ac3enc.c 39.3 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * The simplest AC-3 encoder
3
 * Copyright (c) 2000 Fabrice Bellard
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
21 22

/**
23
 * @file libavcodec/ac3enc.c
24
 * The simplest AC-3 encoder.
Michael Niedermayer's avatar
Michael Niedermayer committed
25
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
26 27
//#define DEBUG
//#define DEBUG_BITALLOC
28
#include "libavutil/crc.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
29
#include "avcodec.h"
30
#include "bitstream.h"
31 32 33 34 35 36 37 38
#include "ac3.h"

typedef struct AC3EncodeContext {
    PutBitContext pb;
    int nb_channels;
    int nb_all_channels;
    int lfe_channel;
    int bit_rate;
39
    unsigned int sample_rate;
40
    unsigned int bitstream_id;
41 42
    unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */
    unsigned int frame_size; /* current frame size in words */
43 44
    unsigned int bits_written;
    unsigned int samples_written;
45
    int sr_shift;
46
    unsigned int frame_size_code;
47
    unsigned int sr_code; /* frequency */
48
    unsigned int channel_mode;
49
    int lfe;
50
    unsigned int bitstream_mode;
51
    short last_samples[AC3_MAX_CHANNELS][256];
52
    unsigned int chbwcod[AC3_MAX_CHANNELS];
53
    int nb_coefs[AC3_MAX_CHANNELS];
54

55
    /* bitrate allocation control */
56
    int slow_gain_code, slow_decay_code, fast_decay_code, db_per_bit_code, floor_code;
57
    AC3BitAllocParameters bit_alloc;
58 59 60
    int coarse_snr_offset;
    int fast_gain_code[AC3_MAX_CHANNELS];
    int fine_snr_offset[AC3_MAX_CHANNELS];
61 62 63
    /* mantissa encoding */
    int mant1_cnt, mant2_cnt, mant4_cnt;
} AC3EncodeContext;
Fabrice Bellard's avatar
Fabrice Bellard committed
64

65 66 67 68
static int16_t costab[64];
static int16_t sintab[64];
static int16_t xcos1[128];
static int16_t xsin1[128];
Fabrice Bellard's avatar
Fabrice Bellard committed
69 70 71 72 73 74 75

#define MDCT_NBITS 9
#define N         (1 << MDCT_NBITS)

/* new exponents are sent if their Norm 1 exceed this number */
#define EXP_DIFF_THRESHOLD 1000

76
static inline int16_t fix15(float a)
Fabrice Bellard's avatar
Fabrice Bellard committed
77 78 79 80 81
{
    int v;
    v = (int)(a * (float)(1 << 15));
    if (v < -32767)
        v = -32767;
82
    else if (v > 32767)
Fabrice Bellard's avatar
Fabrice Bellard committed
83 84 85 86 87 88 89 90
        v = 32767;
    return v;
}

typedef struct IComplex {
    short re,im;
} IComplex;

91
static av_cold void fft_init(int ln)
Fabrice Bellard's avatar
Fabrice Bellard committed
92
{
93
    int i, n;
Fabrice Bellard's avatar
Fabrice Bellard committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
    float alpha;

    n = 1 << ln;

    for(i=0;i<(n/2);i++) {
        alpha = 2 * M_PI * (float)i / (float)n;
        costab[i] = fix15(cos(alpha));
        sintab[i] = fix15(sin(alpha));
    }
}

/* butter fly op */
#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \
{\
  int ax, ay, bx, by;\
  bx=pre1;\
  by=pim1;\
  ax=qre1;\
  ay=qim1;\
  pre = (bx + ax) >> 1;\
  pim = (by + ay) >> 1;\
  qre = (bx - ax) >> 1;\
  qim = (by - ay) >> 1;\
}

#define MUL16(a,b) ((a) * (b))

#define CMUL(pre, pim, are, aim, bre, bim) \
{\
   pre = (MUL16(are, bre) - MUL16(aim, bim)) >> 15;\
   pim = (MUL16(are, bim) + MUL16(bre, aim)) >> 15;\
}


/* do a 2^n point complex fft on 2^ln points. */
static void fft(IComplex *z, int ln)
{
131 132
    int        j, l, np, np2;
    int        nblocks, nloops;
Fabrice Bellard's avatar
Fabrice Bellard committed
133 134 135 136 137 138 139
    register IComplex *p,*q;
    int tmp_re, tmp_im;

    np = 1 << ln;

    /* reverse */
    for(j=0;j<np;j++) {
140
        int k = ff_reverse[j] >> (8 - ln);
141 142
        if (k < j)
            FFSWAP(IComplex, z[k], z[j]);
Fabrice Bellard's avatar
Fabrice Bellard committed
143 144 145 146 147 148 149
    }

    /* pass 0 */

    p=&z[0];
    j=(np >> 1);
    do {
150
        BF(p[0].re, p[0].im, p[1].re, p[1].im,
Fabrice Bellard's avatar
Fabrice Bellard committed
151 152 153 154 155 156 157 158 159
           p[0].re, p[0].im, p[1].re, p[1].im);
        p+=2;
    } while (--j != 0);

    /* pass 1 */

    p=&z[0];
    j=np >> 2;
    do {
160
        BF(p[0].re, p[0].im, p[2].re, p[2].im,
Fabrice Bellard's avatar
Fabrice Bellard committed
161
           p[0].re, p[0].im, p[2].re, p[2].im);
162
        BF(p[1].re, p[1].im, p[3].re, p[3].im,
Fabrice Bellard's avatar
Fabrice Bellard committed
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
           p[1].re, p[1].im, p[3].im, -p[3].re);
        p+=4;
    } while (--j != 0);

    /* pass 2 .. ln-1 */

    nblocks = np >> 3;
    nloops = 1 << 2;
    np2 = np >> 1;
    do {
        p = z;
        q = z + nloops;
        for (j = 0; j < nblocks; ++j) {

            BF(p->re, p->im, q->re, q->im,
               p->re, p->im, q->re, q->im);
179

Fabrice Bellard's avatar
Fabrice Bellard committed
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
            p++;
            q++;
            for(l = nblocks; l < np2; l += nblocks) {
                CMUL(tmp_re, tmp_im, costab[l], -sintab[l], q->re, q->im);
                BF(p->re, p->im, q->re, q->im,
                   p->re, p->im, tmp_re, tmp_im);
                p++;
                q++;
            }
            p += nloops;
            q += nloops;
        }
        nblocks = nblocks >> 1;
        nloops = nloops << 1;
    } while (nblocks != 0);
}

