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

/**
25
 * @file
26
 * The simplest AC-3 encoder.
Michael Niedermayer's avatar
Michael Niedermayer committed
27
 */
28

29 30
#include <stdint.h>

31
#include "libavutil/attributes.h"
32
#include "libavutil/avassert.h"
33
#include "libavutil/avstring.h"
34
#include "libavutil/channel_layout.h"
35
#include "libavutil/crc.h"
36
#include "libavutil/internal.h"
37
#include "libavutil/opt.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
38
#include "avcodec.h"
39
#include "put_bits.h"
40
#include "ac3dsp.h"
41
#include "ac3.h"
42
#include "fft.h"
43 44
#include "ac3enc.h"
#include "eac3enc.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
45

46
typedef struct AC3Mant {
47
    int16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
48 49
    int mant1_cnt, mant2_cnt, mant4_cnt;    ///< mantissa counts for bap=1,2,4
} AC3Mant;
50

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
#define CMIXLEV_NUM_OPTIONS 3
static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
    LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
};

#define SURMIXLEV_NUM_OPTIONS 3
static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
    LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
};

#define EXTMIXLEV_NUM_OPTIONS 8
static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = {
    LEVEL_PLUS_3DB,  LEVEL_PLUS_1POINT5DB,  LEVEL_ONE,       LEVEL_MINUS_4POINT5DB,
    LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO
};


68 69
/**
 * LUT for number of exponent groups.
70
 * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
71
 */
72
static uint8_t exponent_group_tab[2][3][256];
73

74

75 76 77
/**
 * List of supported channel layouts.
 */
78
const uint64_t ff_ac3_channel_layouts[19] = {
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
     AV_CH_LAYOUT_MONO,
     AV_CH_LAYOUT_STEREO,
     AV_CH_LAYOUT_2_1,
     AV_CH_LAYOUT_SURROUND,
     AV_CH_LAYOUT_2_2,
     AV_CH_LAYOUT_QUAD,
     AV_CH_LAYOUT_4POINT0,
     AV_CH_LAYOUT_5POINT0,
     AV_CH_LAYOUT_5POINT0_BACK,
    (AV_CH_LAYOUT_MONO     | AV_CH_LOW_FREQUENCY),
    (AV_CH_LAYOUT_STEREO   | AV_CH_LOW_FREQUENCY),
    (AV_CH_LAYOUT_2_1      | AV_CH_LOW_FREQUENCY),
    (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY),
    (AV_CH_LAYOUT_2_2      | AV_CH_LOW_FREQUENCY),
    (AV_CH_LAYOUT_QUAD     | AV_CH_LOW_FREQUENCY),
    (AV_CH_LAYOUT_4POINT0  | AV_CH_LOW_FREQUENCY),
     AV_CH_LAYOUT_5POINT1,
     AV_CH_LAYOUT_5POINT1_BACK,
     0
};


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
/**
 * LUT to select the bandwidth code based on the bit rate, sample rate, and
 * number of full-bandwidth channels.
 * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
 */
static const uint8_t ac3_bandwidth_tab[5][3][19] = {
//      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640

    { {  0,  0,  0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
      {  0,  0,  0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
      {  0,  0,  0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },

    { {  0,  0,  0,  0,  0,  0,  0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
      {  0,  0,  0,  0,  0,  0,  4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
      {  0,  0,  0,  0,  0,  0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },

    { {  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
      {  0,  0,  0,  0,  0,  0,  0,  0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },

    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },

    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8, 20, 32, 40, 48, 48, 48, 48 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 24, 36, 44, 56, 56, 56, 56 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 28, 44, 60, 60, 60, 60, 60, 60 } }
};


131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
/**
 * LUT to select the coupling start band based on the bit rate, sample rate, and
 * number of full-bandwidth channels. -1 = coupling off
 * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
 *
 * TODO: more testing for optimal parameters.
 *       multi-channel tests at 44.1kHz and 32kHz.
 */
static const int8_t ac3_coupling_start_tab[6][3][19] = {
//      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640

    // 2/0
    { {  0,  0,  0,  0,  0,  0,  0,  1,  1,  7,  8, 11, 12, -1, -1, -1, -1, -1, -1 },
      {  0,  0,  0,  0,  0,  0,  1,  3,  5,  7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
      {  0,  0,  0,  0,  1,  2,  2,  9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

    // 3/0
    { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

    // 2/1 - untested
    { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

    // 3/1
    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

    // 2/2 - untested
    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },

    // 3/2
    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },
      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },
      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
};


174 175
/**
 * Adjust the frame size to make the average bit rate match the target bit rate.
176
 * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
Justin Ruggles's avatar
Justin Ruggles committed
177 178
 *
 * @param s  AC-3 encoder private context
179
 */
180
void ff_ac3_adjust_frame_size(AC3EncodeContext *s)
181 182 183 184 185
{
    while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
        s->bits_written    -= s->bit_rate;
        s->samples_written -= s->sample_rate;
    }
186 187
    s->frame_size = s->frame_size_min +
                    2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
188
    s->bits_written    += s->frame_size * 8;
189
    s->samples_written += AC3_BLOCK_SIZE * s->num_blocks;
190 191 192
}


Justin Ruggles's avatar
Justin Ruggles committed
193 194 195 196 197
/**
 * Set the initial coupling strategy parameters prior to coupling analysis.
 *
 * @param s  AC-3 encoder private context
 */
198
void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
199 200 201
{
    int blk, ch;
    int got_cpl_snr;
202
    int num_cpl_blocks;
203 204 205

    /* set coupling use flags for each block/channel */
    /* TODO: turn coupling on/off and adjust start band based on bit usage */
206
    for (blk = 0; blk < s->num_blocks; blk++) {
207 208 209 210 211 212 213 214
        AC3Block *block = &s->blocks[blk];
        for (ch = 1; ch <= s->fbw_channels; ch++)
            block->channel_in_cpl[ch] = s->cpl_on;
    }

    /* enable coupling for each block if at least 2 channels have coupling
       enabled for that block */
    got_cpl_snr = 0;
215
    num_cpl_blocks = 0;
216
    for (blk = 0; blk < s->num_blocks; blk++) {
217 218 219 220 221
        AC3Block *block = &s->blocks[blk];
        block->num_cpl_channels = 0;
        for (ch = 1; ch <= s->fbw_channels; ch++)
            block->num_cpl_channels += block->channel_in_cpl[ch];
        block->cpl_in_use = block->num_cpl_channels > 1;
222
        num_cpl_blocks += block->cpl_in_use;
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
        if (!block->cpl_in_use) {
            block->num_cpl_channels = 0;
            for (ch = 1; ch <= s->fbw_channels; ch++)
                block->channel_in_cpl[ch] = 0;
        }

        block->new_cpl_strategy = !blk;
        if (blk) {
            for (ch = 1; ch <= s->fbw_channels; ch++) {
                if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
                    block->new_cpl_strategy = 1;
                    break;
                }
            }
        }
        block->new_cpl_leak = block->new_cpl_strategy;

        if (!blk || (block->cpl_in_use && !got_cpl_snr)) {
            block->new_snr_offsets = 1;
            if (block->cpl_in_use)
                got_cpl_snr = 1;
        } else {
            block->new_snr_offsets = 0;
        }
    }
248 249
    if (!num_cpl_blocks)
        s->cpl_on = 0;
250 251

    /* set bandwidth for each channel */
252
    for (blk = 0; blk < s->num_blocks; blk++) {
253 254 255 256 257 258 259 260 261 262 263
        AC3Block *block = &s->blocks[blk];
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (block->channel_in_cpl[ch])
                block->end_freq[ch] = s->start_freq[CPL_CH];
            else
                block->end_freq[ch] = s->bandwidth_code * 3 + 73;
        }
    }
}


264 265
/**
 * Apply stereo rematrixing to coefficients based on rematrixing flags.
Justin Ruggles's avatar
Justin Ruggles committed
266 267
 *
 * @param s  AC-3 encoder private context
268
 */
269
void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
270 271 272 273 274 275
{
    int nb_coefs;
    int blk, bnd, i;
    int start, end;
    uint8_t *flags;

276
    if (!s->rematrixing_enabled)
277 278
        return;

279
    for (blk = 0; blk < s->num_blocks; blk++) {
280 281 282
        AC3Block *block = &s->blocks[blk];
        if (block->new_rematrixing_strategy)
            flags = block->rematrixing_flags;
283 284
        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
285 286 287 288
            if (flags[bnd]) {
                start = ff_ac3_rematrix_band_tab[bnd];
                end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
                for (i = start; i < end; i++) {
289 290 291 292
                    int32_t lt = block->fixed_coef[1][i];
                    int32_t rt = block->fixed_coef[2][i];
                    block->fixed_coef[1][i] = (lt + rt) >> 1;
                    block->fixed_coef[2][i] = (lt - rt) >> 1;
293 294 295 296 297 298 299
                }
            }
        }
    }
}


Justin Ruggles's avatar
Justin Ruggles committed
300
/*
301 302 303 304
 * Initialize exponent tables.
 */
static av_cold void exponent_init(AC3EncodeContext *s)
{
305 306 307 308
    int expstr, i, grpsize;

    for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
        grpsize = 3 << expstr;
309 310 311
        for (i = 12; i < 256; i++) {
            exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;
            exponent_group_tab[1][expstr][i] = (i              ) / grpsize;
312
        }
313
    }
314
    /* LFE */
315
    exponent_group_tab[0][0][7] = 2;
316 317 318

    if (CONFIG_EAC3_ENCODER && s->eac3)
        ff_eac3_exponent_init();
319 320 321
}


Justin Ruggles's avatar
Justin Ruggles committed
322
/*
323 324
 * Extract exponents from the MDCT coefficients.
 */
325
static void extract_exponents(AC3EncodeContext *s)
326
{
327
    int ch        = !s->cpl_on;
328
    int chan_size = AC3_MAX_COEFS * s->num_blocks * (s->channels - ch + 1);
329
    AC3Block *block = &s->blocks[0];
330

331
    s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);
332 333 334
}


335 336 337 338
/**
 * Exponent Difference Threshold.
 * New exponents are sent if their SAD exceed this number.
 */
339
#define EXP_DIFF_THRESHOLD 500
340

341 342 343 344 345 346 347 348 349
/**
 * Table used to select exponent strategy based on exponent reuse block interval.
 */
static const uint8_t exp_strategy_reuse_tab[4][6] = {
    { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
    { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
    { EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
    { EXP_D45, EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15 }
};
350

Justin Ruggles's avatar
Justin Ruggles committed
351
/*
352
 * Calculate exponent strategies for all channels.
353
 * Array arrangement is reversed to simplify the per-channel calculation.
354
 */
355
static void compute_exp_strategy(AC3EncodeContext *s)
356
{
357
    int ch, blk, blk1;
358

359
    for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {
360 361 362 363 364 365 366 367
        uint8_t *exp_strategy = s->exp_strategy[ch];
        uint8_t *exp          = s->blocks[0].exp[ch];
        int exp_diff;

        /* estimate if the exponent variation & decide if they should be
           reused in the next frame */
        exp_strategy[0] = EXP_NEW;
        exp += AC3_MAX_COEFS;
368
        for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {
369 370 371 372 373 374 375 376 377
            if (ch == CPL_CH) {
                if (!s->blocks[blk-1].cpl_in_use) {
                    exp_strategy[blk] = EXP_NEW;
                    continue;
                } else if (!s->blocks[blk].cpl_in_use) {
                    exp_strategy[blk] = EXP_REUSE;
                    continue;
                }
            } else if (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
378 379 380
                exp_strategy[blk] = EXP_NEW;
                continue;
            }
381
            exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
382 383 384 385
            exp_strategy[blk] = EXP_REUSE;
            if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))
                exp_strategy[blk] = EXP_NEW;
            else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)
386 387 388 389 390 391
                exp_strategy[blk] = EXP_NEW;
        }

        /* now select the encoding strategy type : if exponents are often
           recoded, we use a coarse encoding */
        blk = 0;
392
        while (blk < s->num_blocks) {
393
            blk1 = blk + 1;
394
            while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE)
395
                blk1++;
396
            exp_strategy[blk] = exp_strategy_reuse_tab[s->num_blks_code][blk1-blk-1];
397 398
            blk = blk1;
        }
399 400 401
    }
    if (s->lfe_on) {
        ch = s->lfe_channel;
402
        s->exp_strategy[ch][0] = EXP_D15;
403
        for (blk = 1; blk < s->num_blocks; blk++)
404
            s->exp_strategy[ch][blk] = EXP_REUSE;
405
    }
406 407 408 409

    /* for E-AC-3, determine frame exponent strategy */
    if (CONFIG_EAC3_ENCODER && s->eac3)
        ff_eac3_get_frame_exp_strategy(s);
410 411 412
}


