ac3enc.c 85 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 8 9
 * This file is part of FFmpeg.
 *
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; 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 "internal.h"
40
#include "me_cmp.h"
41
#include "put_bits.h"
42
#include "audiodsp.h"
43
#include "ac3dsp.h"
44
#include "ac3.h"
45
#include "fft.h"
46 47
#include "ac3enc.h"
#include "eac3enc.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
48

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

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
#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
};


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

77

78 79 80
/**
 * List of supported channel layouts.
 */
81
const uint64_t ff_ac3_channel_layouts[19] = {
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
     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
};


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 131 132 133
/**
 * 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 } }
};


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 174 175 176
/**
 * 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 } },
};


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


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

    /* set coupling use flags for each block/channel */
    /* TODO: turn coupling on/off and adjust start band based on bit usage */
209
    for (blk = 0; blk < s->num_blocks; blk++) {
210 211 212 213 214 215 216 217
        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;
218
    num_cpl_blocks = 0;
219
    for (blk = 0; blk < s->num_blocks; blk++) {
220 221 222 223 224
        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;
225
        num_cpl_blocks += block->cpl_in_use;
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
        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;
        }
    }
251 252
    if (!num_cpl_blocks)
        s->cpl_on = 0;
253 254

    /* set bandwidth for each channel */
255
    for (blk = 0; blk < s->num_blocks; blk++) {
256 257 258 259 260 261 262 263 264 265 266
        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;
        }
    }
}


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

279
    if (!s->rematrixing_enabled)
280 281
        return;

282
    for (blk = 0; blk < s->num_blocks; blk++) {
283 284 285
        AC3Block *block = &s->blocks[blk];
        if (block->new_rematrixing_strategy)
            flags = block->rematrixing_flags;
286 287
        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
288 289 290 291
            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++) {
292 293 294 295
                    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;
296 297 298 299 300 301 302
                }
            }
        }
    }
}


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

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

    if (CONFIG_EAC3_ENCODER && s->eac3)
        ff_eac3_exponent_init();
322 323 324
}


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

334
    s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);
335 336 337
}


338 339 340 341
/**
 * Exponent Difference Threshold.
 * New exponents are sent if their SAD exceed this number.
 */
342
#define EXP_DIFF_THRESHOLD 500
343

344 345 346 347 348 349 350 351 352
/**
 * 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 }
};
353

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

362
    for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {
363 364 365 366 367 368 369 370
        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;
371
        for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {
372 373 374 375 376 377 378 379 380
            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]) {
381 382 383
                exp_strategy[blk] = EXP_NEW;
                continue;
            }
384
            exp_diff = s->mecc.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
385 386 387 388
            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)
389 390 391 392 393 394
                exp_strategy[blk] = EXP_NEW;
        }

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

    /* for E-AC-3, determine frame exponent strategy */
    if (CONFIG_EAC3_ENCODER && s->eac3)
        ff_eac3_get_frame_exp_strategy(s);
413 414 415
}


416 417
/**
 * Update the exponents so that they are the ones the decoder will decode.
Justin Ruggles's avatar
Justin Ruggles committed
418 419 420 421 422
 *
 * @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
423
 */
424 425
static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
                                    int cpl)
Fabrice Bellard's avatar
Fabrice Bellard committed
426
{
427
    int nb_groups, i, k;
Fabrice Bellard's avatar
Fabrice Bellard committed
428

429
    nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
Fabrice Bellard's avatar
Fabrice Bellard committed
430 431

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

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

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

469 470 471
    if (cpl)
        exp[-1] = exp[0] & ~1;

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

490

Justin Ruggles's avatar
Justin Ruggles committed
491
/*
492 493 494 495 496
 * 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.
 */
497
static void encode_exponents(AC3EncodeContext *s)
498
{
499
    int blk, blk1, ch, cpl;
500
    uint8_t *exp, *exp_strategy;
501
    int nb_coefs, num_reuse_blocks;
502

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

507
        cpl = (ch == CPL_CH);
508
        blk = 0;
509
        while (blk < s->num_blocks) {
510 511 512 513 514 515 516
            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];
517
            blk1 = blk + 1;
518

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

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

532
            encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);
533

534
            exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);