/* do a 512 point mdct */
198
static void mdct512(int32_t *out, int16_t *in)
Fabrice Bellard's avatar
Fabrice Bellard committed
199 200
{
    int i, re, im, re1, im1;
201
    int16_t rot[N];
Fabrice Bellard's avatar
Fabrice Bellard committed
202 203 204 205 206 207 208
    IComplex x[N/4];

    /* shift to simplify computations */
    for(i=0;i<N/4;i++)
        rot[i] = -in[i + 3*N/4];
    for(i=N/4;i<N;i++)
        rot[i] = in[i - N/4];
209

Fabrice Bellard's avatar
Fabrice Bellard committed
210 211 212 213 214 215 216 217
    /* pre rotation */
    for(i=0;i<N/4;i++) {
        re = ((int)rot[2*i] - (int)rot[N-1-2*i]) >> 1;
        im = -((int)rot[N/2+2*i] - (int)rot[N/2-1-2*i]) >> 1;
        CMUL(x[i].re, x[i].im, re, im, -xcos1[i], xsin1[i]);
    }

    fft(x, MDCT_NBITS - 2);
218

Fabrice Bellard's avatar
Fabrice Bellard committed
219 220 221 222 223 224 225 226 227 228 229
    /* post rotation */
    for(i=0;i<N/4;i++) {
        re = x[i].re;
        im = x[i].im;
        CMUL(re1, im1, re, im, xsin1[i], xcos1[i]);
        out[2*i] = im1;
        out[N/2-1-2*i] = re1;
    }
}

/* XXX: use another norm ? */
230
static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
231 232 233 234 235 236 237 238 239
{
    int sum, i;
    sum = 0;
    for(i=0;i<n;i++) {
        sum += abs(exp1[i] - exp2[i]);
    }
    return sum;
}

240 241
static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
                                 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
242
                                 int ch, int is_lfe)
Fabrice Bellard's avatar
Fabrice Bellard committed
243 244 245
{
    int i, j;
    int exp_diff;
246

Fabrice Bellard's avatar
Fabrice Bellard committed
247 248 249 250 251
    /* estimate if the exponent variation & decide if they should be
       reused in the next frame */
    exp_strategy[0][ch] = EXP_NEW;
    for(i=1;i<NB_BLOCKS;i++) {
        exp_diff = calc_exp_diff(exp[i][ch], exp[i-1][ch], N/2);
252
#ifdef DEBUG
253
        av_log(NULL, AV_LOG_DEBUG, "exp_diff=%d\n", exp_diff);
Fabrice Bellard's avatar
Fabrice Bellard committed
254 255 256 257 258 259
#endif
        if (exp_diff > EXP_DIFF_THRESHOLD)
            exp_strategy[i][ch] = EXP_NEW;
        else
            exp_strategy[i][ch] = EXP_REUSE;
    }
260
    if (is_lfe)
261
        return;
262

Fabrice Bellard's avatar
Fabrice Bellard committed
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
    /* now select the encoding strategy type : if exponents are often
       recoded, we use a coarse encoding */
    i = 0;
    while (i < NB_BLOCKS) {
        j = i + 1;
        while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE)
            j++;
        switch(j - i) {
        case 1:
            exp_strategy[i][ch] = EXP_D45;
            break;
        case 2:
        case 3:
            exp_strategy[i][ch] = EXP_D25;
            break;
        default:
            exp_strategy[i][ch] = EXP_D15;
            break;
        }
282
        i = j;
Fabrice Bellard's avatar
Fabrice Bellard committed
283 284 285 286
    }
}

/* set exp[i] to min(exp[i], exp1[i]) */
287
static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
288 289 290 291 292 293 294 295
{
    int i;

    for(i=0;i<n;i++) {
        if (exp1[i] < exp[i])
            exp[i] = exp1[i];
    }
}
296

Fabrice Bellard's avatar
Fabrice Bellard committed
297 298
/* update the exponents so that they are the ones the decoder will
   decode. Return the number of bits used to code the exponents */