413 414
/**
 * Update the exponents so that they are the ones the decoder will decode.
Justin Ruggles's avatar
Justin Ruggles committed
415 416 417 418 419
 *
 * @param[in,out] exp   array of exponents for 1 block in 1 channel
 * @param nb_exps       number of exponents in active bandwidth
 * @param exp_strategy  exponent strategy for the block
 * @param cpl           indicates if the block is in the coupling channel
420
 */
421 422
static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
                                    int cpl)
Fabrice Bellard's avatar
Fabrice Bellard committed
423
{
424
    int nb_groups, i, k;
Fabrice Bellard's avatar
Fabrice Bellard committed
425

426
    nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
Fabrice Bellard's avatar
Fabrice Bellard committed
427 428

    /* for each group, compute the minimum exponent */
429 430
    switch(exp_strategy) {
    case EXP_D25:
431
        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
432 433 434
            uint8_t exp_min = exp[k];
            if (exp[k+1] < exp_min)
                exp_min = exp[k+1];
435
            exp[i-cpl] = exp_min;
436
            k += 2;
Fabrice Bellard's avatar
Fabrice Bellard committed
437
        }
438 439
        break;
    case EXP_D45:
440
        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
441 442 443 444 445 446 447
            uint8_t exp_min = exp[k];
            if (exp[k+1] < exp_min)
                exp_min = exp[k+1];
            if (exp[k+2] < exp_min)
                exp_min = exp[k+2];
            if (exp[k+3] < exp_min)
                exp_min = exp[k+3];
448
            exp[i-cpl] = exp_min;
449 450 451
            k += 4;
        }
        break;
452
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
453 454

    /* constraint for DC exponent */
455
    if (!cpl && exp[0] > 15)
456
        exp[0] = 15;
Fabrice Bellard's avatar
Fabrice Bellard committed
457

458 459 460
    /* decrease the delta between each groups to within 2 so that they can be
       differentially encoded */
    for (i = 1; i <= nb_groups; i++)
461
        exp[i] = FFMIN(exp[i], exp[i-1] + 2);
462 463
    i--;
    while (--i >= 0)
464
        exp[i] = FFMIN(exp[i], exp[i+1] + 2);
465

466 467 468
    if (cpl)
        exp[-1] = exp[0] & ~1;

Fabrice Bellard's avatar
Fabrice Bellard committed
469
    /* now we have the exponent values the decoder will see */
470 471
    switch (exp_strategy) {
    case EXP_D25:
472 473
        for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {
            uint8_t exp1 = exp[i-cpl];
474 475 476 477 478
            exp[k--] = exp1;
            exp[k--] = exp1;
        }
        break;
    case EXP_D45:
479 480
        for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {
            exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];
481 482 483
            k -= 4;
        }
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
484 485 486
    }
}

487

Justin Ruggles's avatar
Justin Ruggles committed
488
/*
489 490 491 492 493
 * Encode exponents from original extracted form to what the decoder will see.
 * This copies and groups exponents based on exponent strategy and reduces
 * deltas between adjacent exponent groups so that they can be differentially
 * encoded.
 */
494
static void encode_exponents(AC3EncodeContext *s)
495
{
496
    int blk, blk1, ch, cpl;
497
    uint8_t *exp, *exp_strategy;
498
    int nb_coefs, num_reuse_blocks;
499

500 501
    for (ch = !s->cpl_on; ch <= s->channels; ch++) {
        exp          = s->blocks[0].exp[ch] + s->start_freq[ch];
502 503
        exp_strategy = s->exp_strategy[ch];

504
        cpl = (ch == CPL_CH);
505
        blk = 0;
506
        while (blk < s->num_blocks) {
507 508 509 510 511 512 513
            AC3Block *block = &s->blocks[blk];
            if (cpl && !block->cpl_in_use) {
                exp += AC3_MAX_COEFS;
                blk++;
                continue;
            }
            nb_coefs = block->end_freq[ch] - s->start_freq[ch];
514
            blk1 = blk + 1;
515

516
            /* count the number of EXP_REUSE blocks after the current block
517 518
               and set exponent reference block numbers */
            s->exp_ref_block[ch][blk] = blk;
519
            while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE) {
520
                s->exp_ref_block[ch][blk1] = blk;
521
                blk1++;
522
            }
523 524 525
            num_reuse_blocks = blk1 - blk - 1;

            /* for the EXP_REUSE case we select the min of the exponents */
526 527
            s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,
                                       AC3_MAX_COEFS);
528

529
            encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);
530

531
            exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);
532 533 534
            blk = blk1;
        }
    }
535 536 537

    /* reference block numbers have been changed, so reset ref_bap_set */
    s->ref_bap_set = 0;
538 539 540
}


Justin Ruggles's avatar
Justin Ruggles committed
541
/*
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
 * Count exponent bits based on bandwidth, coupling, and exponent strategies.
 */
static int count_exponent_bits(AC3EncodeContext *s)
{
    int blk, ch;
    int nb_groups, bit_count;

    bit_count = 0;
    for (blk = 0; blk < s->num_blocks; blk++) {
        AC3Block *block = &s->blocks[blk];
        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
            int exp_strategy = s->exp_strategy[ch][blk];
            int cpl          = (ch == CPL_CH);
            int nb_coefs     = block->end_freq[ch] - s->start_freq[ch];

            if (exp_strategy == EXP_REUSE)
                continue;

            nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs];
            bit_count += 4 + (nb_groups * 7);
        }
    }

    return bit_count;
}


569 570 571 572
/**
 * Group exponents.
 * 3 delta-encoded exponents are in each 7-bit group. The number of groups
 * varies depending on exponent strategy and bandwidth.
Justin Ruggles's avatar
Justin Ruggles committed
573 574
 *
 * @param s  AC-3 encoder private context
575
 */
576
void ff_ac3_group_exponents(AC3EncodeContext *s)
577
{
578
    int blk, ch, i, cpl;
579
    int group_size, nb_groups;
580 581 582 583
    uint8_t *p;
    int delta0, delta1, delta2;
    int exp0, exp1;

584
    for (blk = 0; blk < s->num_blocks; blk++) {
585
        AC3Block *block = &s->blocks[blk];
586
        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
587 588
            int exp_strategy = s->exp_strategy[ch][blk];
            if (exp_strategy == EXP_REUSE)
589
                continue;
590
            cpl = (ch == CPL_CH);
591
            group_size = exp_strategy + (exp_strategy == EXP_D45);
592 593
            nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
            p = block->exp[ch] + s->start_freq[ch] - cpl;
594 595 596

            /* DC exponent */
            exp1 = *p++;
597
            block->grouped_exp[ch][0] = exp1;
598 599

            /* remaining exponents are delta encoded */
600
            for (i = 1; i <= nb_groups; i++) {
601 602 603 604 605
                /* merge three delta in one code */
                exp0   = exp1;
                exp1   = p[0];
                p     += group_size;
                delta0 = exp1 - exp0 + 2;
606
                av_assert2(delta0 >= 0 && delta0 <= 4);
607 608 609 610 611

                exp0   = exp1;
                exp1   = p[0];
                p     += group_size;
                delta1 = exp1 - exp0 + 2;
612
                av_assert2(delta1 >= 0 && delta1 <= 4);
613 614 615 616 617

                exp0   = exp1;
                exp1   = p[0];
                p     += group_size;
                delta2 = exp1 - exp0 + 2;
618
                av_assert2(delta2 >= 0 && delta2 <= 4);
619

620
                block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
621 622 623
            }
        }
    }
624 625 626 627 628 629 630
}


/**
 * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
 * Extract exponents from MDCT coefficients, calculate exponent strategies,
 * and encode final exponents.
Justin Ruggles's avatar
Justin Ruggles committed
631 632
 *
 * @param s  AC-3 encoder private context
633
 */
634
void ff_ac3_process_exponents(AC3EncodeContext *s)
635
{
636
    extract_exponents(s);
637

638
    compute_exp_strategy(s);
639

640
    encode_exponents(s);
641

642
    emms_c();
643 644 645
}


Justin Ruggles's avatar
Justin Ruggles committed
646
/*
647 648 649 650 651 652 653 654 655 656 657 658 659 660
 * Count frame bits that are based solely on fixed parameters.
 * This only has to be run once when the encoder is initialized.
 */
static void count_frame_bits_fixed(AC3EncodeContext *s)
{
    static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
    int blk;
    int frame_bits;

    /* assumptions:
     *   no dynamic range codes
     *   bit allocation parameters do not change between blocks
     *   no delta bit allocation
     *   no skipped data
Diego Biurrun's avatar
Diego Biurrun committed
661
     *   no auxiliary data
662
     *   no E-AC-3 metadata
663 664
     */

665
    /* header */
666 667 668 669
    frame_bits = 16; /* sync info */
    if (s->eac3) {
        /* bitstream info header */
        frame_bits += 35;
670 671 672 673
        frame_bits += 1 + 1;
        if (s->num_blocks != 0x6)
            frame_bits++;
        frame_bits++;
674
        /* audio frame header */
675 676
        if (s->num_blocks == 6)
            frame_bits += 2;
677 678
        frame_bits += 10;
        /* exponent strategy */
679 680 681
        if (s->use_frame_exp_strategy)
            frame_bits += 5 * s->fbw_channels;
        else
682
            frame_bits += s->num_blocks * 2 * s->fbw_channels;
683
        if (s->lfe_on)
684
            frame_bits += s->num_blocks;
685
        /* converter exponent strategy */
686 687 688 689
        if (s->num_blks_code != 0x3)
            frame_bits++;
        else
            frame_bits += s->fbw_channels * 5;
690 691 692
        /* snr offsets */
        frame_bits += 10;
        /* block start info */
693 694
        if (s->num_blocks != 1)
            frame_bits++;
695 696 697 698
    } else {
        frame_bits += 49;
        frame_bits += frame_bits_inc[s->channel_mode];
    }
699 700

    /* audio blocks */
701
    for (blk = 0; blk < s->num_blocks; blk++) {
702
        if (!s->eac3) {
703 704
            /* block switch flags */
            frame_bits += s->fbw_channels;
705

706 707
            /* dither flags */
            frame_bits += s->fbw_channels;
708
        }
709 710 711 712

        /* dynamic range */
        frame_bits++;

713 714 715 716 717
        /* spectral extension */
        if (s->eac3)
            frame_bits++;

        if (!s->eac3) {
718 719 720 721
            /* exponent strategy */
            frame_bits += 2 * s->fbw_channels;
            if (s->lfe_on)
                frame_bits++;
722

723 724 725 726
            /* bit allocation params */
            frame_bits++;
            if (!blk)
                frame_bits += 2 + 2 + 2 + 2 + 3;
727
        }
728

729 730 731 732 733
        /* converter snr offset */
        if (s->eac3)
            frame_bits++;

        if (!s->eac3) {
734 735
            /* delta bit allocation */
            frame_bits++;
736

737 738
            /* skipped data */
            frame_bits++;
739
        }
740 741
    }

742 743
    /* auxiliary data */
    frame_bits++;
744 745

    /* CRC */
746
    frame_bits += 1 + 16;
747 748 749 750 751

    s->frame_bits_fixed = frame_bits;
}