535 536 537
            blk = blk1;
        }
    }
538 539 540

    /* reference block numbers have been changed, so reset ref_bap_set */
    s->ref_bap_set = 0;
541 542 543
}


Justin Ruggles's avatar
Justin Ruggles committed
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 569 570 571
 * 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;
}


572 573 574 575
/**
 * 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
576 577
 *
 * @param s  AC-3 encoder private context
578
 */
579
void ff_ac3_group_exponents(AC3EncodeContext *s)
580
{
581
    int blk, ch, i, cpl;
582
    int group_size, nb_groups;
583 584 585 586
    uint8_t *p;
    int delta0, delta1, delta2;
    int exp0, exp1;

587
    for (blk = 0; blk < s->num_blocks; blk++) {
588
        AC3Block *block = &s->blocks[blk];
589
        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
590 591
            int exp_strategy = s->exp_strategy[ch][blk];
            if (exp_strategy == EXP_REUSE)
592
                continue;
593
            cpl = (ch == CPL_CH);
594
            group_size = exp_strategy + (exp_strategy == EXP_D45);
595 596
            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;
597 598 599

            /* DC exponent */
            exp1 = *p++;
600
            block->grouped_exp[ch][0] = exp1;
601 602

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

                exp0   = exp1;
                exp1   = p[0];
                p     += group_size;
                delta1 = exp1 - exp0 + 2;
615
                av_assert2(delta1 >= 0 && delta1 <= 4);
616 617 618 619 620

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

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


/**
 * 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
634 635
 *
 * @param s  AC-3 encoder private context
636
 */
637
void ff_ac3_process_exponents(AC3EncodeContext *s)
638
{
639
    extract_exponents(s);
640

641
    compute_exp_strategy(s);
642

643
    encode_exponents(s);
644

645
    emms_c();
646 647 648
}


Justin Ruggles's avatar
Justin Ruggles committed
649
/*
650 651 652 653 654 655 656 657 658 659 660 661 662 663
 * 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
664
     *   no auxiliary data
665
     *   no E-AC-3 metadata
666 667
     */

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

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

709 710
            /* dither flags */
            frame_bits += s->fbw_channels;
711
        }
712 713 714 715

        /* dynamic range */
        frame_bits++;

716 717
        /* spectral extension */
        if (s->eac3)
718 719
            frame_bits++;

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

726 727 728 729
            /* bit allocation params */
            frame_bits++;
            if (!blk)
                frame_bits += 2 + 2 + 2 + 2 + 3;
730
        }
731

732 733 734 735 736
        /* converter snr offset */
        if (s->eac3)
            frame_bits++;

        if (!s->eac3) {
737 738
            /* delta bit allocation */
            frame_bits++;
739

740 741
            /* skipped data */
            frame_bits++;
742
        }
743 744
    }

745 746
    /* auxiliary data */
    frame_bits++;
747 748

    /* CRC */
749
    frame_bits += 1 + 16;
750 751 752 753 754

    s->frame_bits_fixed = frame_bits;
}


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

    /* init default parameters */
    s->slow_decay_code = 2;
    s->fast_decay_code = 1;
    s->slow_gain_code  = 1;
767
    s->db_per_bit_code = s->eac3 ? 2 : 3;
768
    s->floor_code      = 7;
769
    for (ch = 0; ch <= s->channels; ch++)
770 771 772 773 774 775 776 777 778 779 780 781 782
        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];
783 784
    s->bit_alloc.cpl_fast_leak = 0;
    s->bit_alloc.cpl_slow_leak = 0;
785 786

    count_frame_bits_fixed(s);
787 788 789
}


Justin Ruggles's avatar
Justin Ruggles committed
790
/*
791
 * Count the bits used to encode the frame, minus exponents and mantissas.
792 793
 * 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.
794
 */
