Revision 86c9673b

View differences:

libavcodec/ac3enc.c
37 37
#include "audioconvert.h"
38 38

  
39 39

  
40
#define MDCT_NBITS 9
41
#define MDCT_SAMPLES (1 << MDCT_NBITS)
42

  
43 40
/** Maximum number of exponent groups. +1 for separate DC exponent. */
44 41
#define AC3_MAX_EXP_GROUPS 85
45 42

  
......
60 57

  
61 58
typedef struct AC3MDCTContext {
62 59
    AVCodecContext *avctx;                  ///< parent context for av_log()
60
    int nbits;                              ///< log2(transform size)
61
    int16_t *costab;                        ///< FFT cos table
62
    int16_t *sintab;                        ///< FFT sin table
63
    int16_t *xcos1;                         ///< MDCT cos table
64
    int16_t *xsin1;                         ///< MDCT sin table
63 65
    int16_t *rot_tmp;                       ///< temp buffer for pre-rotated samples
64 66
    IComplex *cplx_tmp;                     ///< temp buffer for complex pre-rotated samples
65 67
} AC3MDCTContext;
......
145 147
} AC3EncodeContext;
146 148

  
147 149

  
148
/** MDCT and FFT tables */
149
static int16_t costab[64];
150
static int16_t sintab[64];
151
static int16_t xcos1[128];
152
static int16_t xsin1[128];
153

  
154 150
/**
155 151
 * LUT for number of exponent groups.
156 152
 * exponent_group_tab[exponent strategy-1][number of coefficients]
......
209 205
 */
210 206
static av_cold void mdct_end(AC3MDCTContext *mdct)
211 207
{
208
    mdct->nbits = 0;
209
    av_freep(&mdct->costab);
210
    av_freep(&mdct->sintab);
211
    av_freep(&mdct->xcos1);
212
    av_freep(&mdct->xsin1);
212 213
    av_freep(&mdct->rot_tmp);
213 214
    av_freep(&mdct->cplx_tmp);
214 215
}
......
219 220
 * Initialize FFT tables.
220 221
 * @param ln log2(FFT size)
221 222
 */
222
static av_cold void fft_init(int ln)
223
static av_cold int fft_init(AC3MDCTContext *mdct, int ln)
223 224
{
224 225
    int i, n, n2;
225 226
    float alpha;
......
227 228
    n  = 1 << ln;
228 229
    n2 = n >> 1;
229 230

  
231
    FF_ALLOC_OR_GOTO(mdct->avctx, mdct->costab, n2 * sizeof(*mdct->costab),
232
                     fft_alloc_fail);
233
    FF_ALLOC_OR_GOTO(mdct->avctx, mdct->sintab, n2 * sizeof(*mdct->sintab),
234
                     fft_alloc_fail);
235

  
230 236
    for (i = 0; i < n2; i++) {
231 237
        alpha     = 2.0 * M_PI * i / n;
232
        costab[i] = FIX15(cos(alpha));
233
        sintab[i] = FIX15(sin(alpha));
238
        mdct->costab[i] = FIX15(cos(alpha));
239
        mdct->sintab[i] = FIX15(sin(alpha));
234 240
    }
241

  
242
    return 0;
243
fft_alloc_fail:
244
    mdct_end(mdct);
245
    return AVERROR(ENOMEM);
235 246
}
236 247

  
237 248

  
......
241 252
 */