Justin Ruggles's avatar
Justin Ruggles committed
752
/*
753 754 755
 * Initialize bit allocation.
 * Set default parameter codes and calculate parameter values.
 */
756
static av_cold void bit_alloc_init(AC3EncodeContext *s)
757 758 759 760 761 762 763
{
    int ch;

    /* init default parameters */
    s->slow_decay_code = 2;
    s->fast_decay_code = 1;
    s->slow_gain_code  = 1;
764
    s->db_per_bit_code = s->eac3 ? 2 : 3;
765
    s->floor_code      = 7;
766
    for (ch = 0; ch <= s->channels; ch++)
767 768 769 770 771 772 773 774 775 776 777 778 779
        s->fast_gain_code[ch] = 4;

    /* initial snr offset */
    s->coarse_snr_offset = 40;

    /* compute real values */
    /* currently none of these values change during encoding, so we can just
       set them once at initialization */
    s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift;
    s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.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];
780 781
    s->bit_alloc.cpl_fast_leak = 0;
    s->bit_alloc.cpl_slow_leak = 0;
782 783

    count_frame_bits_fixed(s);
784 785 786
}


Justin Ruggles's avatar
Justin Ruggles committed
787
/*
788
 * Count the bits used to encode the frame, minus exponents and mantissas.
789 790
 * Bits based on fixed parameters have already been counted, so now we just
 * have to add the bits based on parameters that change during encoding.
791
 */
792
static void count_frame_bits(AC3EncodeContext *s)
793
{
794
    AC3EncOptions *opt = &s->options;
795
    int blk, ch;
796
    int frame_bits = 0;
797

798
    /* header */
799
    if (s->eac3) {
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
        if (opt->eac3_mixing_metadata) {
            if (s->channel_mode > AC3_CHMODE_STEREO)
                frame_bits += 2;
            if (s->has_center)
                frame_bits += 6;
            if (s->has_surround)
                frame_bits += 6;
            frame_bits += s->lfe_on;
            frame_bits += 1 + 1 + 2;
            if (s->channel_mode < AC3_CHMODE_STEREO)
                frame_bits++;
            frame_bits++;
        }
        if (opt->eac3_info_metadata) {
            frame_bits += 3 + 1 + 1;
            if (s->channel_mode == AC3_CHMODE_STEREO)
                frame_bits += 2 + 2;
            if (s->channel_mode >= AC3_CHMODE_2F2R)
                frame_bits += 2;
            frame_bits++;
            if (opt->audio_production_info)
                frame_bits += 5 + 2 + 1;
            frame_bits++;
        }
824 825 826
        /* coupling */
        if (s->channel_mode > AC3_CHMODE_MONO) {
            frame_bits++;
827
            for (blk = 1; blk < s->num_blocks; blk++) {
828 829 830 831 832 833 834
                AC3Block *block = &s->blocks[blk];
                frame_bits++;
                if (block->new_cpl_strategy)
                    frame_bits++;
            }
        }
        /* coupling exponent strategy */
835 836 837 838
        if (s->cpl_on) {
            if (s->use_frame_exp_strategy) {
                frame_bits += 5 * s->cpl_on;
            } else {
839
                for (blk = 0; blk < s->num_blocks; blk++)
840 841 842
                    frame_bits += 2 * s->blocks[blk].cpl_in_use;
            }
        }
843
    } else {
844 845 846 847 848 849 850 851
        if (opt->audio_production_info)
            frame_bits += 7;
        if (s->bitstream_id == 6) {
            if (opt->extended_bsi_1)
                frame_bits += 14;
            if (opt->extended_bsi_2)
                frame_bits += 14;
        }
852
    }
853

854
    /* audio blocks */
855
    for (blk = 0; blk < s->num_blocks; blk++) {
856 857 858
        AC3Block *block = &s->blocks[blk];

        /* coupling strategy */
859
        if (!s->eac3)
860
            frame_bits++;
861
        if (block->new_cpl_strategy) {
862
            if (!s->eac3)
863
                frame_bits++;
864
            if (block->cpl_in_use) {
865 866 867
                if (s->eac3)
                    frame_bits++;
                if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO)
868
                    frame_bits += s->fbw_channels;
869 870 871
                if (s->channel_mode == AC3_CHMODE_STEREO)
                    frame_bits++;
                frame_bits += 4 + 4;
872 873 874
                if (s->eac3)
                    frame_bits++;
                else
875
                    frame_bits += s->num_cpl_subbands - 1;
876 877 878 879 880 881 882
            }
        }

        /* coupling coordinates */
        if (block->cpl_in_use) {
            for (ch = 1; ch <= s->fbw_channels; ch++) {
                if (block->channel_in_cpl[ch]) {
883
                    if (!s->eac3 || block->new_cpl_coords[ch] != 2)
884
                        frame_bits++;
885
                    if (block->new_cpl_coords[ch]) {
886 887 888 889 890 891 892
                        frame_bits += 2;
                        frame_bits += (4 + 4) * s->num_cpl_bands;
                    }
                }
            }
        }

893
        /* stereo rematrixing */
894
        if (s->channel_mode == AC3_CHMODE_STEREO) {
895
            if (!s->eac3 || blk > 0)
896
                frame_bits++;
897
            if (s->blocks[blk].new_rematrixing_strategy)
898
                frame_bits += block->num_rematrixing_bands;
899 900
        }

901
        /* bandwidth codes & gain range */
902 903 904 905 906 907 908 909 910
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
                if (!block->channel_in_cpl[ch])
                    frame_bits += 6;
                frame_bits += 2;
            }
        }

        /* coupling exponent strategy */
911
        if (!s->eac3 && block->cpl_in_use)
912 913 914
            frame_bits += 2;

        /* snr offsets and fast gain codes */
915
        if (!s->eac3) {
916 917 918
            frame_bits++;
            if (block->new_snr_offsets)
                frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3);
919
        }
920 921 922

        /* coupling leak info */
        if (block->cpl_in_use) {
923
            if (!s->eac3 || block->new_cpl_leak != 2)
924
                frame_bits++;
925 926
            if (block->new_cpl_leak)
                frame_bits += 3 + 3;
927 928
        }
    }
929

930
    s->frame_bits = s->frame_bits_fixed + frame_bits;
931 932 933
}


Justin Ruggles's avatar
Justin Ruggles committed
934
/*
935 936 937
 * Calculate masking curve based on the final exponents.
 * Also calculate the power spectral densities to use in future calculations.
 */
938
static void bit_alloc_masking(AC3EncodeContext *s)
939 940 941
{
    int blk, ch;

942
    for (blk = 0; blk < s->num_blocks; blk++) {
943
        AC3Block *block = &s->blocks[blk];
944
        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
945 946 947
            /* We only need psd and mask for calculating bap.
               Since we currently do not calculate bap when exponent
               strategy is EXP_REUSE we do not need to calculate psd or mask. */
948
            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
949 950 951
                ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
                                          block->end_freq[ch], block->psd[ch],
                                          block->band_psd[ch]);
952
                ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
953
                                           s->start_freq[ch], block->end_freq[ch],
954
                                           ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
955
                                           ch == s->lfe_channel,
956
                                           DBA_NONE, 0, NULL, NULL, NULL,
957
                                           block->mask[ch]);
958 959 960 961 962
            }
        }
    }
}

963

Justin Ruggles's avatar
Justin Ruggles committed
964
/*
965 966 967 968 969 970
 * Ensure that bap for each block and channel point to the current bap_buffer.
 * They may have been switched during the bit allocation search.
 */
static void reset_block_bap(AC3EncodeContext *s)
{
    int blk, ch;
971 972 973
    uint8_t *ref_bap;

    if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
974
        return;
975 976 977

    ref_bap = s->bap_buffer;
    for (ch = 0; ch <= s->channels; ch++) {
978
        for (blk = 0; blk < s->num_blocks; blk++)
979
            s->ref_bap[ch][blk] = ref_bap + AC3_MAX_COEFS * s->exp_ref_block[ch][blk];
980
        ref_bap += AC3_MAX_COEFS * s->num_blocks;
981
    }
982
    s->ref_bap_set = 1;
983 984 985
}


986 987 988 989
/**
 * Initialize mantissa counts.
 * These are set so that they are padded to the next whole group size when bits
 * are counted in compute_mantissa_size.
Justin Ruggles's avatar
Justin Ruggles committed
990 991
 *
 * @param[in,out] mant_cnt  running counts for each bap value for each block
992 993
 */
static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
Fabrice Bellard's avatar
Fabrice Bellard committed
994
{
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
    int blk;

    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
        memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk]));
        mant_cnt[blk][1] = mant_cnt[blk][2] = 2;
        mant_cnt[blk][4] = 1;
    }
}


/**
 * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
 * range.
Justin Ruggles's avatar
Justin Ruggles committed
1008 1009 1010 1011 1012 1013
 *
 * @param s                 AC-3 encoder private context
 * @param ch                channel index
 * @param[in,out] mant_cnt  running counts for each bap value for each block
 * @param start             starting coefficient bin
 * @param end               ending coefficient bin
1014 1015 1016 1017 1018 1019
 */
static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch,
                                          uint16_t mant_cnt[AC3_MAX_BLOCKS][16],
                                          int start, int end)
{
    int blk;
Justin Ruggles's avatar
Justin Ruggles committed
1020

1021
    for (blk = 0; blk < s->num_blocks; blk++) {
1022
        AC3Block *block = &s->blocks[blk];
1023 1024 1025 1026 1027
        if (ch == CPL_CH && !block->cpl_in_use)
            continue;
        s->ac3dsp.update_bap_counts(mant_cnt[blk],
                                    s->ref_bap[ch][blk] + start,
                                    FFMIN(end, block->end_freq[ch]) - start);
1028
    }
1029 1030 1031
}


Justin Ruggles's avatar
Justin Ruggles committed
1032
/*
1033 1034 1035 1036 1037
 * Count the number of mantissa bits in the frame based on the bap values.
 */
static int count_mantissa_bits(AC3EncodeContext *s)
{
    int ch, max_end_freq;
1038
    LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
1039 1040 1041 1042 1043 1044 1045 1046 1047

    count_mantissa_bits_init(mant_cnt);

    max_end_freq = s->bandwidth_code * 3 + 73;
    for (ch = !s->cpl_enabled; ch <= s->channels; ch++)
        count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch],
                                      max_end_freq);

    return s->ac3dsp.compute_mantissa_size(mant_cnt);
1048
}
1049

1050 1051 1052 1053 1054