795
static void count_frame_bits(AC3EncodeContext *s)
796
{
797
    AC3EncOptions *opt = &s->options;
798
    int blk, ch;
799
    int frame_bits = 0;
800

801
    /* header */
802
    if (s->eac3) {
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
        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++;
        }
827 828 829
        /* coupling */
        if (s->channel_mode > AC3_CHMODE_MONO) {
            frame_bits++;
830
            for (blk = 1; blk < s->num_blocks; blk++) {
831 832 833 834 835 836 837
                AC3Block *block = &s->blocks[blk];
                frame_bits++;
                if (block->new_cpl_strategy)
                    frame_bits++;
            }
        }
        /* coupling exponent strategy */
838 839 840 841
        if (s->cpl_on) {
            if (s->use_frame_exp_strategy) {
                frame_bits += 5 * s->cpl_on;
            } else {
842
                for (blk = 0; blk < s->num_blocks; blk++)
843 844 845
                    frame_bits += 2 * s->blocks[blk].cpl_in_use;
            }
        }
846
    } else {
847 848 849 850 851 852 853 854
        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;
        }
855 856
    }

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

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

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

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

904
        /* bandwidth codes & gain range */
905 906 907 908 909 910 911 912 913
        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 */
914
        if (!s->eac3 && block->cpl_in_use)
915 916 917
            frame_bits += 2;

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

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

933
    s->frame_bits = s->frame_bits_fixed + frame_bits;
934 935 936
}


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

945
    for (blk = 0; blk < s->num_blocks; blk++) {
946
        AC3Block *block = &s->blocks[blk];
947
        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
948 949 950
            /* 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. */
951
            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
952 953 954
                ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
                                          block->end_freq[ch], block->psd[ch],
                                          block->band_psd[ch]);
955
                ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
956
                                           s->start_freq[ch], block->end_freq[ch],
957
                                           ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
958
                                           ch == s->lfe_channel,
959
                                           DBA_NONE, 0, NULL, NULL, NULL,
960
                                           block->mask[ch]);
961 962 963 964 965
            }
        }
    }
}

966

Justin Ruggles's avatar
Justin Ruggles committed
967
/*
968 969 970 971 972 973
 * 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;
974 975 976
    uint8_t *ref_bap;

    if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
977
        return;
978 979 980

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


989 990 991 992
/**
 * 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
993 994
 *
 * @param[in,out] mant_cnt  running counts for each bap value for each block
995 996
 */
static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
Fabrice Bellard's avatar
Fabrice Bellard committed
997
{
998 999
    int blk;

1000
    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
        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
1011 1012 1013 1014 1015 1016
 *
 * @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
1017 1018 1019 1020 1021 1022
 */
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
1023

1024
    for (blk = 0; blk < s->num_blocks; blk++) {
1025
        AC3Block *block = &s->blocks[blk];
1026 1027 1028 1029 1030
        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);
1031 1032 1033 1034
    }
}


Justin Ruggles's avatar
Justin Ruggles committed
1035
/*
1036 1037 1038 1039 1040
 * 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;
1041
    LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
1042 1043 1044 1045 1046 1047 1048 1049 1050

    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);
1051
}
1052

1053

1054 1055 1056 1057
/**
 * 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
1058 1059 1060
 *
 * @param s           AC-3 encoder private context
 * @param snr_offset  SNR offset, 0 to 1023
1061 1062
 * @return the number of bits needed for mantissas if the given SNR offset is
 *         is used.
1063
 */
1064
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
Fabrice Bellard's avatar
Fabrice Bellard committed
1065
{
1066
    int blk, ch;
Justin Ruggles's avatar
Justin Ruggles committed
1067

1068
    snr_offset = (snr_offset - 240) << 2;
Fabrice Bellard's avatar
Fabrice Bellard committed
1069

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

1074
        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1075 1076 1077 1078
            /* 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. */
1079
            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1080
                s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch],
1081 1082
                                             s->start_freq[ch], block->end_freq[ch],
                                             snr_offset, s->bit_alloc.floor,
1083
                                             ff_ac3_bap_tab, s->ref_bap[ch][blk]);
1084
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1085 1086
        }
    }
1087
    return count_mantissa_bits(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
1088 1089
}

1090

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

1101
    bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
1102 1103
    if (bits_left < 0)
        return AVERROR(EINVAL);
1104

1105
    snr_offset = s->coarse_snr_offset << 4;