299 300
static int encode_exp(uint8_t encoded_exp[N/2],
                      uint8_t exp[N/2],
Fabrice Bellard's avatar
Fabrice Bellard committed
301 302 303
                      int nb_exps,
                      int exp_strategy)
{
304
    int group_size, nb_groups, i, j, k, exp_min;
305
    uint8_t exp1[N/2];
Fabrice Bellard's avatar
Fabrice Bellard committed
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338

    switch(exp_strategy) {
    case EXP_D15:
        group_size = 1;
        break;
    case EXP_D25:
        group_size = 2;
        break;
    default:
    case EXP_D45:
        group_size = 4;
        break;
    }
    nb_groups = ((nb_exps + (group_size * 3) - 4) / (3 * group_size)) * 3;

    /* for each group, compute the minimum exponent */
    exp1[0] = exp[0]; /* DC exponent is handled separately */
    k = 1;
    for(i=1;i<=nb_groups;i++) {
        exp_min = exp[k];
        assert(exp_min >= 0 && exp_min <= 24);
        for(j=1;j<group_size;j++) {
            if (exp[k+j] < exp_min)
                exp_min = exp[k+j];
        }
        exp1[i] = exp_min;
        k += group_size;
    }

    /* constraint for DC exponent */
    if (exp1[0] > 15)
        exp1[0] = 15;

339 340 341
    /* Decrease the delta between each groups to within 2
     * so that they can be differentially encoded */
    for (i=1;i<=nb_groups;i++)
342
        exp1[i] = FFMIN(exp1[i], exp1[i-1] + 2);
343
    for (i=nb_groups-1;i>=0;i--)
344
        exp1[i] = FFMIN(exp1[i], exp1[i+1] + 2);
345

Fabrice Bellard's avatar
Fabrice Bellard committed
346 347 348 349 350 351 352 353 354
    /* now we have the exponent values the decoder will see */
    encoded_exp[0] = exp1[0];
    k = 1;
    for(i=1;i<=nb_groups;i++) {
        for(j=0;j<group_size;j++) {
            encoded_exp[k+j] = exp1[i];
        }
        k += group_size;
    }
355

Fabrice Bellard's avatar
Fabrice Bellard committed
356
#if defined(DEBUG)
357
    av_log(NULL, AV_LOG_DEBUG, "exponents: strategy=%d\n", exp_strategy);
Fabrice Bellard's avatar
Fabrice Bellard committed
358
    for(i=0;i<=nb_groups * group_size;i++) {
359
        av_log(NULL, AV_LOG_DEBUG, "%d ", encoded_exp[i]);
Fabrice Bellard's avatar
Fabrice Bellard committed
360
    }
361
    av_log(NULL, AV_LOG_DEBUG, "\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
362 363 364 365 366 367
#endif

    return 4 + (nb_groups / 3) * 7;
}

/* return the size in bits taken by the mantissa */
368
static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs)
Fabrice Bellard's avatar
Fabrice Bellard committed
369 370 371 372 373 374 375 376 377 378 379 380
{
    int bits, mant, i;

    bits = 0;
    for(i=0;i<nb_coefs;i++) {
        mant = m[i];
        switch(mant) {
        case 0:
            /* nothing */
            break;
        case 1:
            /* 3 mantissa in 5 bits */
381
            if (s->mant1_cnt == 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
382 383 384 385 386 387
                bits += 5;
            if (++s->mant1_cnt == 3)
                s->mant1_cnt = 0;
            break;
        case 2:
            /* 3 mantissa in 7 bits */
388
            if (s->mant2_cnt == 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
389 390 391 392 393 394 395 396 397 398 399
                bits += 7;
            if (++s->mant2_cnt == 3)
                s->mant2_cnt = 0;
            break;
        case 3:
            bits += 3;
            break;
        case 4:
            /* 2 mantissa in 7 bits */
            if (s->mant4_cnt == 0)
                bits += 7;
400
            if (++s->mant4_cnt == 2)
Fabrice Bellard's avatar
Fabrice Bellard committed
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
                s->mant4_cnt = 0;
            break;
        case 14:
            bits += 14;
            break;
        case 15:
            bits += 16;
            break;
        default:
            bits += mant - 1;
            break;
        }
    }
    return bits;
}


418 419 420 421 422 423 424
static void bit_alloc_masking(AC3EncodeContext *s,
                              uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
                              uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
                              int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
                              int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50])
{
    int blk, ch;
425
    int16_t band_psd[NB_BLOCKS][AC3_MAX_CHANNELS][50];
426 427 428 429 430 431 432 433 434

    for(blk=0; blk<NB_BLOCKS; blk++) {
        for(ch=0;ch<s->nb_all_channels;ch++) {
            if(exp_strategy[blk][ch] == EXP_REUSE) {
                memcpy(psd[blk][ch], psd[blk-1][ch], (N/2)*sizeof(int16_t));
                memcpy(mask[blk][ch], mask[blk-1][ch], 50*sizeof(int16_t));
            } else {
                ff_ac3_bit_alloc_calc_psd(encoded_exp[blk][ch], 0,
                                          s->nb_coefs[ch],
435 436
                                          psd[blk][ch], band_psd[blk][ch]);
                ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, band_psd[blk][ch],
437
                                           0, s->nb_coefs[ch],
438
                                           ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
439
                                           ch == s->lfe_channel,
440
                                           DBA_NONE, 0, NULL, NULL, NULL,
441 442 443 444 445 446
                                           mask[blk][ch]);
            }
        }
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
447
static int bit_alloc(AC3EncodeContext *s,
448 449
                     int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50],
                     int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
450
                     uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
451
                     int frame_bits, int coarse_snr_offset, int fine_snr_offset)
Fabrice Bellard's avatar
Fabrice Bellard committed
452 453
{
    int i, ch;
454
    int snr_offset;
Justin Ruggles's avatar
Justin Ruggles committed
455

456
    snr_offset = (((coarse_snr_offset - 15) << 4) + fine_snr_offset) << 2;
Fabrice Bellard's avatar
Fabrice Bellard committed
457 458 459 460 461 462

    /* compute size */
    for(i=0;i<NB_BLOCKS;i++) {
        s->mant1_cnt = 0;
        s->mant2_cnt = 0;
        s->mant4_cnt = 0;
463
        for(ch=0;ch<s->nb_all_channels;ch++) {
464
            ff_ac3_bit_alloc_calc_bap(mask[i][ch], psd[i][ch], 0,
465
                                      s->nb_coefs[ch], snr_offset,
466 467
                                      s->bit_alloc.floor, ff_ac3_bap_tab,
                                      bap[i][ch]);
468
            frame_bits += compute_mantissa_size(s, bap[i][ch],
Fabrice Bellard's avatar
Fabrice Bellard committed
469 470 471 472
                                                 s->nb_coefs[ch]);
        }
    }
#if 0
473
    printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n",
474
           coarse_snr_offset, fine_snr_offset, frame_bits,
Fabrice Bellard's avatar
Fabrice Bellard committed
475 476 477 478 479 480 481 482
           16 * s->frame_size - ((frame_bits + 7) & ~7));
#endif
    return 16 * s->frame_size - frame_bits;
}

#define SNR_INC1 4

static int compute_bit_allocation(AC3EncodeContext *s,
483 484 485
                                  uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
                                  uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
                                  uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
Fabrice Bellard's avatar
Fabrice Bellard committed
486 487 488
                                  int frame_bits)
{
    int i, ch;
489
    int coarse_snr_offset, fine_snr_offset;
490
    uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
491 492
    int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
    int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50];
493
    static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
Fabrice Bellard's avatar
Fabrice Bellard committed
494 495

    /* init default parameters */
496 497 498 499 500
    s->slow_decay_code = 2;
    s->fast_decay_code = 1;
    s->slow_gain_code = 1;
    s->db_per_bit_code = 2;
    s->floor_code = 4;
501
    for(ch=0;ch<s->nb_all_channels;ch++)
502
        s->fast_gain_code[ch] = 4;
503

Fabrice Bellard's avatar
Fabrice Bellard committed
504
    /* compute real values */
505 506 507 508 509 510 511
    s->bit_alloc.sr_code = s->sr_code;
    s->bit_alloc.sr_shift = s->sr_shift;
    s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->sr_shift;
    s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->sr_shift;
    s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
    s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
    s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
512

Fabrice Bellard's avatar
Fabrice Bellard committed
513 514
    /* header size */
    frame_bits += 65;
515
    // if (s->channel_mode == 2)
516
    //    frame_bits += 2;
517
    frame_bits += frame_bits_inc[s->channel_mode];
Fabrice Bellard's avatar
Fabrice Bellard committed
518 519 520

    /* audio blocks */
    for(i=0;i<NB_BLOCKS;i++) {
521
        frame_bits += s->nb_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */
522
        if (s->channel_mode == AC3_CHMODE_STEREO) {
523
            frame_bits++; /* rematstr */
524 525
            if(i==0) frame_bits += 4;
        }
526
        frame_bits += 2 * s->nb_channels; /* chexpstr[2] * c */
527 528
        if (s->lfe)
            frame_bits++; /* lfeexpstr */
Fabrice Bellard's avatar
Fabrice Bellard committed
529 530
        for(ch=0;ch<s->nb_channels;ch++) {
            if (exp_strategy[i][ch] != EXP_REUSE)
531
                frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */
Fabrice Bellard's avatar
Fabrice Bellard committed
532 533 534 535 536 537 538
        }
        frame_bits++; /* baie */
        frame_bits++; /* snr */
        frame_bits += 2; /* delta / skip */
    }
    frame_bits++; /* cplinu for block 0 */
    /* bit alloc info */