/**
 * Run the bit allocation with a given SNR offset.
 * This calculates the bit allocation pointers that will be used to determine
 * the quantization of each mantissa.
Justin Ruggles's avatar
Justin Ruggles committed
1055 1056 1057
 *
 * @param s           AC-3 encoder private context
 * @param snr_offset  SNR offset, 0 to 1023
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
 * @return the number of bits needed for mantissas if the given SNR offset is
 *         is used.
 */
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
{
    int blk, ch;

    snr_offset = (snr_offset - 240) << 2;

    reset_block_bap(s);
1068
    for (blk = 0; blk < s->num_blocks; blk++) {
1069 1070 1071
        AC3Block *block = &s->blocks[blk];

        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1072 1073 1074 1075
            /* Currently the only bit allocation parameters which vary across
               blocks within a frame are the exponent values.  We can take
               advantage of that by reusing the bit allocation pointers
               whenever we reuse exponents. */
1076
            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1077
                s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch],
1078 1079
                                             s->start_freq[ch], block->end_freq[ch],
                                             snr_offset, s->bit_alloc.floor,
1080
                                             ff_ac3_bap_tab, s->ref_bap[ch][blk]);
1081
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1082 1083
        }
    }
1084
    return count_mantissa_bits(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
1085 1086
}

1087

Justin Ruggles's avatar
Justin Ruggles committed
1088
/*
1089 1090
 * Constant bitrate bit allocation search.
 * Find the largest SNR offset that will allow data to fit in the frame.
1091
 */
1092
static int cbr_bit_allocation(AC3EncodeContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
1093
{
1094
    int ch;
1095
    int bits_left;
1096
    int snr_offset, snr_incr;
Fabrice Bellard's avatar
Fabrice Bellard committed
1097

1098
    bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
1099 1100
    if (bits_left < 0)
        return AVERROR(EINVAL);
1101

1102
    snr_offset = s->coarse_snr_offset << 4;
1103

1104 1105
    /* if previous frame SNR offset was 1023, check if current frame can also
       use SNR offset of 1023. if so, skip the search. */
1106
    if ((snr_offset | s->fine_snr_offset[1]) == 1023) {
1107 1108 1109 1110
        if (bit_alloc(s, 1023) <= bits_left)
            return 0;
    }

1111
    while (snr_offset >= 0 &&
1112
           bit_alloc(s, snr_offset) > bits_left) {
1113
        snr_offset -= 64;
1114
    }
1115
    if (snr_offset < 0)
1116
        return AVERROR(EINVAL);
1117

1118
    FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1119
    for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
1120
        while (snr_offset + snr_incr <= 1023 &&
1121 1122 1123 1124
               bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
            snr_offset += snr_incr;
            FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1125
    }
1126 1127
    FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
    reset_block_bap(s);
1128

1129
    s->coarse_snr_offset = snr_offset >> 4;
1130
    for (ch = !s->cpl_on; ch <= s->channels; ch++)
1131
        s->fine_snr_offset[ch] = snr_offset & 0xF;
1132

Fabrice Bellard's avatar
Fabrice Bellard committed
1133 1134 1135
    return 0;
}

1136

Justin Ruggles's avatar
Justin Ruggles committed
1137
/*
1138 1139 1140 1141 1142
 * Perform bit allocation search.
 * Finds the SNR offset value that maximizes quality and fits in the specified
 * frame size.  Output is the SNR offset and a set of bit allocation pointers
 * used to quantize the mantissas.
 */
1143
int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
1144 1145 1146
{
    count_frame_bits(s);

1147 1148
    s->exponent_bits = count_exponent_bits(s);

1149 1150
    bit_alloc_masking(s);

1151
    return cbr_bit_allocation(s);
1152 1153 1154
}


1155 1156
/**
 * Symmetric quantization on 'levels' levels.
Justin Ruggles's avatar
Justin Ruggles committed
1157 1158 1159 1160 1161
 *
 * @param c       unquantized coefficient
 * @param e       exponent
 * @param levels  number of quantization levels
 * @return        quantized coefficient
1162
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
1163 1164
static inline int sym_quant(int c, int e, int levels)
{
1165
    int v = (((levels * c) >> (24 - e)) + levels) >> 1;
1166
    av_assert2(v >= 0 && v < levels);
Fabrice Bellard's avatar
Fabrice Bellard committed
1167 1168 1169
    return v;
}

1170

1171 1172
/**
 * Asymmetric quantization on 2^qbits levels.
Justin Ruggles's avatar
Justin Ruggles committed
1173 1174 1175 1176 1177
 *
 * @param c      unquantized coefficient
 * @param e      exponent
 * @param qbits  number of quantization bits
 * @return       quantized coefficient
1178
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
1179 1180
static inline int asym_quant(int c, int e, int qbits)
{
1181
    int m;
1182

1183
    c = (((c << e) >> (24 - qbits)) + 1) >> 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1184
    m = (1 << (qbits-1));
1185 1186 1187 1188
    if (c >= m)
        c = m - 1;
    av_assert2(c >= -m);
    return c;
Fabrice Bellard's avatar
Fabrice Bellard committed
1189 1190
}

1191

1192 1193
/**
 * Quantize a set of mantissas for a single channel in a single block.
Justin Ruggles's avatar
Justin Ruggles committed
1194 1195 1196 1197 1198 1199 1200 1201
 *
 * @param s           Mantissa count context
 * @param fixed_coef  unquantized fixed-point coefficients
 * @param exp         exponents
 * @param bap         bit allocation pointer indices
 * @param[out] qmant  quantized coefficients
 * @param start_freq  starting coefficient bin
 * @param end_freq    ending coefficient bin
1202
 */
1203
static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef,
1204
                                      uint8_t *exp, uint8_t *bap,
1205
                                      int16_t *qmant, int start_freq,
1206
                                      int end_freq)
1207 1208 1209
{
    int i;

1210
    for (i = start_freq; i < end_freq; i++) {
1211
        int v;
1212
        int c = fixed_coef[i];
1213
        int e = exp[i];
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 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 1296
        int b = bap[i];
        switch (b) {
        case 0:
            v = 0;
            break;
        case 1:
            v = sym_quant(c, e, 3);
            switch (s->mant1_cnt) {
            case 0:
                s->qmant1_ptr = &qmant[i];
                v = 9 * v;
                s->mant1_cnt = 1;
                break;
            case 1:
                *s->qmant1_ptr += 3 * v;
                s->mant1_cnt = 2;
                v = 128;
                break;
            default:
                *s->qmant1_ptr += v;
                s->mant1_cnt = 0;
                v = 128;
                break;
            }
            break;
        case 2:
            v = sym_quant(c, e, 5);
            switch (s->mant2_cnt) {
            case 0:
                s->qmant2_ptr = &qmant[i];
                v = 25 * v;
                s->mant2_cnt = 1;
                break;
            case 1:
                *s->qmant2_ptr += 5 * v;
                s->mant2_cnt = 2;
                v = 128;
                break;
            default:
                *s->qmant2_ptr += v;
                s->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 (s->mant4_cnt) {
            case 0:
                s->qmant4_ptr = &qmant[i];
                v = 11 * v;
                s->mant4_cnt = 1;
                break;
            default:
                *s->qmant4_ptr += v;
                s->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[i] = v;
    }
}


/**
 * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
Justin Ruggles's avatar
Justin Ruggles committed
1297 1298
 *
 * @param s  AC-3 encoder private context
1299
 */
1300
void ff_ac3_quantize_mantissas(AC3EncodeContext *s)
1301
{
1302
    int blk, ch, ch0=0, got_cpl;
1303

1304
    for (blk = 0; blk < s->num_blocks; blk++) {
1305
        AC3Block *block = &s->blocks[blk];
1306
        AC3Mant m = { 0 };
1307

1308 1309 1310 1311 1312 1313 1314
        got_cpl = !block->cpl_in_use;
        for (ch = 1; ch <= s->channels; ch++) {
            if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
                ch0     = ch - 1;
                ch      = CPL_CH;
                got_cpl = 1;
            }
1315
            quantize_mantissas_blk_ch(&m, block->fixed_coef[ch],
1316 1317
                                      s->blocks[s->exp_ref_block[ch][blk]].exp[ch],
                                      s->ref_bap[ch][blk], block->qmant[ch],
1318 1319 1320
                                      s->start_freq[ch], block->end_freq[ch]);
            if (ch == CPL_CH)
                ch = ch0;
1321 1322 1323 1324 1325
        }
    }
}


Justin Ruggles's avatar
Justin Ruggles committed
1326
/*
1327 1328
 * Write the AC-3 frame header to the output bitstream.
 */
1329
static void ac3_output_frame_header(AC3EncodeContext *s)
1330
{
1331 1332
    AC3EncOptions *opt = &s->options;

1333 1334 1335 1336 1337 1338 1339 1340
    put_bits(&s->pb, 16, 0x0b77);   /* frame header */
    put_bits(&s->pb, 16, 0);        /* crc1: will be filled later */
    put_bits(&s->pb, 2,  s->bit_alloc.sr_code);
    put_bits(&s->pb, 6,  s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
    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)
1341
        put_bits(&s->pb, 2, s->center_mix_level);
1342
    if (s->channel_mode & 0x04)
1343
        put_bits(&s->pb, 2, s->surround_mix_level);
1344
    if (s->channel_mode == AC3_CHMODE_STEREO)
1345
        put_bits(&s->pb, 2, opt->dolby_surround_mode);
1346
    put_bits(&s->pb, 1, s->lfe_on); /* LFE */
1347
    put_bits(&s->pb, 5, -opt->dialogue_level);
1348 1349
    put_bits(&s->pb, 1, 0);         /* no compression control word */
    put_bits(&s->pb, 1, 0);         /* no lang code */
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
    put_bits(&s->pb, 1, opt->audio_production_info);
    if (opt->audio_production_info) {
        put_bits(&s->pb, 5, opt->mixing_level - 80);
        put_bits(&s->pb, 2, opt->room_type);
    }
    put_bits(&s->pb, 1, opt->copyright);
    put_bits(&s->pb, 1, opt->original);
    if (s->bitstream_id == 6) {
        /* alternate bit stream syntax */
        put_bits(&s->pb, 1, opt->extended_bsi_1);
        if (opt->extended_bsi_1) {
            put_bits(&s->pb, 2, opt->preferred_stereo_downmix);
            put_bits(&s->pb, 3, s->ltrt_center_mix_level);
            put_bits(&s->pb, 3, s->ltrt_surround_mix_level);
            put_bits(&s->pb, 3, s->loro_center_mix_level);
            put_bits(&s->pb, 3, s->loro_surround_mix_level);
        }
        put_bits(&s->pb, 1, opt->extended_bsi_2);
        if (opt->extended_bsi_2) {
            put_bits(&s->pb, 2, opt->dolby_surround_ex_mode);
            put_bits(&s->pb, 2, opt->dolby_headphone_mode);
            put_bits(&s->pb, 1, opt->ad_converter_type);
            put_bits(&s->pb, 9, 0);     /* xbsi2 and encinfo : reserved */
        }
    } else {
1375 1376
    put_bits(&s->pb, 1, 0);         /* no time code 1 */
    put_bits(&s->pb, 1, 0);         /* no time code 2 */
1377
    }
1378 1379 1380 1381
    put_bits(&s->pb, 1, 0);         /* no additional bit stream info */
}


Justin Ruggles's avatar
Justin Ruggles committed
1382
/*
1383 1384
 * Write one audio block to the output bitstream.
 */
1385
static void output_audio_block(AC3EncodeContext *s, int blk)
Fabrice Bellard's avatar
Fabrice Bellard committed
1386
{
1387
    int ch, i, baie, bnd, got_cpl, ch0;
1388
    AC3Block *block = &s->blocks[blk];
Fabrice Bellard's avatar
Fabrice Bellard committed
1389

1390
    /* block switching */
1391
    if (!s->eac3) {
1392 1393
        for (ch = 0; ch < s->fbw_channels; ch++)
            put_bits(&s->pb, 1, 0);
1394
    }
1395 1396

    /* dither flags */
1397
    if (!s->eac3) {
1398 1399
        for (ch = 0; ch < s->fbw_channels; ch++)
            put_bits(&s->pb, 1, 1);
1400
    }
1401 1402 1403 1404

    /* dynamic range codes */
    put_bits(&s->pb, 1, 0);

1405 1406 1407 1408
    /* spectral extension */
    if (s->eac3)
        put_bits(&s->pb, 1, 0);

1409
    /* channel coupling */
1410
    if (!s->eac3)
1411
        put_bits(&s->pb, 1, block->new_cpl_strategy);
1412
    if (block->new_cpl_strategy) {
1413
        if (!s->eac3)
1414
            put_bits(&s->pb, 1, block->cpl_in_use);
1415 1416
        if (block->cpl_in_use) {
            int start_sub, end_sub;
1417 1418 1419
            if (s->eac3)
                put_bits(&s->pb, 1, 0); /* enhanced coupling */
            if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) {
1420 1421
                for (ch = 1; ch <= s->fbw_channels; ch++)
                    put_bits(&s->pb, 1, block->channel_in_cpl[ch]);
1422
            }
1423 1424 1425 1426 1427 1428
            if (s->channel_mode == AC3_CHMODE_STEREO)
                put_bits(&s->pb, 1, 0); /* phase flags in use */
            start_sub = (s->start_freq[CPL_CH] - 37) / 12;
            end_sub   = (s->cpl_end_freq       - 37) / 12;
            put_bits(&s->pb, 4, start_sub);
            put_bits(&s->pb, 4, end_sub - 3);
1429 1430 1431 1432
            /* coupling band structure */
            if (s->eac3) {
                put_bits(&s->pb, 1, 0); /* use default */
            } else {
1433 1434
                for (bnd = start_sub+1; bnd < end_sub; bnd++)
                    put_bits(&s->pb, 1, ff_eac3_default_cpl_band_struct[bnd]);
1435
            }
1436 1437 1438 1439 1440 1441 1442
        }
    }

    /* coupling coordinates */
    if (block->cpl_in_use) {
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (block->channel_in_cpl[ch]) {
1443 1444 1445
                if (!s->eac3 || block->new_cpl_coords[ch] != 2)
                    put_bits(&s->pb, 1, block->new_cpl_coords[ch]);
                if (block->new_cpl_coords[ch]) {
1446 1447 1448 1449 1450 1451 1452 1453
                    put_bits(&s->pb, 2, block->cpl_master_exp[ch]);
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
                        put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]);
                        put_bits(&s->pb, 4, block->cpl_coord_mant[ch][bnd]);
                    }
                }
            }
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1454 1455
    }