242 253
static av_cold int mdct_init(AC3MDCTContext *mdct, int nbits)
243 254
{
244
    int i, n, n4;
255
    int i, n, n4, ret;
245 256

  
246 257
    n  = 1 << nbits;
247 258
    n4 = n >> 2;
248 259

  
249
    fft_init(nbits - 2);
260
    mdct->nbits = nbits;
261

  
262
    ret = fft_init(mdct, nbits - 2);
263
    if (ret)
264
        return ret;
250 265

  
266
    FF_ALLOC_OR_GOTO(mdct->avctx, mdct->xcos1,    n4 * sizeof(*mdct->xcos1),
267
                     mdct_alloc_fail);
268
    FF_ALLOC_OR_GOTO(mdct->avctx, mdct->xsin1 ,   n4 * sizeof(*mdct->xsin1),
269
                     mdct_alloc_fail);
251 270
    FF_ALLOC_OR_GOTO(mdct->avctx, mdct->rot_tmp,  n  * sizeof(*mdct->rot_tmp),
252 271
                     mdct_alloc_fail);
253 272
    FF_ALLOC_OR_GOTO(mdct->avctx, mdct->cplx_tmp, n4 * sizeof(*mdct->cplx_tmp),
......
255 274

  
256 275
    for (i = 0; i < n4; i++) {
257 276
        float alpha = 2.0 * M_PI * (i + 1.0 / 8.0) / n;
258
        xcos1[i] = FIX15(-cos(alpha));
259
        xsin1[i] = FIX15(-sin(alpha));
277
        mdct->xcos1[i] = FIX15(-cos(alpha));
278
        mdct->xsin1[i] = FIX15(-sin(alpha));
260 279
    }
261 280

  
262 281
    return 0;
263 282
mdct_alloc_fail:
283
    mdct_end(mdct);
264 284
    return AVERROR(ENOMEM);
265 285
}
266 286

  
......
293 313
 * @param z  complex input/output samples
294 314
 * @param ln log2(FFT size)
295 315
 */
296
static void fft(IComplex *z, int ln)
316
static void fft(AC3MDCTContext *mdct, IComplex *z, int ln)
297 317
{
298 318
    int j, l, np, np2;
299 319
    int nblocks, nloops;
......
345 365
            p++;
346 366
            q++;
347 367
            for(l = nblocks; l < np2; l += nblocks) {
348
                CMUL(tmp_re, tmp_im, costab[l], -sintab[l], q->re, q->im);
368
                CMUL(tmp_re, tmp_im, mdct->costab[l], -mdct->sintab[l], q->re, q->im);
349 369
                BF(p->re, p->im, q->re,  q->im,
350 370
                   p->re, p->im, tmp_re, tmp_im);
351 371
                p++;
......
367 387
 */
368 388
static void mdct512(AC3MDCTContext *mdct, int32_t *out, int16_t *in)
369 389
{
370
    int i, re, im;
390
    int i, re, im, n, n2, n4;
371 391
    int16_t *rot = mdct->rot_tmp;
372 392
    IComplex *x  = mdct->cplx_tmp;
373 393

  
394
    n  = 1 << mdct->nbits;
395
    n2 = n >> 1;
396
    n4 = n >> 2;
397

  
374 398
    /* shift to simplify computations */
375
    for (i = 0; i < MDCT_SAMPLES/4; i++)
376
        rot[i] = -in[i + 3*MDCT_SAMPLES/4];
377
    memcpy(&rot[MDCT_SAMPLES/4], &in[0], 3*MDCT_SAMPLES/4*sizeof(*in));
399
    for (i = 0; i <n4; i++)
400
        rot[i] = -in[i + 3*n4];
401
    memcpy(&rot[n4], &in[0], 3*n4*sizeof(*in));
378 402

  
379 403
    /* pre rotation */
380
    for (i = 0; i < MDCT_SAMPLES/4; i++) {
381
        re =  ((int)rot[               2*i] - (int)rot[MDCT_SAMPLES  -1-2*i]) >> 1;
382
        im = -((int)rot[MDCT_SAMPLES/2+2*i] - (int)rot[MDCT_SAMPLES/2-1-2*i]) >> 1;
383
        CMUL(x[i].re, x[i].im, re, im, -xcos1[i], xsin1[i]);
404
    for (i = 0; i < n4; i++) {
405
        re =  ((int)rot[   2*i] - (int)rot[ n-1-2*i]) >> 1;
406
        im = -((int)rot[n2+2*i] - (int)rot[n2-1-2*i]) >> 1;
407
        CMUL(x[i].re, x[i].im, re, im, -mdct->xcos1[i], mdct->xsin1[i]);
384 408
    }
385 409

  
386
    fft(x, MDCT_NBITS - 2);
410
    fft(mdct, x, mdct->nbits - 2);
387 411

  
388 412
    /* post rotation */
389
    for (i = 0; i < MDCT_SAMPLES/4; i++) {
413
    for (i = 0; i < n4; i++) {
390 414
        re = x[i].re;
391 415
        im = x[i].im;
392
        CMUL(out[MDCT_SAMPLES/2-1-2*i], out[2*i], re, im, xsin1[i], xcos1[i]);
416
        CMUL(out[n2-1-2*i], out[2*i], re, im, mdct->xsin1[i], mdct->xcos1[i]);
393 417
    }
394 418
}
395 419

  
......
1824 1848

  
1825 1849
#include "libavutil/lfg.h"
1826 1850

  
1851
#define MDCT_NBITS 9
1852
#define MDCT_SAMPLES (1 << MDCT_NBITS)
1827 1853
#define FN (MDCT_SAMPLES/4)
1828 1854

  
1829 1855

  
1830
static void fft_test(AVLFG *lfg)
1856
static void fft_test(AC3MDCTContext *mdct, AVLFG *lfg)
1831 1857
{
1832 1858
    IComplex in[FN], in1[FN];
1833 1859
    int k, n, i;
......
1838 1864
        in[i].im = av_lfg_get(lfg) % 65535 - 32767;
1839 1865
        in1[i]   = in[i];
1840 1866
    }
1841
    fft(in, 7);
1867
    fft(mdct, in, 7);
1842 1868

  
1843 1869
    /* do it by hand */
1844 1870
    for (k = 0; k < FN; k++) {
......
1855 1881
}
1856 1882

  
1857 1883

  
1858
static void mdct_test(AVLFG *lfg)
1884
static void mdct_test(AC3MDCTContext *mdct, AVLFG *lfg)
1859 1885
{
1860 1886
    int16_t input[MDCT_SAMPLES];
1861 1887
    int32_t output[AC3_MAX_COEFS];
......
1869 1895
        input1[i] = input[i];
1870 1896
    }
1871 1897

  
1872
    mdct512(output, input);
1898
    mdct512(mdct, output, input);
1873 1899

  
1874 1900
    /* do it by hand */
1875 1901
    for (k = 0; k < AC3_MAX_COEFS; k++) {
......
1897 1923
int main(void)
1898 1924
{
1899 1925
    AVLFG lfg;
1926
    AC3MDCTContext mdct;
1900 1927

  
1928
    mdct.avctx = NULL;
1901 1929
    av_log_set_level(AV_LOG_DEBUG);
1902
    mdct_init(9);
1930
    mdct_init(&mdct, 9);
1903 1931

  
1904
    fft_test(&lfg);
1905
    mdct_test(&lfg);
1932
    fft_test(&mdct, &lfg);
1933
    mdct_test(&mdct, &lfg);
1906 1934

  
1907 1935
    return 0;
1908 1936
}

Also available in: Unified diff