539 540 541 542
    /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */
    /* csnroffset[6] */
    /* (fsnoffset[4] + fgaincod[4]) * c */
    frame_bits += 2*4 + 3 + 6 + s->nb_all_channels * (4 + 3);
Fabrice Bellard's avatar
Fabrice Bellard committed
543

544 545 546
    /* auxdatae, crcrsv */
    frame_bits += 2;

Fabrice Bellard's avatar
Fabrice Bellard committed
547 548 549
    /* CRC */
    frame_bits += 16;

550 551 552
    /* calculate psd and masking curve before doing bit allocation */
    bit_alloc_masking(s, encoded_exp, exp_strategy, psd, mask);

Fabrice Bellard's avatar
Fabrice Bellard committed
553 554 555
    /* now the big work begins : do the bit allocation. Modify the snr
       offset until we can pack everything in the requested frame size */

556 557 558 559 560
    coarse_snr_offset = s->coarse_snr_offset;
    while (coarse_snr_offset >= 0 &&
           bit_alloc(s, mask, psd, bap, frame_bits, coarse_snr_offset, 0) < 0)
        coarse_snr_offset -= SNR_INC1;
    if (coarse_snr_offset < 0) {
561
        av_log(NULL, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
562
        return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
563
    }
564
    while ((coarse_snr_offset + SNR_INC1) <= 63 &&
565
           bit_alloc(s, mask, psd, bap1, frame_bits,
566 567
                     coarse_snr_offset + SNR_INC1, 0) >= 0) {
        coarse_snr_offset += SNR_INC1;
Fabrice Bellard's avatar
Fabrice Bellard committed
568 569
        memcpy(bap, bap1, sizeof(bap1));
    }
570 571 572
    while ((coarse_snr_offset + 1) <= 63 &&
           bit_alloc(s, mask, psd, bap1, frame_bits, coarse_snr_offset + 1, 0) >= 0) {
        coarse_snr_offset++;
Fabrice Bellard's avatar
Fabrice Bellard committed
573 574 575
        memcpy(bap, bap1, sizeof(bap1));
    }

576 577
    fine_snr_offset = 0;
    while ((fine_snr_offset + SNR_INC1) <= 15 &&
578
           bit_alloc(s, mask, psd, bap1, frame_bits,
579 580
                     coarse_snr_offset, fine_snr_offset + SNR_INC1) >= 0) {
        fine_snr_offset += SNR_INC1;
Fabrice Bellard's avatar
Fabrice Bellard committed
581 582
        memcpy(bap, bap1, sizeof(bap1));
    }
583
    while ((fine_snr_offset + 1) <= 15 &&
584
           bit_alloc(s, mask, psd, bap1, frame_bits,
585 586
                     coarse_snr_offset, fine_snr_offset + 1) >= 0) {
        fine_snr_offset++;
Fabrice Bellard's avatar
Fabrice Bellard committed
587 588
        memcpy(bap, bap1, sizeof(bap1));
    }
589

590
    s->coarse_snr_offset = coarse_snr_offset;
591
    for(ch=0;ch<s->nb_all_channels;ch++)
592
        s->fine_snr_offset[ch] = fine_snr_offset;
Fabrice Bellard's avatar
Fabrice Bellard committed
593 594 595 596 597
#if defined(DEBUG_BITALLOC)
    {
        int j;

        for(i=0;i<6;i++) {
598
            for(ch=0;ch<s->nb_all_channels;ch++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
599 600 601 602 603 604 605 606 607 608 609 610 611
                printf("Block #%d Ch%d:\n", i, ch);
                printf("bap=");
                for(j=0;j<s->nb_coefs[ch];j++) {
                    printf("%d ",bap[i][ch][j]);
                }
                printf("\n");
            }
        }
    }
#endif
    return 0;
}

612
static av_cold int AC3_encode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
613 614 615 616 617
{
    int freq = avctx->sample_rate;
    int bitrate = avctx->bit_rate;
    int channels = avctx->channels;
    AC3EncodeContext *s = avctx->priv_data;
618
    int i, j, ch;
Fabrice Bellard's avatar
Fabrice Bellard committed
619
    float alpha;
620
    int bw_code;
621
    static const uint8_t channel_mode_defs[6] = {
622 623 624 625 626 627
        0x01, /* C */
        0x02, /* L R */
        0x03, /* L C R */
        0x06, /* L R SL SR */
        0x07, /* L C R SL SR */
        0x07, /* L C R SL SR (+LFE) */
628
    };
Fabrice Bellard's avatar
Fabrice Bellard committed
629 630

    avctx->frame_size = AC3_FRAME_SIZE;
631

632 633
    ac3_common_init();

Fabrice Bellard's avatar
Fabrice Bellard committed
634
    /* number of channels */
635
    if (channels < 1 || channels > 6)
636
        return -1;
637
    s->channel_mode = channel_mode_defs[channels - 1];
638 639 640 641
    s->lfe = (channels == 6) ? 1 : 0;
    s->nb_all_channels = channels;
    s->nb_channels = channels > 5 ? 5 : channels;
    s->lfe_channel = s->lfe ? 5 : -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
642 643 644

    /* frequency */
    for(i=0;i<3;i++) {
645
        for(j=0;j<3;j++)
646
            if ((ff_ac3_sample_rate_tab[j] >> i) == freq)
Fabrice Bellard's avatar
Fabrice Bellard committed
647 648 649
                goto found;
    }
    return -1;
650
 found:
Fabrice Bellard's avatar
Fabrice Bellard committed
651
    s->sample_rate = freq;
652 653
    s->sr_shift = i;
    s->sr_code = j;
654 655
    s->bitstream_id = 8 + s->sr_shift;
    s->bitstream_mode = 0; /* complete main audio service */
Fabrice Bellard's avatar
Fabrice Bellard committed
656 657 658

    /* bitrate & frame size */
    for(i=0;i<19;i++) {
659
        if ((ff_ac3_bitrate_tab[i] >> s->sr_shift)*1000 == bitrate)
Fabrice Bellard's avatar
Fabrice Bellard committed
660 661 662 663 664
            break;
    }
    if (i == 19)
        return -1;
    s->bit_rate = bitrate;
665 666
    s->frame_size_code = i << 1;
    s->frame_size_min = ff_ac3_frame_size_tab[s->frame_size_code][s->sr_code];
667 668
    s->bits_written = 0;
    s->samples_written = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
669
    s->frame_size = s->frame_size_min;
670

Fabrice Bellard's avatar
Fabrice Bellard committed
671
    /* bit allocation init */
672 673 674 675 676 677 678
    if(avctx->cutoff) {
        /* calculate bandwidth based on user-specified cutoff frequency */
        int cutoff = av_clip(avctx->cutoff, 1, s->sample_rate >> 1);
        int fbw_coeffs = cutoff * 512 / s->sample_rate;
        bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
    } else {
        /* use default bandwidth setting */
Fabrice Bellard's avatar
Fabrice Bellard committed
679
        /* XXX: should compute the bandwidth according to the frame
680
           size, so that we avoid annoying high frequency artifacts */
681 682 683 684 685 686
        bw_code = 50;
    }
    for(ch=0;ch<s->nb_channels;ch++) {
        /* bandwidth for each channel */
        s->chbwcod[ch] = bw_code;
        s->nb_coefs[ch] = bw_code * 3 + 73;
Fabrice Bellard's avatar
Fabrice Bellard committed
687
    }
688
    if (s->lfe) {
689
        s->nb_coefs[s->lfe_channel] = 7; /* fixed */
690
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
691
    /* initial snr offset */
692
    s->coarse_snr_offset = 40;
Fabrice Bellard's avatar
Fabrice Bellard committed
693 694 695 696 697 698 699 700 701

    /* mdct init */
    fft_init(MDCT_NBITS - 2);
    for(i=0;i<N/4;i++) {
        alpha = 2 * M_PI * (i + 1.0 / 8.0) / (float)N;
        xcos1[i] = fix15(-cos(alpha));
        xsin1[i] = fix15(-sin(alpha));
    }

702 703
    avctx->coded_frame= avcodec_alloc_frame();
    avctx->coded_frame->key_frame= 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
704 705 706 707

    return 0;
}

708
/* output the AC-3 frame header */
Fabrice Bellard's avatar
Fabrice Bellard committed
709 710
static void output_frame_header(AC3EncodeContext *s, unsigned char *frame)
{
711
    init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
Fabrice Bellard's avatar
Fabrice Bellard committed
712 713 714

    put_bits(&s->pb, 16, 0x0b77); /* frame header */
    put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
715
    put_bits(&s->pb, 2, s->sr_code);
716 717 718 719 720
    put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min));
    put_bits(&s->pb, 5, s->bitstream_id);
    put_bits(&s->pb, 3, s->bitstream_mode);
    put_bits(&s->pb, 3, s->channel_mode);
    if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