1456
    /* stereo rematrixing */
1457
    if (s->channel_mode == AC3_CHMODE_STEREO) {
1458
        if (!s->eac3 || blk > 0)
1459
            put_bits(&s->pb, 1, block->new_rematrixing_strategy);
1460 1461
        if (block->new_rematrixing_strategy) {
            /* rematrixing flags */
1462 1463
            for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++)
                put_bits(&s->pb, 1, block->rematrixing_flags[bnd]);
1464 1465
        }
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1466 1467

    /* exponent strategy */
1468
    if (!s->eac3) {
1469 1470 1471 1472
        for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++)
            put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
        if (s->lfe_on)
            put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
1473
    }
1474

1475
    /* bandwidth */
1476 1477
    for (ch = 1; ch <= s->fbw_channels; ch++) {
        if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch])
1478
            put_bits(&s->pb, 6, s->bandwidth_code);
Fabrice Bellard's avatar
Fabrice Bellard committed
1479
    }
1480

Fabrice Bellard's avatar
Fabrice Bellard committed
1481
    /* exponents */
1482
    for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1483
        int nb_groups;
1484
        int cpl = (ch == CPL_CH);
1485

1486
        if (s->exp_strategy[ch][blk] == EXP_REUSE)
Fabrice Bellard's avatar
Fabrice Bellard committed
1487 1488
            continue;

1489
        /* DC exponent */
1490
        put_bits(&s->pb, 4, block->grouped_exp[ch][0] >> cpl);
1491

1492
        /* exponent groups */
1493
        nb_groups = exponent_group_tab[cpl][s->exp_strategy[ch][blk]-1][block->end_freq[ch]-s->start_freq[ch]];
1494
        for (i = 1; i <= nb_groups; i++)
1495
            put_bits(&s->pb, 7, block->grouped_exp[ch][i]);
Fabrice Bellard's avatar
Fabrice Bellard committed
1496

1497
        /* gain range info */
1498
        if (ch != s->lfe_channel && !cpl)
1499
            put_bits(&s->pb, 2, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
1500 1501 1502
    }

    /* bit allocation info */
1503
    if (!s->eac3) {
1504 1505 1506 1507 1508 1509 1510 1511 1512
        baie = (blk == 0);
        put_bits(&s->pb, 1, baie);
        if (baie) {
            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);
        }
1513
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1514 1515

    /* snr offset */
1516
    if (!s->eac3) {
1517 1518 1519 1520 1521 1522 1523
        put_bits(&s->pb, 1, block->new_snr_offsets);
        if (block->new_snr_offsets) {
            put_bits(&s->pb, 6, s->coarse_snr_offset);
            for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
                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
1524
        }
1525 1526 1527
    } else {
        put_bits(&s->pb, 1, 0); /* no converter snr offset */
    }
1528

1529 1530
    /* coupling leak */
    if (block->cpl_in_use) {
1531
        if (!s->eac3 || block->new_cpl_leak != 2)
1532
            put_bits(&s->pb, 1, block->new_cpl_leak);
1533 1534 1535 1536 1537 1538
        if (block->new_cpl_leak) {
            put_bits(&s->pb, 3, s->bit_alloc.cpl_fast_leak);
            put_bits(&s->pb, 3, s->bit_alloc.cpl_slow_leak);
        }
    }

1539
    if (!s->eac3) {
1540 1541
        put_bits(&s->pb, 1, 0); /* no delta bit allocation */
        put_bits(&s->pb, 1, 0); /* no data to skip */
1542
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1543

1544
    /* mantissas */
1545 1546
    got_cpl = !block->cpl_in_use;
    for (ch = 1; ch <= s->channels; ch++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1547
        int b, q;
1548 1549 1550 1551 1552 1553 1554

        if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
            ch0     = ch - 1;
            ch      = CPL_CH;
            got_cpl = 1;
        }
        for (i = s->start_freq[ch]; i < block->end_freq[ch]; i++) {
1555
            q = block->qmant[ch][i];
1556
            b = s->ref_bap[ch][blk][i];
1557
            switch (b) {
1558 1559 1560 1561 1562 1563 1564 1565
            case 0:                                          break;
            case 1: if (q != 128) put_bits (&s->pb,   5, q); break;
            case 2: if (q != 128) put_bits (&s->pb,   7, q); break;
            case 3:               put_sbits(&s->pb,   3, q); break;
            case 4: if (q != 128) put_bits (&s->pb,   7, q); break;
            case 14:              put_sbits(&s->pb,  14, q); break;
            case 15:              put_sbits(&s->pb,  16, q); break;
            default:              put_sbits(&s->pb, b-1, q); break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1566 1567
            }
        }
1568 1569
        if (ch == CPL_CH)
            ch = ch0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1570 1571 1572
    }
}

1573

1574
/** CRC-16 Polynomial */
Fabrice Bellard's avatar
Fabrice Bellard committed
1575 1576
#define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))

1577

Fabrice Bellard's avatar
Fabrice Bellard committed
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
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;
}

1594

Fabrice Bellard's avatar
Fabrice Bellard committed
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
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;
}

1608

Justin Ruggles's avatar
Justin Ruggles committed
1609
/*
1610 1611
 * Fill the end of the frame with 0's and compute the two CRCs.
 */
1612
static void output_frame_end(AC3EncodeContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
1613
{
1614
    const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
1615
    int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;
1616
    uint8_t *frame;
Fabrice Bellard's avatar
Fabrice Bellard committed
1617

1618
    frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1;
1619 1620

    /* pad the remainder of the frame with zeros */
1621
    av_assert2(s->frame_size * 8 - put_bits_count(&s->pb) >= 18);
Fabrice Bellard's avatar
Fabrice Bellard committed
1622 1623
    flush_put_bits(&s->pb);
    frame = s->pb.buf;
1624
    pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2;
1625
    av_assert2(pad_bytes >= 0);
1626 1627
    if (pad_bytes > 0)
        memset(put_bits_ptr(&s->pb), 0, pad_bytes);
1628

1629 1630 1631 1632
    if (s->eac3) {
        /* compute crc2 */
        crc2_partial = av_crc(crc_ctx, 0, frame + 2, s->frame_size - 5);
    } else {
1633 1634
    /* compute crc1 */
    /* this is not so easy because it is at the beginning of the data... */
1635
    crc1    = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4));
1636
    crc_inv = s->crc_inv[s->frame_size > s->frame_size_min];
1637 1638
    crc1    = mul_poly(crc_inv, crc1, CRC16_POLY);
    AV_WB16(frame + 2, crc1);
1639

1640
    /* compute crc2 */
1641 1642
    crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,
                          s->frame_size - frame_size_58 - 3);
1643
    }
1644 1645 1646 1647 1648 1649 1650
    crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
    /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
    if (crc2 == 0x770B) {
        frame[s->frame_size - 3] ^= 0x1;
        crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
    }
    crc2 = av_bswap16(crc2);
1651
    AV_WB16(frame + s->frame_size - 2, crc2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1652 1653
}

1654

1655 1656
/**
 * Write the frame to the output bitstream.
Justin Ruggles's avatar
Justin Ruggles committed
1657 1658 1659
 *
 * @param s      AC-3 encoder private context
 * @param frame  output data buffer
1660
 */
1661
void ff_ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
1662 1663 1664 1665 1666
{
    int blk;

    init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);

1667
    s->output_frame_header(s);
1668

1669
    for (blk = 0; blk < s->num_blocks; blk++)
1670
        output_audio_block(s, blk);
1671 1672 1673 1674 1675

    output_frame_end(s);
}


1676
static void dprint_options(AC3EncodeContext *s)
1677 1678
{
#ifdef DEBUG
1679
    AVCodecContext *avctx = s->avctx;
1680 1681 1682 1683
    AC3EncOptions *opt = &s->options;
    char strbuf[32];

    switch (s->bitstream_id) {
1684 1685 1686 1687 1688
    case  6:  av_strlcpy(strbuf, "AC-3 (alt syntax)",       32); break;
    case  8:  av_strlcpy(strbuf, "AC-3 (standard)",         32); break;
    case  9:  av_strlcpy(strbuf, "AC-3 (dnet half-rate)",   32); break;
    case 10:  av_strlcpy(strbuf, "AC-3 (dnet quater-rate)", 32); break;
    case 16:  av_strlcpy(strbuf, "E-AC-3 (enhanced)",       32); break;
1689 1690 1691 1692 1693 1694 1695 1696
    default: snprintf(strbuf, 32, "ERROR");
    }
    av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
    av_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
    av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout);
    av_dlog(avctx, "channel_layout: %s\n", strbuf);
    av_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
    av_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