1106

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

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

1121
    FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1122
    for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
1123
        while (snr_offset + snr_incr <= 1023 &&
1124 1125 1126 1127
               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
1128
    }
1129 1130
    FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
    reset_block_bap(s);
1131

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1136 1137 1138
    return 0;
}

1139

Justin Ruggles's avatar
Justin Ruggles committed
1140
/*
1141 1142 1143 1144 1145
 * 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.
 */
1146
int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
1147 1148 1149
{
    count_frame_bits(s);

1150 1151
    s->exponent_bits = count_exponent_bits(s);

1152 1153
    bit_alloc_masking(s);

1154
    return cbr_bit_allocation(s);
1155 1156 1157
}


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

1173

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

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

1194

1195 1196
/**
 * Quantize a set of mantissas for a single channel in a single block.
Justin Ruggles's avatar
Justin Ruggles committed
1197 1198 1199 1200 1201 1202 1203 1204
 *
 * @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
1205
 */
1206
static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef,
1207
                                      uint8_t *exp, uint8_t *bap,
1208
                                      int16_t *qmant, int start_freq,
1209
                                      int end_freq)
1210 1211 1212
{
    int i;

1213
    for (i = start_freq; i < end_freq; i++) {
1214
        int c = fixed_coef[i];
1215
        int e = exp[i];
1216 1217 1218
        int v = bap[i];
        if (v)
        switch (v) {
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
        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:
1287
            v = asym_quant(c, e, v - 1);
1288 1289 1290 1291 1292 1293 1294 1295 1296
            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, av_uninit(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);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1513 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
    } else {
        put_bits(&s->pb, 1, 0); /* no converter snr offset */
Fabrice Bellard's avatar
Fabrice Bellard committed
1527
    }
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
    default: snprintf(strbuf, 32, "ERROR");
    }
1691 1692
    ff_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
    ff_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
1693
    av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout);
1694 1695 1696 1697
    ff_dlog(avctx, "channel_layout: %s\n", strbuf);
    ff_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
    ff_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
    ff_dlog(avctx, "blocks/frame: %d (code=%d)\n", s->num_blocks, s->num_blks_code);
1698
    if (s->cutoff)
1699
        ff_dlog(avctx, "cutoff: %d\n", s->cutoff);
1700

1701
    ff_dlog(avctx, "per_frame_metadata: %s\n",
1702 1703
            opt->allow_per_frame_metadata?"on":"off");
    if (s->has_center)
1704
        ff_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
1705 1706
                s->center_mix_level);
    else
1707
        ff_dlog(avctx, "center_mixlev: {not written}\n");
1708
    if (s->has_surround)
1709
        ff_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
1710 1711
                s->surround_mix_level);
    else
1712
        ff_dlog(avctx, "surround_mixlev: {not written}\n");
1713
    if (opt->audio_production_info) {
1714
        ff_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
1715
        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
        default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
        }
1721
        ff_dlog(avctx, "room_type: %s\n", strbuf);
1722
    } else {
1723 1724
        ff_dlog(avctx, "mixing_level: {not written}\n");
        ff_dlog(avctx, "room_type: {not written}\n");
1725
    }
1726 1727
    ff_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
    ff_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
1728 1729
    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
        default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
        }
1735
        ff_dlog(avctx, "dsur_mode: %s\n", strbuf);
1736
    } else {
1737
        ff_dlog(avctx, "dsur_mode: {not written}\n");
1738
    }
1739
    ff_dlog(avctx, "original: %s\n", opt->original?"on":"off");
1740 1741 1742 1743

    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
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
            }
1749 1750
            ff_dlog(avctx, "dmix_mode: %s\n", strbuf);
            ff_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
1751
                    opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
1752
            ff_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
1753
                    opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
1754
            ff_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
1755
                    opt->loro_center_mix_level, s->loro_center_mix_level);
1756
            ff_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
1757 1758
                    opt->loro_surround_mix_level, s->loro_surround_mix_level);
        } else {
1759
            ff_dlog(avctx, "extended bitstream info 1: {not written}\n");
1760 1761 1762
        }
        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
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
            }