721
        put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */
722
    if (s->channel_mode & 0x04)
723
        put_bits(&s->pb, 2, 1); /* XXX -6 dB */
724
    if (s->channel_mode == AC3_CHMODE_STEREO)
Fabrice Bellard's avatar
Fabrice Bellard committed
725
        put_bits(&s->pb, 2, 0); /* surround not indicated */
726
    put_bits(&s->pb, 1, s->lfe); /* LFE */
Fabrice Bellard's avatar
Fabrice Bellard committed
727 728 729 730 731 732 733 734
    put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */
    put_bits(&s->pb, 1, 0); /* no compression control word */
    put_bits(&s->pb, 1, 0); /* no lang code */
    put_bits(&s->pb, 1, 0); /* no audio production info */
    put_bits(&s->pb, 1, 0); /* no copyright */
    put_bits(&s->pb, 1, 1); /* original bitstream */
    put_bits(&s->pb, 1, 0); /* no time code 1 */
    put_bits(&s->pb, 1, 0); /* no time code 2 */
Justin Ruggles's avatar
Justin Ruggles committed
735
    put_bits(&s->pb, 1, 0); /* no additional bit stream info */
Fabrice Bellard's avatar
Fabrice Bellard committed
736 737 738 739 740 741 742 743
}

/* symetric quantization on 'levels' levels */
static inline int sym_quant(int c, int e, int levels)
{
    int v;

    if (c >= 0) {
744 745
        v = (levels * (c << e)) >> 24;
        v = (v + 1) >> 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
746 747
        v = (levels >> 1) + v;
    } else {
748 749
        v = (levels * ((-c) << e)) >> 24;
        v = (v + 1) >> 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
        v = (levels >> 1) - v;
    }
    assert (v >= 0 && v < levels);
    return v;
}

/* asymetric quantization on 2^qbits levels */
static inline int asym_quant(int c, int e, int qbits)
{
    int lshift, m, v;

    lshift = e + qbits - 24;
    if (lshift >= 0)
        v = c << lshift;
    else
        v = c >> (-lshift);
    /* rounding */
    v = (v + 1) >> 1;
    m = (1 << (qbits-1));
    if (v >= m)
        v = m - 1;
    assert(v >= -m);
    return v & ((1 << qbits)-1);
}

775
/* Output one audio block. There are NB_BLOCKS audio blocks in one AC-3
Fabrice Bellard's avatar
Fabrice Bellard committed
776 777
   frame */
static void output_audio_block(AC3EncodeContext *s,
778 779 780 781 782
                               uint8_t exp_strategy[AC3_MAX_CHANNELS],
                               uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2],
                               uint8_t bap[AC3_MAX_CHANNELS][N/2],
                               int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2],
                               int8_t global_exp[AC3_MAX_CHANNELS],