1697
    av_dlog(avctx, "blocks/frame: %d (code=%d)\n", s->num_blocks, s->num_blks_code);
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
    if (s->cutoff)
        av_dlog(avctx, "cutoff: %d\n", s->cutoff);

    av_dlog(avctx, "per_frame_metadata: %s\n",
            opt->allow_per_frame_metadata?"on":"off");
    if (s->has_center)
        av_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
                s->center_mix_level);
    else
        av_dlog(avctx, "center_mixlev: {not written}\n");
    if (s->has_surround)
        av_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
                s->surround_mix_level);
    else
        av_dlog(avctx, "surround_mixlev: {not written}\n");
    if (opt->audio_production_info) {
        av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
        switch (opt->room_type) {
1716 1717 1718
        case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
        case AC3ENC_OPT_LARGE_ROOM:    av_strlcpy(strbuf, "large", 32);        break;
        case AC3ENC_OPT_SMALL_ROOM:    av_strlcpy(strbuf, "small", 32);        break;
1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
        default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
        }
        av_dlog(avctx, "room_type: %s\n", strbuf);
    } else {
        av_dlog(avctx, "mixing_level: {not written}\n");
        av_dlog(avctx, "room_type: {not written}\n");
    }
    av_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
    av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
    if (s->channel_mode == AC3_CHMODE_STEREO) {
        switch (opt->dolby_surround_mode) {
1730 1731 1732
        case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
        case AC3ENC_OPT_MODE_ON:       av_strlcpy(strbuf, "on", 32);           break;
        case AC3ENC_OPT_MODE_OFF:      av_strlcpy(strbuf, "off", 32);          break;
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
        default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
        }
        av_dlog(avctx, "dsur_mode: %s\n", strbuf);
    } else {
        av_dlog(avctx, "dsur_mode: {not written}\n");
    }
    av_dlog(avctx, "original: %s\n", opt->original?"on":"off");

    if (s->bitstream_id == 6) {
        if (opt->extended_bsi_1) {
            switch (opt->preferred_stereo_downmix) {
1744 1745 1746
            case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
            case AC3ENC_OPT_DOWNMIX_LTRT:  av_strlcpy(strbuf, "ltrt", 32);         break;
            case AC3ENC_OPT_DOWNMIX_LORO:  av_strlcpy(strbuf, "loro", 32);         break;
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
            }
            av_dlog(avctx, "dmix_mode: %s\n", strbuf);
            av_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
                    opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
            av_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
                    opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
            av_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
                    opt->loro_center_mix_level, s->loro_center_mix_level);
            av_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
                    opt->loro_surround_mix_level, s->loro_surround_mix_level);
        } else {
            av_dlog(avctx, "extended bitstream info 1: {not written}\n");
        }
        if (opt->extended_bsi_2) {
            switch (opt->dolby_surround_ex_mode) {
1763 1764 1765
            case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
            case AC3ENC_OPT_MODE_ON:       av_strlcpy(strbuf, "on", 32);           break;
            case AC3ENC_OPT_MODE_OFF:      av_strlcpy(strbuf, "off", 32);          break;
1766 1767 1768 1769
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
            }
            av_dlog(avctx, "dsurex_mode: %s\n", strbuf);
            switch (opt->dolby_headphone_mode) {
1770 1771 1772
            case AC3ENC_OPT_NOT_INDICATED: av_strlcpy(strbuf, "notindicated", 32); break;
            case AC3ENC_OPT_MODE_ON:       av_strlcpy(strbuf, "on", 32);           break;
            case AC3ENC_OPT_MODE_OFF:      av_strlcpy(strbuf, "off", 32);          break;
1773 1774 1775 1776 1777
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
            }
            av_dlog(avctx, "dheadphone_mode: %s\n", strbuf);

            switch (opt->ad_converter_type) {
1778 1779
            case AC3ENC_OPT_ADCONV_STANDARD: av_strlcpy(strbuf, "standard", 32); break;
            case AC3ENC_OPT_ADCONV_HDCD:     av_strlcpy(strbuf, "hdcd", 32);     break;
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
            }
            av_dlog(avctx, "ad_conv_type: %s\n", strbuf);
        } else {
            av_dlog(avctx, "extended bitstream info 2: {not written}\n");
        }
    }
#endif
}


#define FLT_OPTION_THRESHOLD 0.01

static int validate_float_option(float v, const float *v_list, int v_list_size)
{
    int i;

    for (i = 0; i < v_list_size; i++) {
        if (v < (v_list[i] + FLT_OPTION_THRESHOLD) &&
            v > (v_list[i] - FLT_OPTION_THRESHOLD))
            break;
    }
    if (i == v_list_size)
        return -1;

    return i;
}


static void validate_mix_level(void *log_ctx, const char *opt_name,
                               float *opt_param, const float *list,
                               int list_size, int default_value, int min_value,
                               int *ctx_param)
{
    int mixlev = validate_float_option(*opt_param, list, list_size);
    if (mixlev < min_value) {
        mixlev = default_value;
        if (*opt_param >= 0.0) {
            av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using "
                   "default value: %0.3f\n", opt_name, list[mixlev]);
        }
    }
    *opt_param = list[mixlev];
    *ctx_param = mixlev;
}


/**
 * Validate metadata options as set by AVOption system.
 * These values can optionally be changed per-frame.
Justin Ruggles's avatar
Justin Ruggles committed
1830 1831
 *
 * @param s  AC-3 encoder private context
1832
 */
1833
int ff_ac3_validate_metadata(AC3EncodeContext *s)
1834
{
1835
    AVCodecContext *avctx = s->avctx;
1836 1837
    AC3EncOptions *opt = &s->options;

1838 1839 1840 1841 1842 1843 1844
    opt->audio_production_info = 0;
    opt->extended_bsi_1        = 0;
    opt->extended_bsi_2        = 0;
    opt->eac3_mixing_metadata  = 0;
    opt->eac3_info_metadata    = 0;

    /* determine mixing metadata / xbsi1 use */
1845
    if (s->channel_mode > AC3_CHMODE_STEREO && opt->preferred_stereo_downmix != AC3ENC_OPT_NONE) {
1846 1847 1848 1849 1850 1851 1852
        opt->extended_bsi_1       = 1;
        opt->eac3_mixing_metadata = 1;
    }
    if (s->has_center &&
        (opt->ltrt_center_mix_level >= 0 || opt->loro_center_mix_level >= 0)) {
        opt->extended_bsi_1       = 1;
        opt->eac3_mixing_metadata = 1;
1853
    }
1854 1855 1856 1857
    if (s->has_surround &&
        (opt->ltrt_surround_mix_level >= 0 || opt->loro_surround_mix_level >= 0)) {
        opt->extended_bsi_1       = 1;
        opt->eac3_mixing_metadata = 1;
1858 1859
    }

1860 1861 1862 1863
    if (s->eac3) {
        /* determine info metadata use */
        if (avctx->audio_service_type != AV_AUDIO_SERVICE_TYPE_MAIN)
            opt->eac3_info_metadata = 1;
1864
        if (opt->copyright != AC3ENC_OPT_NONE || opt->original != AC3ENC_OPT_NONE)
1865 1866
            opt->eac3_info_metadata = 1;
        if (s->channel_mode == AC3_CHMODE_STEREO &&
1867
            (opt->dolby_headphone_mode != AC3ENC_OPT_NONE || opt->dolby_surround_mode != AC3ENC_OPT_NONE))
1868
            opt->eac3_info_metadata = 1;
1869
        if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
1870
            opt->eac3_info_metadata = 1;
1871 1872
        if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE ||
            opt->ad_converter_type != AC3ENC_OPT_NONE) {
1873 1874
            opt->audio_production_info = 1;
            opt->eac3_info_metadata    = 1;
1875 1876
        }
    } else {
1877
        /* determine audio production info use */
1878
        if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE)
1879 1880 1881
            opt->audio_production_info = 1;

        /* determine xbsi2 use */
1882
        if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
1883
            opt->extended_bsi_2 = 1;
1884
        if (s->channel_mode == AC3_CHMODE_STEREO && opt->dolby_headphone_mode != AC3ENC_OPT_NONE)
1885
            opt->extended_bsi_2 = 1;
1886
        if (opt->ad_converter_type != AC3ENC_OPT_NONE)
1887
            opt->extended_bsi_2 = 1;
1888 1889
    }

1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
    /* validate AC-3 mixing levels */
    if (!s->eac3) {
        if (s->has_center) {
            validate_mix_level(avctx, "center_mix_level", &opt->center_mix_level,
                            cmixlev_options, CMIXLEV_NUM_OPTIONS, 1, 0,
                            &s->center_mix_level);
        }
        if (s->has_surround) {
            validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
                            surmixlev_options, SURMIXLEV_NUM_OPTIONS, 1, 0,
                            &s->surround_mix_level);
        }
    }

    /* validate extended bsi 1 / mixing metadata */
    if (opt->extended_bsi_1 || opt->eac3_mixing_metadata) {
1906
        /* default preferred stereo downmix */
1907 1908
        if (opt->preferred_stereo_downmix == AC3ENC_OPT_NONE)
            opt->preferred_stereo_downmix = AC3ENC_OPT_NOT_INDICATED;
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
        if (!s->eac3 || s->has_center) {
            /* validate Lt/Rt center mix level */
            validate_mix_level(avctx, "ltrt_center_mix_level",
                               &opt->ltrt_center_mix_level, extmixlev_options,
                               EXTMIXLEV_NUM_OPTIONS, 5, 0,
                               &s->ltrt_center_mix_level);
            /* validate Lo/Ro center mix level */
            validate_mix_level(avctx, "loro_center_mix_level",
                               &opt->loro_center_mix_level, extmixlev_options,
                               EXTMIXLEV_NUM_OPTIONS, 5, 0,
                               &s->loro_center_mix_level);
        }
        if (!s->eac3 || s->has_surround) {
            /* validate Lt/Rt surround mix level */
            validate_mix_level(avctx, "ltrt_surround_mix_level",
                               &opt->ltrt_surround_mix_level, extmixlev_options,
                               EXTMIXLEV_NUM_OPTIONS, 6, 3,
                               &s->ltrt_surround_mix_level);
            /* validate Lo/Ro surround mix level */
            validate_mix_level(avctx, "loro_surround_mix_level",
                               &opt->loro_surround_mix_level, extmixlev_options,
                               EXTMIXLEV_NUM_OPTIONS, 6, 3,
                               &s->loro_surround_mix_level);
        }
1933 1934
    }

1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
    /* validate audio service type / channels combination */
    if ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_KARAOKE &&
         avctx->channels == 1) ||
        ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_COMMENTARY ||
          avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_EMERGENCY  ||
          avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_VOICE_OVER)
         && avctx->channels > 1)) {
        av_log(avctx, AV_LOG_ERROR, "invalid audio service type for the "
                                    "specified number of channels\n");
        return AVERROR(EINVAL);
    }

    /* validate extended bsi 2 / info metadata */
    if (opt->extended_bsi_2 || opt->eac3_info_metadata) {
1949
        /* default dolby headphone mode */
1950 1951
        if (opt->dolby_headphone_mode == AC3ENC_OPT_NONE)
            opt->dolby_headphone_mode = AC3ENC_OPT_NOT_INDICATED;
1952
        /* default dolby surround ex mode */
1953 1954
        if (opt->dolby_surround_ex_mode == AC3ENC_OPT_NONE)
            opt->dolby_surround_ex_mode = AC3ENC_OPT_NOT_INDICATED;
1955
        /* default A/D converter type */
1956 1957
        if (opt->ad_converter_type == AC3ENC_OPT_NONE)
            opt->ad_converter_type = AC3ENC_OPT_ADCONV_STANDARD;
1958 1959 1960 1961 1962
    }

    /* copyright & original defaults */
    if (!s->eac3 || opt->eac3_info_metadata) {
        /* default copyright */
1963 1964
        if (opt->copyright == AC3ENC_OPT_NONE)
            opt->copyright = AC3ENC_OPT_OFF;
1965
        /* default original */
1966 1967
        if (opt->original == AC3ENC_OPT_NONE)
            opt->original = AC3ENC_OPT_ON;
1968 1969 1970 1971
    }

    /* dolby surround mode default */
    if (!s->eac3 || opt->eac3_info_metadata) {
1972 1973
        if (opt->dolby_surround_mode == AC3ENC_OPT_NONE)
            opt->dolby_surround_mode = AC3ENC_OPT_NOT_INDICATED;
1974 1975 1976 1977
    }

    /* validate audio production info */
    if (opt->audio_production_info) {
1978
        if (opt->mixing_level == AC3ENC_OPT_NONE) {
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
            av_log(avctx, AV_LOG_ERROR, "mixing_level must be set if "
                   "room_type is set\n");
            return AVERROR(EINVAL);
        }
        if (opt->mixing_level < 80) {
            av_log(avctx, AV_LOG_ERROR, "invalid mixing level. must be between "
                   "80dB and 111dB\n");
            return AVERROR(EINVAL);
        }
        /* default room type */
1989 1990
        if (opt->room_type == AC3ENC_OPT_NONE)
            opt->room_type = AC3ENC_OPT_NOT_INDICATED;
1991 1992 1993
    }

    /* set bitstream id for alternate bitstream syntax */