1768
            ff_dlog(avctx, "dsurex_mode: %s\n", strbuf);
1769
            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
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
            }
1775
            ff_dlog(avctx, "dheadphone_mode: %s\n", strbuf);
1776 1777

            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
            default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
            }
1782
            ff_dlog(avctx, "ad_conv_type: %s\n", strbuf);
1783
        } else {
1784
            ff_dlog(avctx, "extended bitstream info 2: {not written}\n");
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
        }
    }
#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
    if (s->planar_samples)
2024 2025 2026
    for (ch = 0; ch < s->channels; ch++)
        av_freep(&s->planar_samples[ch]);
    av_freep(&s->planar_samples);
2027 2028
    av_freep(&s->bap_buffer);
    av_freep(&s->bap1_buffer);
2029
    av_freep(&s->mdct_coef_buffer);
2030
    av_freep(&s->fixed_coef_buffer);
2031 2032 2033 2034 2035 2036
    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
2037 2038
    av_freep(&s->cpl_coord_exp_buffer);
    av_freep(&s->cpl_coord_mant_buffer);
2039
    av_freep(&s->fdsp);
2040
    for (blk = 0; blk < s->num_blocks; blk++) {
2041
        AC3Block *block = &s->blocks[blk];
2042
        av_freep(&block->mdct_coef);
2043
        av_freep(&block->fixed_coef);
2044 2045 2046 2047 2048 2049
        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
2050 2051
        av_freep(&block->cpl_coord_exp);
        av_freep(&block->cpl_coord_mant);
2052 2053
    }

2054
    s->mdct_end(s);
2055

2056
    return 0;
2057 2058
}

2059

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

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

    s->lfe_on       = !!(ch_layout & AV_CH_LOW_FREQUENCY);
    s->channels     = channels;
    s->fbw_channels = channels - s->lfe_on;
2079
    s->lfe_channel  = s->lfe_on ? s->fbw_channels + 1 : -1;
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
    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:
2094
        return AVERROR(EINVAL);
2095
    }
2096 2097
    s->has_center   = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
    s->has_surround =  s->channel_mode & 0x04;
2098 2099 2100 2101 2102 2103 2104 2105 2106

    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;
}

2107

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

2113
    /* validate channel layout */
2114 2115 2116 2117 2118
    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");
    }
2119 2120
    ret = set_channel_info(s, avctx->channels, &avctx->channel_layout);
    if (ret) {
2121
        av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
2122
        return ret;
2123 2124
    }

2125
    /* validate sample rate */
2126 2127 2128 2129 2130 2131
    /* 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)
2132
            break;
2133
    }
2134
    if (i > max_sr) {
2135 2136
        av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
        return AVERROR(EINVAL);
2137
    }
2138
    s->sample_rate        = avctx->sample_rate;
2139 2140 2141
    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;
2142

2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
    /* 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;
        }
    }

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

        /* calculate min/max bitrate */
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
        /* 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;
        }
2172 2173 2174 2175 2176
        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);
        }
2177 2178
        s->num_blks_code = num_blks_code;
        s->num_blocks    = num_blocks;
2179 2180

        /* calculate words-per-frame for the selected bitrate */
2181
        wpf = (avctx->bit_rate / 16) * frame_samples / s->sample_rate;
2182 2183 2184 2185 2186 2187
        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;
2188
        min_br_dist = INT64_MAX;