Fabrice Bellard's avatar
Fabrice Bellard committed
783 784
                               int block_num)
{
785
    int ch, nb_groups, group_size, i, baie, rbnd;
786 787
    uint8_t *p;
    uint16_t qmant[AC3_MAX_CHANNELS][N/2];
Fabrice Bellard's avatar
Fabrice Bellard committed
788 789
    int exp0, exp1;
    int mant1_cnt, mant2_cnt, mant4_cnt;
790
    uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
791 792
    int delta0, delta1, delta2;

793
    for(ch=0;ch<s->nb_channels;ch++)
Fabrice Bellard's avatar
Fabrice Bellard committed
794
        put_bits(&s->pb, 1, 0); /* 512 point MDCT */
795
    for(ch=0;ch<s->nb_channels;ch++)
Fabrice Bellard's avatar
Fabrice Bellard committed
796 797 798 799 800 801 802 803 804 805 806
        put_bits(&s->pb, 1, 1); /* no dither */
    put_bits(&s->pb, 1, 0); /* no dynamic range */
    if (block_num == 0) {
        /* for block 0, even if no coupling, we must say it. This is a
           waste of bit :-) */
        put_bits(&s->pb, 1, 1); /* coupling strategy present */
        put_bits(&s->pb, 1, 0); /* no coupling strategy */
    } else {
        put_bits(&s->pb, 1, 0); /* no new coupling strategy */
    }

807
    if (s->channel_mode == AC3_CHMODE_STEREO)
808
      {
809 810 811 812 813 814 815 816 817 818 819 820 821 822
        if(block_num==0)
          {
            /* first block must define rematrixing (rematstr)  */
            put_bits(&s->pb, 1, 1);

            /* dummy rematrixing rematflg(1:4)=0 */
            for (rbnd=0;rbnd<4;rbnd++)
              put_bits(&s->pb, 1, 0);
          }
        else
          {
            /* no matrixing (but should be used in the future) */
            put_bits(&s->pb, 1, 0);
          }
823
      }
Fabrice Bellard's avatar
Fabrice Bellard committed
824

825
#if defined(DEBUG)
Fabrice Bellard's avatar
Fabrice Bellard committed
826
    {
827
      static int count = 0;
828
      av_log(NULL, AV_LOG_DEBUG, "Block #%d (%d)\n", block_num, count++);
Fabrice Bellard's avatar
Fabrice Bellard committed
829 830 831 832 833 834
    }
#endif
    /* exponent strategy */
    for(ch=0;ch<s->nb_channels;ch++) {
        put_bits(&s->pb, 2, exp_strategy[ch]);
    }
835

836
    if (s->lfe) {
837
        put_bits(&s->pb, 1, exp_strategy[s->lfe_channel]);
838 839
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
840 841 842 843
    for(ch=0;ch<s->nb_channels;ch++) {
        if (exp_strategy[ch] != EXP_REUSE)
            put_bits(&s->pb, 6, s->chbwcod[ch]);
    }
844

Fabrice Bellard's avatar
Fabrice Bellard committed
845
    /* exponents */
846
    for (ch = 0; ch < s->nb_all_channels; ch++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
847 848 849 850 851 852 853 854 855 856 857 858 859 860
        switch(exp_strategy[ch]) {
        case EXP_REUSE:
            continue;
        case EXP_D15:
            group_size = 1;
            break;
        case EXP_D25:
            group_size = 2;
            break;
        default:
        case EXP_D45:
            group_size = 4;
            break;
        }
861
        nb_groups = (s->nb_coefs[ch] + (group_size * 3) - 4) / (3 * group_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
        p = encoded_exp[ch];

        /* first exponent */
        exp1 = *p++;
        put_bits(&s->pb, 4, exp1);

        /* next ones are delta encoded */
        for(i=0;i<nb_groups;i++) {
            /* merge three delta in one code */
            exp0 = exp1;
            exp1 = p[0];
            p += group_size;
            delta0 = exp1 - exp0 + 2;

            exp0 = exp1;
            exp1 = p[0];
            p += group_size;
            delta1 = exp1 - exp0 + 2;

            exp0 = exp1;
            exp1 = p[0];
            p += group_size;
            delta2 = exp1 - exp0 + 2;

            put_bits(&s->pb, 7, ((delta0 * 5 + delta1) * 5) + delta2);
        }

889 890
        if (ch != s->lfe_channel)
            put_bits(&s->pb, 2, 0); /* no gain range info */
Fabrice Bellard's avatar
Fabrice Bellard committed
891 892 893 894 895 896
    }

    /* bit allocation info */
    baie = (block_num == 0);
    put_bits(&s->pb, 1, baie);
    if (baie) {
897 898 899 900 901
        put_bits(&s->pb, 2, s->slow_decay_code);
        put_bits(&s->pb, 2, s->fast_decay_code);
        put_bits(&s->pb, 2, s->slow_gain_code);
        put_bits(&s->pb, 2, s->db_per_bit_code);
        put_bits(&s->pb, 3, s->floor_code);
Fabrice Bellard's avatar
Fabrice Bellard committed
902 903 904 905 906
    }

    /* snr offset */
    put_bits(&s->pb, 1, baie); /* always present with bai */
    if (baie) {
907
        put_bits(&s->pb, 6, s->coarse_snr_offset);
908
        for(ch=0;ch<s->nb_all_channels;ch++) {
909 910
            put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
            put_bits(&s->pb, 3, s->fast_gain_code[ch]);
Fabrice Bellard's avatar
Fabrice Bellard committed
911 912
        }
    }
913

Fabrice Bellard's avatar
Fabrice Bellard committed
914 915 916 917 918 919 920 921 922 923 924
    put_bits(&s->pb, 1, 0); /* no delta bit allocation */
    put_bits(&s->pb, 1, 0); /* no data to skip */

    /* mantissa encoding : we use two passes to handle the grouping. A
       one pass method may be faster, but it would necessitate to
       modify the output stream. */

    /* first pass: quantize */
    mant1_cnt = mant2_cnt = mant4_cnt = 0;
    qmant1_ptr = qmant2_ptr = qmant4_ptr = NULL;

925
    for (ch = 0; ch < s->nb_all_channels; ch++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
        int b, c, e, v;

        for(i=0;i<s->nb_coefs[ch];i++) {
            c = mdct_coefs[ch][i];
            e = encoded_exp[ch][i] - global_exp[ch];
            b = bap[ch][i];
            switch(b) {
            case 0:
                v = 0;
                break;
            case 1:
                v = sym_quant(c, e, 3);
                switch(mant1_cnt) {
                case 0:
                    qmant1_ptr = &qmant[ch][i];
                    v = 9 * v;
                    mant1_cnt = 1;
                    break;
                case 1:
                    *qmant1_ptr += 3 * v;
                    mant1_cnt = 2;
                    v = 128;
                    break;
                default:
                    *qmant1_ptr += v;
                    mant1_cnt = 0;
                    v = 128;
                    break;
                }
                break;
            case 2:
                v = sym_quant(c, e, 5);
                switch(mant2_cnt) {
                case 0:
                    qmant2_ptr = &qmant[ch][i];
                    v = 25 * v;
                    mant2_cnt = 1;
                    break;
                case 1:
                    *qmant2_ptr += 5 * v;
                    mant2_cnt = 2;
                    v = 128;
                    break;
                default:
                    *qmant2_ptr += v;
                    mant2_cnt = 0;
                    v = 128;
                    break;
                }
                break;
            case 3:
                v = sym_quant(c, e, 7);
                break;
            case 4:
                v = sym_quant(c, e, 11);
                switch(mant4_cnt) {
                case 0:
                    qmant4_ptr = &qmant[ch][i];
                    v = 11 * v;
                    mant4_cnt = 1;
                    break;
                default:
                    *qmant4_ptr += v;
                    mant4_cnt = 0;
                    v = 128;
                    break;
                }
                break;
            case 5:
                v = sym_quant(c, e, 15);
                break;
            case 14:
                v = asym_quant(c, e, 14);
                break;
            case 15:
                v = asym_quant(c, e, 16);
                break;
            default:
                v = asym_quant(c, e, b - 1);
                break;
            }
            qmant[ch][i] = v;
        }
    }

    /* second pass : output the values */
1012
    for (ch = 0; ch < s->nb_all_channels; ch++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1013
        int b, q;
1014

Fabrice Bellard's avatar
Fabrice Bellard committed
1015 1016 1017 1018 1019 1020 1021
        for(i=0;i<s->nb_coefs[ch];i++) {
            q = qmant[ch][i];
            b = bap[ch][i];
            switch(b) {
            case 0:
                break;
            case 1:
1022
                if (q != 128)
Fabrice Bellard's avatar
Fabrice Bellard committed
1023 1024 1025
                    put_bits(&s->pb, 5, q);
                break;
            case 2:
1026
                if (q != 128)
Fabrice Bellard's avatar
Fabrice Bellard committed
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
                    put_bits(&s->pb, 7, q);
                break;
            case 3:
                put_bits(&s->pb, 3, q);
                break;
            case 4:
                if (q != 128)
                    put_bits(&s->pb, 7, q);
                break;
            case 14:
                put_bits(&s->pb, 14, q);
                break;
            case 15:
                put_bits(&s->pb, 16, q);
                break;
            default:
                put_bits(&s->pb, b - 1, q);
                break;
            }
        }
    }
}

#define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))

static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
{
    unsigned int c;

    c = 0;
    while (a) {
        if (a & 1)
            c ^= b;
        a = a >> 1;
        b = b << 1;
        if (b & (1 << 16))
            b ^= poly;
    }
    return c;
}

static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
{
    unsigned int r;
    r = 1;
    while (n) {
        if (n & 1)
            r = mul_poly(r, a, poly);
        a = mul_poly(a, a, poly);
        n >>= 1;
    }
    return r;
}


/* compute log2(max(abs(tab[]))) */
1083
static int log2_tab(int16_t *tab, int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
1084 1085 1086 1087 1088 1089 1090
{
    int i, v;

    v = 0;
    for(i=0;i<n;i++) {
        v |= abs(tab[i]);
    }
1091
    return av_log2(v);
Fabrice Bellard's avatar
Fabrice Bellard committed
1092 1093
}

1094
static void lshift_tab(int16_t *tab, int n, int lshift)
Fabrice Bellard's avatar
Fabrice Bellard committed
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
{
    int i;

    if (lshift > 0) {
        for(i=0;i<n;i++) {
            tab[i] <<= lshift;
        }
    } else if (lshift < 0) {
        lshift = -lshift;
        for(i=0;i<n;i++) {
            tab[i] >>= lshift;
        }
    }
}

/* fill the end of the frame and compute the two crcs */
static int output_frame_end(AC3EncodeContext *s)
{
    int frame_size, frame_size_58, n, crc1, crc2, crc_inv;
1114
    uint8_t *frame;
Fabrice Bellard's avatar
Fabrice Bellard committed
1115 1116 1117 1118 1119 1120

    frame_size = s->frame_size; /* frame size in words */
    /* align to 8 bits */
    flush_put_bits(&s->pb);
    /* add zero bytes to reach the frame size */
    frame = s->pb.buf;
1121
    n = 2 * s->frame_size - (pbBufPtr(&s->pb) - frame) - 2;
Fabrice Bellard's avatar
Fabrice Bellard committed
1122
    assert(n >= 0);
1123 1124
    if(n>0)
      memset(pbBufPtr(&s->pb), 0, n);
1125

Fabrice Bellard's avatar
Fabrice Bellard committed
1126 1127 1128
    /* Now we must compute both crcs : this is not so easy for crc1
       because it is at the beginning of the data... */
    frame_size_58 = (frame_size >> 1) + (frame_size >> 3);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
1129 1130
    crc1 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
                           frame + 4, 2 * frame_size_58 - 4));
Fabrice Bellard's avatar
Fabrice Bellard committed
1131 1132 1133
    /* XXX: could precompute crc_inv */
    crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY);
    crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
1134
    AV_WB16(frame+2,crc1);
1135

Aurelien Jacobs's avatar
Aurelien Jacobs committed
1136 1137 1138
    crc2 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
                           frame + 2 * frame_size_58,
                           (frame_size - frame_size_58) * 2 - 2));