1994
    if (!s->eac3 && (opt->extended_bsi_1 || opt->extended_bsi_2)) {
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
        if (s->bitstream_id > 8 && s->bitstream_id < 11) {
            static int warn_once = 1;
            if (warn_once) {
                av_log(avctx, AV_LOG_WARNING, "alternate bitstream syntax is "
                       "not compatible with reduced samplerates. writing of "
                       "extended bitstream information will be disabled.\n");
                warn_once = 0;
            }
        } else {
            s->bitstream_id = 6;
        }
    }

    return 0;
}


2012 2013
/**
 * Finalize encoding and free any memory allocated by the encoder.
Justin Ruggles's avatar
Justin Ruggles committed
2014 2015
 *
 * @param avctx  Codec context
2016
 */
2017
av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
2018
{
2019
    int blk, ch;
2020 2021
    AC3EncodeContext *s = avctx->priv_data;

2022
    av_freep(&s->windowed_samples);
2023 2024 2025
    for (ch = 0; ch < s->channels; ch++)
        av_freep(&s->planar_samples[ch]);
    av_freep(&s->planar_samples);
2026 2027
    av_freep(&s->bap_buffer);
    av_freep(&s->bap1_buffer);
2028
    av_freep(&s->mdct_coef_buffer);
2029
    av_freep(&s->fixed_coef_buffer);
2030 2031 2032 2033 2034 2035
    av_freep(&s->exp_buffer);
    av_freep(&s->grouped_exp_buffer);
    av_freep(&s->psd_buffer);
    av_freep(&s->band_psd_buffer);
    av_freep(&s->mask_buffer);
    av_freep(&s->qmant_buffer);
Justin Ruggles's avatar
Justin Ruggles committed
2036 2037
    av_freep(&s->cpl_coord_exp_buffer);
    av_freep(&s->cpl_coord_mant_buffer);
2038
    for (blk = 0; blk < s->num_blocks; blk++) {
2039
        AC3Block *block = &s->blocks[blk];
2040
        av_freep(&block->mdct_coef);
2041
        av_freep(&block->fixed_coef);
2042 2043 2044 2045 2046 2047
        av_freep(&block->exp);
        av_freep(&block->grouped_exp);
        av_freep(&block->psd);
        av_freep(&block->band_psd);
        av_freep(&block->mask);
        av_freep(&block->qmant);
Justin Ruggles's avatar
Justin Ruggles committed
2048 2049
        av_freep(&block->cpl_coord_exp);
        av_freep(&block->cpl_coord_mant);
2050 2051
    }

2052
    s->mdct_end(s);
2053

2054
    return 0;
2055 2056
}

2057

Justin Ruggles's avatar
Justin Ruggles committed
2058
/*
2059 2060
 * Set channel information during initialization.
 */
2061
static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
2062
                                    uint64_t *channel_layout)
2063 2064 2065 2066
{
    int ch_layout;

    if (channels < 1 || channels > AC3_MAX_CHANNELS)
2067
        return AVERROR(EINVAL);
2068
    if (*channel_layout > 0x7FF)
2069
        return AVERROR(EINVAL);
2070 2071
    ch_layout = *channel_layout;
    if (!ch_layout)
2072
        ch_layout = av_get_default_channel_layout(channels);
2073 2074 2075 2076

    s->lfe_on       = !!(ch_layout & AV_CH_LOW_FREQUENCY);
    s->channels     = channels;
    s->fbw_channels = channels - s->lfe_on;
2077
    s->lfe_channel  = s->lfe_on ? s->fbw_channels + 1 : -1;
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091
    if (s->lfe_on)
        ch_layout -= AV_CH_LOW_FREQUENCY;

    switch (ch_layout) {
    case AV_CH_LAYOUT_MONO:           s->channel_mode = AC3_CHMODE_MONO;   break;
    case AV_CH_LAYOUT_STEREO:         s->channel_mode = AC3_CHMODE_STEREO; break;
    case AV_CH_LAYOUT_SURROUND:       s->channel_mode = AC3_CHMODE_3F;     break;
    case AV_CH_LAYOUT_2_1:            s->channel_mode = AC3_CHMODE_2F1R;   break;
    case AV_CH_LAYOUT_4POINT0:        s->channel_mode = AC3_CHMODE_3F1R;   break;
    case AV_CH_LAYOUT_QUAD:
    case AV_CH_LAYOUT_2_2:            s->channel_mode = AC3_CHMODE_2F2R;   break;
    case AV_CH_LAYOUT_5POINT0:
    case AV_CH_LAYOUT_5POINT0_BACK:   s->channel_mode = AC3_CHMODE_3F2R;   break;
    default:
2092
        return AVERROR(EINVAL);
2093
    }
2094 2095
    s->has_center   = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
    s->has_surround =  s->channel_mode & 0x04;
2096 2097 2098 2099 2100 2101 2102 2103 2104

    s->channel_map  = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on];
    *channel_layout = ch_layout;
    if (s->lfe_on)
        *channel_layout |= AV_CH_LOW_FREQUENCY;

    return 0;
}

2105

2106
static av_cold int validate_options(AC3EncodeContext *s)
2107
{
2108
    AVCodecContext *avctx = s->avctx;
2109
    int i, ret, max_sr;
2110

2111
    /* validate channel layout */
2112 2113 2114 2115 2116
    if (!avctx->channel_layout) {
        av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
                                      "encoder will guess the layout, but it "
                                      "might be incorrect.\n");
    }
2117 2118
    ret = set_channel_info(s, avctx->channels, &avctx->channel_layout);
    if (ret) {
2119
        av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
2120
        return ret;
2121 2122
    }

2123
    /* validate sample rate */
2124 2125 2126 2127 2128 2129
    /* note: max_sr could be changed from 2 to 5 for E-AC-3 once we find a
             decoder that supports half sample rate so we can validate that
             the generated files are correct. */
    max_sr = s->eac3 ? 2 : 8;
    for (i = 0; i <= max_sr; i++) {
        if ((ff_ac3_sample_rate_tab[i % 3] >> (i / 3)) == avctx->sample_rate)
2130
            break;
2131
    }
2132
    if (i > max_sr) {
2133 2134
        av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
        return AVERROR(EINVAL);
2135
    }
2136
    s->sample_rate        = avctx->sample_rate;
2137 2138 2139
    s->bit_alloc.sr_shift = i / 3;
    s->bit_alloc.sr_code  = i % 3;
    s->bitstream_id       = s->eac3 ? 16 : 8 + s->bit_alloc.sr_shift;
2140

2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151
    /* select a default bit rate if not set by the user */
    if (!avctx->bit_rate) {
        switch (s->fbw_channels) {
        case 1: avctx->bit_rate =  96000; break;
        case 2: avctx->bit_rate = 192000; break;
        case 3: avctx->bit_rate = 320000; break;
        case 4: avctx->bit_rate = 384000; break;
        case 5: avctx->bit_rate = 448000; break;
        }
    }

2152
    /* validate bit rate */
2153 2154
    if (s->eac3) {
        int max_br, min_br, wpf, min_br_dist, min_br_code;
2155
        int num_blks_code, num_blocks, frame_samples;
2156 2157

        /* calculate min/max bitrate */
2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168
        /* TODO: More testing with 3 and 2 blocks. All E-AC-3 samples I've
                 found use either 6 blocks or 1 block, even though 2 or 3 blocks
                 would work as far as the bit rate is concerned. */
        for (num_blks_code = 3; num_blks_code >= 0; num_blks_code--) {
            num_blocks = ((int[]){ 1, 2, 3, 6 })[num_blks_code];
            frame_samples  = AC3_BLOCK_SIZE * num_blocks;
            max_br = 2048 * s->sample_rate / frame_samples * 16;
            min_br = ((s->sample_rate + (frame_samples-1)) / frame_samples) * 16;
            if (avctx->bit_rate <= max_br)
                break;
        }
2169 2170 2171 2172 2173
        if (avctx->bit_rate < min_br || avctx->bit_rate > max_br) {
            av_log(avctx, AV_LOG_ERROR, "invalid bit rate. must be %d to %d "
                   "for this sample rate\n", min_br, max_br);
            return AVERROR(EINVAL);
        }
2174 2175
        s->num_blks_code = num_blks_code;
        s->num_blocks    = num_blocks;
2176 2177

        /* calculate words-per-frame for the selected bitrate */
2178
        wpf = (avctx->bit_rate / 16) * frame_samples / s->sample_rate;
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
        av_assert1(wpf > 0 && wpf <= 2048);

        /* find the closest AC-3 bitrate code to the selected bitrate.
           this is needed for lookup tables for bandwidth and coupling
           parameter selection */
        min_br_code = -1;
        min_br_dist = INT_MAX;
        for (i = 0; i < 19; i++) {
            int br_dist = abs(ff_ac3_bitrate_tab[i] * 1000 - avctx->bit_rate);
            if (br_dist < min_br_dist) {
                min_br_dist = br_dist;
                min_br_code = i;
            }
        }

        /* make sure the minimum frame size is below the average frame size */
        s->frame_size_code = min_br_code << 1;
        while (wpf > 1 && wpf * s->sample_rate / AC3_FRAME_SIZE * 16 > avctx->bit_rate)
            wpf--;
        s->frame_size_min = 2 * wpf;
    } else {
2200
        int best_br = 0, best_code = 0, best_diff = INT_MAX;
2201
        for (i = 0; i < 19; i++) {
2202 2203 2204 2205 2206 2207 2208 2209
            int br   = (ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift) * 1000;
            int diff = abs(br - avctx->bit_rate);
            if (diff < best_diff) {
                best_br   = br;
                best_code = i;
                best_diff = diff;
            }
            if (!best_diff)
2210 2211
                break;
        }
2212 2213
        avctx->bit_rate    = best_br;
        s->frame_size_code = best_code << 1;
2214
        s->frame_size_min  = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
2215 2216
        s->num_blks_code   = 0x3;
        s->num_blocks      = 6;
2217 2218 2219
    }
    s->bit_rate   = avctx->bit_rate;
    s->frame_size = s->frame_size_min;
2220

2221 2222 2223 2224 2225 2226 2227 2228 2229
    /* validate cutoff */
    if (avctx->cutoff < 0) {
        av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
        return AVERROR(EINVAL);
    }
    s->cutoff = avctx->cutoff;
    if (s->cutoff > (s->sample_rate >> 1))
        s->cutoff = s->sample_rate >> 1;