2189
        for (i = 0; i < 19; i++) {
2190
            long long br_dist = llabs(ff_ac3_bitrate_tab[i] * 1000 - avctx->bit_rate);
2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
            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 {
2203 2204
        int best_br = 0, best_code = 0;
        long long best_diff = INT64_MAX;
2205
        for (i = 0; i < 19; i++) {
2206
            int br   = (ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift) * 1000;
2207
            long long diff = llabs(br - avctx->bit_rate);
2208 2209 2210 2211 2212 2213
            if (diff < best_diff) {
                best_br   = br;
                best_code = i;
                best_diff = diff;
            }
            if (!best_diff)
2214 2215
                break;
        }
2216 2217
        avctx->bit_rate    = best_br;
        s->frame_size_code = best_code << 1;
2218
        s->frame_size_min  = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
2219 2220
        s->num_blks_code   = 0x3;
        s->num_blocks      = 6;
2221
    }
2222 2223
    s->bit_rate   = avctx->bit_rate;
    s->frame_size = s->frame_size_min;
2224

2225 2226 2227 2228 2229 2230 2231 2232 2233
    /* 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
2234 2235 2236
    ret = ff_ac3_validate_metadata(s);
    if (ret)
        return ret;
2237

2238 2239 2240
    s->rematrixing_enabled = s->options.stereo_rematrixing &&
                             (s->channel_mode == AC3_CHMODE_STEREO);

2241
    s->cpl_enabled = s->options.channel_coupling &&
2242
                     s->channel_mode >= AC3_CHMODE_STEREO;
2243

2244 2245 2246 2247
    return 0;
}


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

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

    /* set number of coefficients for each channel */
2268 2269
    for (ch = 1; ch <= s->fbw_channels; ch++) {
        s->start_freq[ch] = 0;
2270
        for (blk = 0; blk < s->num_blocks; blk++)
2271 2272 2273 2274 2275
            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;
2276
        for (blk = 0; blk < s->num_blocks; blk++)
2277 2278 2279 2280 2281
            s->blocks[blk].end_freq[ch] = 7;
    }

    /* initialize coupling strategy */
    if (s->cpl_enabled) {
2282
        if (s->options.cpl_start != AC3ENC_OPT_AUTO) {
2283 2284 2285
            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];
2286
            if (cpl_start < 0) {
2287
                if (s->options.channel_coupling == AC3ENC_OPT_AUTO)
2288 2289 2290 2291
                    s->cpl_enabled = 0;
                else
                    cpl_start = 15;
            }
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
        }
    }
    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;
2317
        for (blk = 0; blk < s->num_blocks; blk++)
2318
            s->blocks[blk].end_freq[CPL_CH] = s->cpl_end_freq;
2319 2320 2321 2322
    }
}


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

2331 2332 2333
    if (s->allocate_sample_buffers(s))
        goto alloc_fail;

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

2381
        for (ch = 0; ch < channels; ch++) {
2382
            /* arrangement: block, channel, coeff */
2383 2384 2385 2386 2387 2388 2389 2390 2391
            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)];
            }
2392 2393

            /* arrangement: channel, block, coeff */
2394 2395
            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)];
2396
        }
2397 2398
    }

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

2419 2420 2421 2422 2423 2424
    return 0;
alloc_fail:
    return AVERROR(ENOMEM);
}


2425
av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
2426 2427
{
    AC3EncodeContext *s = avctx->priv_data;
2428
    int ret, frame_size_58;
2429

2430 2431
    s->avctx = avctx;

2432
    s->eac3 = avctx->codec_id == AV_CODEC_ID_EAC3;
2433

2434
    ff_ac3_common_init();
2435

2436
    ret = validate_options(s);
2437 2438 2439
    if (ret)
        return ret;

2440
    avctx->frame_size = AC3_BLOCK_SIZE * s->num_blocks;
2441
    avctx->initial_padding = AC3_BLOCK_SIZE;
2442

2443 2444 2445
    s->bitstream_mode = avctx->audio_service_type;
    if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
        s->bitstream_mode = 0x7;
2446

2447 2448 2449
    s->bits_written    = 0;
    s->samples_written = 0;

2450 2451 2452 2453 2454 2455 2456 2457
    /* 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);
    }

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

2473
    set_bandwidth(s);
2474

2475 2476
    exponent_init(s);

2477
    bit_alloc_init(s);
2478

2479
    ret = s->mdct_init(s);
2480
    if (ret)
2481
        goto init_fail;
2482

2483
    ret = allocate_buffers(s);
2484
    if (ret)
2485
        goto init_fail;
2486

2487
    ff_audiodsp_init(&s->adsp);
2488
    ff_me_cmp_init(&s->mecc, avctx);
2489
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
2490

2491
    dprint_options(s);
2492

2493
    return 0;
2494
init_fail:
2495
    ff_ac3_encode_close(avctx);
2496
    return ret;
2497
}