1139
    AV_WB16(frame+2*frame_size-2,crc2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1140 1141 1142 1143 1144

    //    printf("n=%d frame_size=%d\n", n, frame_size);
    return frame_size * 2;
}

1145 1146
static int AC3_encode_frame(AVCodecContext *avctx,
                            unsigned char *frame, int buf_size, void *data)
Fabrice Bellard's avatar
Fabrice Bellard committed
1147 1148
{
    AC3EncodeContext *s = avctx->priv_data;
1149
    int16_t *samples = data;
Fabrice Bellard's avatar
Fabrice Bellard committed
1150
    int i, j, k, v, ch;
1151 1152 1153 1154 1155 1156 1157
    int16_t input_samples[N];
    int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
    uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
    uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS];
    uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
    uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
    int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS];
Fabrice Bellard's avatar
Fabrice Bellard committed
1158 1159 1160
    int frame_bits;

    frame_bits = 0;
1161
    for(ch=0;ch<s->nb_all_channels;ch++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1162 1163
        /* fixed mdct to the six sub blocks & exponent computation */
        for(i=0;i<NB_BLOCKS;i++) {
1164
            int16_t *sptr;
Fabrice Bellard's avatar
Fabrice Bellard committed
1165 1166 1167
            int sinc;

            /* compute input samples */
1168
            memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(int16_t));
1169
            sinc = s->nb_all_channels;
Fabrice Bellard's avatar
Fabrice Bellard committed
1170 1171 1172 1173
            sptr = samples + (sinc * (N/2) * i) + ch;
            for(j=0;j<N/2;j++) {
                v = *sptr;
                input_samples[j + N/2] = v;
1174
                s->last_samples[ch][j] = v;
Fabrice Bellard's avatar
Fabrice Bellard committed
1175 1176 1177 1178 1179
                sptr += sinc;
            }

            /* apply the MDCT window */
            for(j=0;j<N/2;j++) {
1180
                input_samples[j] = MUL16(input_samples[j],
1181
                                         ff_ac3_window[j]) >> 15;
1182
                input_samples[N-j-1] = MUL16(input_samples[N-j-1],
1183
                                             ff_ac3_window[j]) >> 15;
Fabrice Bellard's avatar
Fabrice Bellard committed
1184
            }
1185

Fabrice Bellard's avatar
Fabrice Bellard committed
1186 1187 1188 1189 1190
            /* Normalize the samples to use the maximum available
               precision */
            v = 14 - log2_tab(input_samples, N);
            if (v < 0)
                v = 0;
1191
            exp_samples[i][ch] = v - 9;
Fabrice Bellard's avatar
Fabrice Bellard committed
1192 1193 1194 1195
            lshift_tab(input_samples, N, v);

            /* do the MDCT */
            mdct512(mdct_coef[i][ch], input_samples);
1196

Fabrice Bellard's avatar
Fabrice Bellard committed
1197 1198 1199 1200 1201 1202 1203 1204
            /* compute "exponents". We take into account the
               normalization there */
            for(j=0;j<N/2;j++) {
                int e;
                v = abs(mdct_coef[i][ch][j]);
                if (v == 0)
                    e = 24;
                else {
1205
                    e = 23 - av_log2(v) + exp_samples[i][ch];
Fabrice Bellard's avatar
Fabrice Bellard committed
1206 1207 1208 1209 1210 1211 1212 1213
                    if (e >= 24) {
                        e = 24;
                        mdct_coef[i][ch][j] = 0;
                    }
                }
                exp[i][ch][j] = e;
            }
        }