Justin Ruggles's avatar
Justin Ruggles committed
2230 2231 2232
    ret = ff_ac3_validate_metadata(s);
    if (ret)
        return ret;
2233

2234 2235 2236
    s->rematrixing_enabled = s->options.stereo_rematrixing &&
                             (s->channel_mode == AC3_CHMODE_STEREO);

2237
    s->cpl_enabled = s->options.channel_coupling &&
2238
                     s->channel_mode >= AC3_CHMODE_STEREO;
2239

2240 2241 2242 2243
    return 0;
}


Justin Ruggles's avatar
Justin Ruggles committed
2244
/*
2245 2246 2247 2248
 * Set bandwidth for all channels.
 * The user can optionally supply a cutoff frequency. Otherwise an appropriate
 * default value will be used.
 */
2249
static av_cold void set_bandwidth(AC3EncodeContext *s)
2250
{
2251
    int blk, ch, cpl_start;
2252

2253
    if (s->cutoff) {
2254 2255
        /* calculate bandwidth based on user-specified cutoff frequency */
        int fbw_coeffs;
2256
        fbw_coeffs     = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
2257
        s->bandwidth_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
2258 2259
    } else {
        /* use default bandwidth setting */
2260
        s->bandwidth_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
2261 2262 2263
    }

    /* set number of coefficients for each channel */
2264 2265
    for (ch = 1; ch <= s->fbw_channels; ch++) {
        s->start_freq[ch] = 0;
2266
        for (blk = 0; blk < s->num_blocks; blk++)
2267 2268 2269 2270 2271
            s->blocks[blk].end_freq[ch] = s->bandwidth_code * 3 + 73;
    }
    /* LFE channel always has 7 coefs */
    if (s->lfe_on) {
        s->start_freq[s->lfe_channel] = 0;
2272
        for (blk = 0; blk < s->num_blocks; blk++)
2273 2274 2275 2276 2277
            s->blocks[blk].end_freq[ch] = 7;
    }

    /* initialize coupling strategy */
    if (s->cpl_enabled) {
2278
        if (s->options.cpl_start != AC3ENC_OPT_AUTO) {
2279 2280 2281
            cpl_start = s->options.cpl_start;
        } else {
            cpl_start = ac3_coupling_start_tab[s->channel_mode-2][s->bit_alloc.sr_code][s->frame_size_code/2];
2282
            if (cpl_start < 0) {
2283
                if (s->options.channel_coupling == AC3ENC_OPT_AUTO)
2284 2285 2286 2287
                    s->cpl_enabled = 0;
                else
                    cpl_start = 15;
            }
2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312
        }
    }
    if (s->cpl_enabled) {
        int i, cpl_start_band, cpl_end_band;
        uint8_t *cpl_band_sizes = s->cpl_band_sizes;

        cpl_end_band   = s->bandwidth_code / 4 + 3;
        cpl_start_band = av_clip(cpl_start, 0, FFMIN(cpl_end_band-1, 15));

        s->num_cpl_subbands = cpl_end_band - cpl_start_band;

        s->num_cpl_bands = 1;
        *cpl_band_sizes  = 12;
        for (i = cpl_start_band + 1; i < cpl_end_band; i++) {
            if (ff_eac3_default_cpl_band_struct[i]) {
                *cpl_band_sizes += 12;
            } else {
                s->num_cpl_bands++;
                cpl_band_sizes++;
                *cpl_band_sizes = 12;
            }
        }

        s->start_freq[CPL_CH] = cpl_start_band * 12 + 37;
        s->cpl_end_freq       = cpl_end_band   * 12 + 37;
2313
        for (blk = 0; blk < s->num_blocks; blk++)
2314
            s->blocks[blk].end_freq[CPL_CH] = s->cpl_end_freq;
2315 2316 2317 2318
    }
}


2319
static av_cold int allocate_buffers(AC3EncodeContext *s)
2320
{
2321
    AVCodecContext *avctx = s->avctx;
2322
    int blk, ch;
2323
    int channels = s->channels + 1; /* includes coupling channel */
2324 2325
    int channel_blocks = channels * s->num_blocks;
    int total_coefs    = AC3_MAX_COEFS * channel_blocks;
2326

2327 2328 2329
    if (s->allocate_sample_buffers(s))
        goto alloc_fail;

2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
    FF_ALLOC_OR_GOTO(avctx, s->bap_buffer, total_coefs *
                     sizeof(*s->bap_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, total_coefs *
                     sizeof(*s->bap1_buffer), alloc_fail);
    FF_ALLOCZ_OR_GOTO(avctx, s->mdct_coef_buffer, total_coefs *
                      sizeof(*s->mdct_coef_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, total_coefs *
                     sizeof(*s->exp_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, channel_blocks * 128 *
                     sizeof(*s->grouped_exp_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, total_coefs *
                     sizeof(*s->psd_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, channel_blocks * 64 *
                     sizeof(*s->band_psd_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, channel_blocks * 64 *
                     sizeof(*s->mask_buffer), alloc_fail);
    FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, total_coefs *
                     sizeof(*s->qmant_buffer), alloc_fail);
2348
    if (s->cpl_enabled) {
2349 2350 2351 2352
        FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_exp_buffer, channel_blocks * 16 *
                         sizeof(*s->cpl_coord_exp_buffer), alloc_fail);
        FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_mant_buffer, channel_blocks * 16 *
                         sizeof(*s->cpl_coord_mant_buffer), alloc_fail);
2353
    }
2354
    for (blk = 0; blk < s->num_blocks; blk++) {
2355
        AC3Block *block = &s->blocks[blk];
2356
        FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, channels * sizeof(*block->mdct_coef),
2357
                          alloc_fail);
2358
        FF_ALLOCZ_OR_GOTO(avctx, block->exp, channels * sizeof(*block->exp),
2359
                          alloc_fail);
2360
        FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, channels * sizeof(*block->grouped_exp),
2361
                          alloc_fail);
2362
        FF_ALLOCZ_OR_GOTO(avctx, block->psd, channels * sizeof(*block->psd),
2363
                          alloc_fail);
2364
        FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, channels * sizeof(*block->band_psd),
2365
                          alloc_fail);
2366
        FF_ALLOCZ_OR_GOTO(avctx, block->mask, channels * sizeof(*block->mask),
2367
                          alloc_fail);
2368
        FF_ALLOCZ_OR_GOTO(avctx, block->qmant, channels * sizeof(*block->qmant),
2369
                          alloc_fail);
2370 2371 2372 2373 2374 2375
        if (s->cpl_enabled) {
            FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_exp, channels * sizeof(*block->cpl_coord_exp),
                              alloc_fail);
            FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_mant, channels * sizeof(*block->cpl_coord_mant),
                              alloc_fail);
        }
2376

2377
        for (ch = 0; ch < channels; ch++) {
2378
            /* arrangement: block, channel, coeff */
2379 2380 2381 2382 2383 2384 2385 2386 2387
            block->grouped_exp[ch] = &s->grouped_exp_buffer[128           * (blk * channels + ch)];
            block->psd[ch]         = &s->psd_buffer        [AC3_MAX_COEFS * (blk * channels + ch)];
            block->band_psd[ch]    = &s->band_psd_buffer   [64            * (blk * channels + ch)];
            block->mask[ch]        = &s->mask_buffer       [64            * (blk * channels + ch)];
            block->qmant[ch]       = &s->qmant_buffer      [AC3_MAX_COEFS * (blk * channels + ch)];
            if (s->cpl_enabled) {
                block->cpl_coord_exp[ch]  = &s->cpl_coord_exp_buffer [16  * (blk * channels + ch)];
                block->cpl_coord_mant[ch] = &s->cpl_coord_mant_buffer[16  * (blk * channels + ch)];
            }
2388 2389

            /* arrangement: channel, block, coeff */
2390 2391
            block->exp[ch]         = &s->exp_buffer        [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
            block->mdct_coef[ch]   = &s->mdct_coef_buffer  [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2392
        }
2393 2394
    }

2395
    if (!s->fixed_point) {
2396 2397 2398
        FF_ALLOCZ_OR_GOTO(avctx, s->fixed_coef_buffer, total_coefs *
                          sizeof(*s->fixed_coef_buffer), alloc_fail);
        for (blk = 0; blk < s->num_blocks; blk++) {
2399
            AC3Block *block = &s->blocks[blk];
2400
            FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
2401
                              sizeof(*block->fixed_coef), alloc_fail);
2402
            for (ch = 0; ch < channels; ch++)
2403
                block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2404 2405
        }
    } else {
2406
        for (blk = 0; blk < s->num_blocks; blk++) {
2407
            AC3Block *block = &s->blocks[blk];
2408
            FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
2409
                              sizeof(*block->fixed_coef), alloc_fail);
2410
            for (ch = 0; ch < channels; ch++)
2411 2412 2413 2414
                block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
        }
    }

2415 2416 2417 2418 2419 2420
    return 0;
alloc_fail:
    return AVERROR(ENOMEM);
}


2421
av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
2422 2423
{
    AC3EncodeContext *s = avctx->priv_data;
2424
    int ret, frame_size_58;
2425

2426 2427
    s->avctx = avctx;

2428
    s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
2429

2430
    ff_ac3_common_init();
2431

2432
    ret = validate_options(s);
2433 2434 2435
    if (ret)
        return ret;

2436
    avctx->frame_size = AC3_BLOCK_SIZE * s->num_blocks;
2437
    avctx->delay      = AC3_BLOCK_SIZE;
2438

2439 2440 2441
    s->bitstream_mode = avctx->audio_service_type;
    if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
        s->bitstream_mode = 0x7;
2442

2443 2444 2445
    s->bits_written    = 0;
    s->samples_written = 0;

2446 2447 2448 2449 2450 2451 2452 2453
    /* calculate crc_inv for both possible frame sizes */
    frame_size_58 = (( s->frame_size    >> 2) + ( s->frame_size    >> 4)) << 1;
    s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
    if (s->bit_alloc.sr_code == 1) {
        frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
        s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
    }

2454
    /* set function pointers */
2455 2456 2457
    if (CONFIG_AC3_FIXED_ENCODER && s->fixed_point) {
        s->mdct_end                     = ff_ac3_fixed_mdct_end;
        s->mdct_init                    = ff_ac3_fixed_mdct_init;
2458
        s->allocate_sample_buffers      = ff_ac3_fixed_allocate_sample_buffers;
2459 2460 2461
    } else if (CONFIG_AC3_ENCODER || CONFIG_EAC3_ENCODER) {
        s->mdct_end                     = ff_ac3_float_mdct_end;
        s->mdct_init                    = ff_ac3_float_mdct_init;
2462
        s->allocate_sample_buffers      = ff_ac3_float_allocate_sample_buffers;
2463
    }
2464 2465 2466 2467 2468
    if (CONFIG_EAC3_ENCODER && s->eac3)
        s->output_frame_header = ff_eac3_output_frame_header;
    else
        s->output_frame_header = ac3_output_frame_header;

2469
    set_bandwidth(s);
2470

2471 2472
    exponent_init(s);

2473
    bit_alloc_init(s);
2474

2475
    ret = s->mdct_init(s);
2476
    if (ret)
2477
        goto init_fail;
2478

2479
    ret = allocate_buffers(s);
2480
    if (ret)
2481
        goto init_fail;
2482

2483
    ff_dsputil_init(&s->dsp, avctx);
2484
    avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2485
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
2486

2487
    dprint_options(s);
2488

2489
    return 0;
2490
init_fail:
2491
    ff_ac3_encode_close(avctx);
2492
    return ret;
2493
}