1214

1215
        compute_exp_strategy(exp_strategy, exp, ch, ch == s->lfe_channel);
Fabrice Bellard's avatar
Fabrice Bellard committed
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227

        /* compute the exponents as the decoder will see them. The
           EXP_REUSE case must be handled carefully : we select the
           min of the exponents */
        i = 0;
        while (i < NB_BLOCKS) {
            j = i + 1;
            while (j < NB_BLOCKS && exp_strategy[j][ch] == EXP_REUSE) {
                exponent_min(exp[i][ch], exp[j][ch], s->nb_coefs[ch]);
                j++;
            }
            frame_bits += encode_exp(encoded_exp[i][ch],
1228
                                     exp[i][ch], s->nb_coefs[ch],
Fabrice Bellard's avatar
Fabrice Bellard committed
1229 1230 1231
                                     exp_strategy[i][ch]);
            /* copy encoded exponents for reuse case */
            for(k=i+1;k<j;k++) {
1232
                memcpy(encoded_exp[k][ch], encoded_exp[i][ch],
1233
                       s->nb_coefs[ch] * sizeof(uint8_t));
Fabrice Bellard's avatar
Fabrice Bellard committed
1234 1235 1236 1237 1238
            }
            i = j;
        }
    }

1239
    /* adjust for fractional frame sizes */
1240 1241
    while(s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
        s->bits_written -= s->bit_rate;
1242 1243
        s->samples_written -= s->sample_rate;
    }
1244
    s->frame_size = s->frame_size_min + (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
1245 1246 1247
    s->bits_written += s->frame_size * 16;
    s->samples_written += AC3_FRAME_SIZE;

Fabrice Bellard's avatar
Fabrice Bellard committed
1248 1249 1250
    compute_bit_allocation(s, bap, encoded_exp, exp_strategy, frame_bits);
    /* everything is known... let's output the frame */
    output_frame_header(s, frame);
1251

Fabrice Bellard's avatar
Fabrice Bellard committed
1252
    for(i=0;i<NB_BLOCKS;i++) {
1253
        output_audio_block(s, exp_strategy[i], encoded_exp[i],
Fabrice Bellard's avatar
Fabrice Bellard committed
1254 1255 1256 1257 1258
                           bap[i], mdct_coef[i], exp_samples[i], i);
    }
    return output_frame_end(s);
}

1259
static av_cold int AC3_encode_close(AVCodecContext *avctx)
1260 1261
{
    av_freep(&avctx->coded_frame);
1262
    return 0;
1263 1264
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1265 1266 1267 1268
#if 0
/*************************************************************************/
/* TEST */

1269
#undef random
Fabrice Bellard's avatar
Fabrice Bellard committed
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
#define FN (N/4)

void fft_test(void)
{
    IComplex in[FN], in1[FN];
    int k, n, i;
    float sum_re, sum_im, a;

    /* FFT test */

    for(i=0;i<FN;i++) {
        in[i].re = random() % 65535 - 32767;
        in[i].im = random() % 65535 - 32767;
        in1[i] = in[i];
    }
    fft(in, 7);

    /* do it by hand */
    for(k=0;k<FN;k++) {
        sum_re = 0;
        sum_im = 0;
        for(n=0;n<FN;n++) {
            a = -2 * M_PI * (n * k) / FN;
            sum_re += in1[n].re * cos(a) - in1[n].im * sin(a);
            sum_im += in1[n].re * sin(a) + in1[n].im * cos(a);
        }
1296 1297
        printf("%3d: %6d,%6d %6.0f,%6.0f\n",
               k, in[k].re, in[k].im, sum_re / FN, sum_im / FN);
Fabrice Bellard's avatar
Fabrice Bellard committed
1298 1299 1300 1301 1302
    }
}

void mdct_test(void)
{
1303 1304
    int16_t input[N];
    int32_t output[N/2];
Fabrice Bellard's avatar
Fabrice Bellard committed
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
    float input1[N];
    float output1[N/2];
    float s, a, err, e, emax;
    int i, k, n;

    for(i=0;i<N;i++) {
        input[i] = (random() % 65535 - 32767) * 9 / 10;
        input1[i] = input[i];
    }

    mdct512(output, input);
1316

Fabrice Bellard's avatar
Fabrice Bellard committed
1317 1318 1319 1320 1321 1322 1323 1324 1325
    /* do it by hand */
    for(k=0;k<N/2;k++) {
        s = 0;
        for(n=0;n<N;n++) {
            a = (2*M_PI*(2*n+1+N/2)*(2*k+1) / (4 * N));
            s += input1[n] * cos(a);
        }
        output1[k] = -2 * s / N;
    }
1326

Fabrice Bellard's avatar
Fabrice Bellard committed
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
    err = 0;
    emax = 0;
    for(i=0;i<N/2;i++) {
        printf("%3d: %7d %7.0f\n", i, output[i], output1[i]);
        e = output[i] - output1[i];
        if (e > emax)
            emax = e;
        err += e * e;
    }
    printf("err2=%f emax=%f\n", err / (N/2), emax);
}

void test_ac3(void)
{
    AC3EncodeContext ctx;
    unsigned char frame[AC3_MAX_CODED_FRAME_SIZE];
    short samples[AC3_FRAME_SIZE];
    int ret, i;
1345

Fabrice Bellard's avatar
Fabrice Bellard committed
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
    AC3_encode_init(&ctx, 44100, 64000, 1);

    fft_test();
    mdct_test();

    for(i=0;i<AC3_FRAME_SIZE;i++)
        samples[i] = (int)(sin(2*M_PI*i*1000.0/44100) * 10000);
    ret = AC3_encode_frame(&ctx, frame, samples);
    printf("ret=%d\n", ret);
}
#endif

AVCodec ac3_encoder = {
    "ac3",
    CODEC_TYPE_AUDIO,
    CODEC_ID_AC3,
    sizeof(AC3EncodeContext),
    AC3_encode_init,
    AC3_encode_frame,
1365
    AC3_encode_close,
Fabrice Bellard's avatar
Fabrice Bellard committed
1366
    NULL,
1367
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1368
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
Fabrice Bellard's avatar
Fabrice Bellard committed
1369
};