PageRenderTime 103ms CodeModel.GetById 7ms app.highlight 82ms RepoModel.GetById 1ms app.codeStats 1ms

/libavcodec/ac3enc.c

http://github.com/FFmpeg/FFmpeg
C | 2495 lines | 1792 code | 307 blank | 396 comment | 517 complexity | 691dd5f7fb64670d0ef49c8127af5a86 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * The simplest AC-3 encoder
   3 * Copyright (c) 2000 Fabrice Bellard
   4 * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
   5 * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
   6 *
   7 * This file is part of FFmpeg.
   8 *
   9 * FFmpeg is free software; you can redistribute it and/or
  10 * modify it under the terms of the GNU Lesser General Public
  11 * License as published by the Free Software Foundation; either
  12 * version 2.1 of the License, or (at your option) any later version.
  13 *
  14 * FFmpeg is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 * Lesser General Public License for more details.
  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
  22 */
  23
  24/**
  25 * @file
  26 * The simplest AC-3 encoder.
  27 */
  28
  29#include <stdint.h>
  30
  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"
  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#include "ac3enc.h"
  47#include "eac3enc.h"
  48
  49typedef struct AC3Mant {
  50    int16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
  51    int mant1_cnt, mant2_cnt, mant4_cnt;    ///< mantissa counts for bap=1,2,4
  52} AC3Mant;
  53
  54#define CMIXLEV_NUM_OPTIONS 3
  55static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
  56    LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
  57};
  58
  59#define SURMIXLEV_NUM_OPTIONS 3
  60static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
  61    LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
  62};
  63
  64#define EXTMIXLEV_NUM_OPTIONS 8
  65static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = {
  66    LEVEL_PLUS_3DB,  LEVEL_PLUS_1POINT5DB,  LEVEL_ONE,       LEVEL_MINUS_1POINT5DB,
  67    LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO
  68};
  69
  70
  71/**
  72 * LUT for number of exponent groups.
  73 * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
  74 */
  75static uint8_t exponent_group_tab[2][3][256];
  76
  77
  78/**
  79 * List of supported channel layouts.
  80 */
  81const uint64_t ff_ac3_channel_layouts[19] = {
  82     AV_CH_LAYOUT_MONO,
  83     AV_CH_LAYOUT_STEREO,
  84     AV_CH_LAYOUT_2_1,
  85     AV_CH_LAYOUT_SURROUND,
  86     AV_CH_LAYOUT_2_2,
  87     AV_CH_LAYOUT_QUAD,
  88     AV_CH_LAYOUT_4POINT0,
  89     AV_CH_LAYOUT_5POINT0,
  90     AV_CH_LAYOUT_5POINT0_BACK,
  91    (AV_CH_LAYOUT_MONO     | AV_CH_LOW_FREQUENCY),
  92    (AV_CH_LAYOUT_STEREO   | AV_CH_LOW_FREQUENCY),
  93    (AV_CH_LAYOUT_2_1      | AV_CH_LOW_FREQUENCY),
  94    (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY),
  95    (AV_CH_LAYOUT_2_2      | AV_CH_LOW_FREQUENCY),
  96    (AV_CH_LAYOUT_QUAD     | AV_CH_LOW_FREQUENCY),
  97    (AV_CH_LAYOUT_4POINT0  | AV_CH_LOW_FREQUENCY),
  98     AV_CH_LAYOUT_5POINT1,
  99     AV_CH_LAYOUT_5POINT1_BACK,
 100     0
 101};
 102
 103
 104/**
 105 * LUT to select the bandwidth code based on the bit rate, sample rate, and
 106 * number of full-bandwidth channels.
 107 * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
 108 */
 109static const uint8_t ac3_bandwidth_tab[5][3][19] = {
 110//      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640
 111
 112    { {  0,  0,  0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
 113      {  0,  0,  0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
 114      {  0,  0,  0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
 115
 116    { {  0,  0,  0,  0,  0,  0,  0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
 117      {  0,  0,  0,  0,  0,  0,  4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
 118      {  0,  0,  0,  0,  0,  0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
 119
 120    { {  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
 121      {  0,  0,  0,  0,  0,  0,  0,  0,  4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
 122      {  0,  0,  0,  0,  0,  0,  0,  0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
 123
 124    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
 125      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
 126      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
 127
 128    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8, 20, 32, 40, 48, 48, 48, 48 },
 129      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 24, 36, 44, 56, 56, 56, 56 },
 130      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 28, 44, 60, 60, 60, 60, 60, 60 } }
 131};
 132
 133
 134/**
 135 * LUT to select the coupling start band based on the bit rate, sample rate, and
 136 * number of full-bandwidth channels. -1 = coupling off
 137 * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
 138 *
 139 * TODO: more testing for optimal parameters.
 140 *       multi-channel tests at 44.1kHz and 32kHz.
 141 */
 142static const int8_t ac3_coupling_start_tab[6][3][19] = {
 143//      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640
 144
 145    // 2/0
 146    { {  0,  0,  0,  0,  0,  0,  0,  1,  1,  7,  8, 11, 12, -1, -1, -1, -1, -1, -1 },
 147      {  0,  0,  0,  0,  0,  0,  1,  3,  5,  7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
 148      {  0,  0,  0,  0,  1,  2,  2,  9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
 149
 150    // 3/0
 151    { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
 152      {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
 153      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
 154
 155    // 2/1 - untested
 156    { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
 157      {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
 158      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
 159
 160    // 3/1
 161    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
 162      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
 163      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
 164
 165    // 2/2 - untested
 166    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
 167      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
 168      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
 169
 170    // 3/2
 171    { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },
 172      {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },
 173      { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
 174};
 175
 176
 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.
 180 *
 181 * @param s  AC-3 encoder private context
 182 */
 183void ff_ac3_adjust_frame_size(AC3EncodeContext *s)
 184{
 185    while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
 186        s->bits_written    -= s->bit_rate;
 187        s->samples_written -= s->sample_rate;
 188    }
 189    s->frame_size = s->frame_size_min +
 190                    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
 196/**
 197 * Set the initial coupling strategy parameters prior to coupling analysis.
 198 *
 199 * @param s  AC-3 encoder private context
 200 */
 201void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
 202{
 203    int blk, ch;
 204    int got_cpl_snr;
 205    int num_cpl_blocks;
 206
 207    /* set coupling use flags for each block/channel */
 208    /* TODO: turn coupling on/off and adjust start band based on bit usage */
 209    for (blk = 0; blk < s->num_blocks; blk++) {
 210        AC3Block *block = &s->blocks[blk];
 211        for (ch = 1; ch <= s->fbw_channels; ch++)
 212            block->channel_in_cpl[ch] = s->cpl_on;
 213    }
 214
 215    /* enable coupling for each block if at least 2 channels have coupling
 216       enabled for that block */
 217    got_cpl_snr = 0;
 218    num_cpl_blocks = 0;
 219    for (blk = 0; blk < s->num_blocks; blk++) {
 220        AC3Block *block = &s->blocks[blk];
 221        block->num_cpl_channels = 0;
 222        for (ch = 1; ch <= s->fbw_channels; ch++)
 223            block->num_cpl_channels += block->channel_in_cpl[ch];
 224        block->cpl_in_use = block->num_cpl_channels > 1;
 225        num_cpl_blocks += block->cpl_in_use;
 226        if (!block->cpl_in_use) {
 227            block->num_cpl_channels = 0;
 228            for (ch = 1; ch <= s->fbw_channels; ch++)
 229                block->channel_in_cpl[ch] = 0;
 230        }
 231
 232        block->new_cpl_strategy = !blk;
 233        if (blk) {
 234            for (ch = 1; ch <= s->fbw_channels; ch++) {
 235                if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
 236                    block->new_cpl_strategy = 1;
 237                    break;
 238                }
 239            }
 240        }
 241        block->new_cpl_leak = block->new_cpl_strategy;
 242
 243        if (!blk || (block->cpl_in_use && !got_cpl_snr)) {
 244            block->new_snr_offsets = 1;
 245            if (block->cpl_in_use)
 246                got_cpl_snr = 1;
 247        } else {
 248            block->new_snr_offsets = 0;
 249        }
 250    }
 251    if (!num_cpl_blocks)
 252        s->cpl_on = 0;
 253
 254    /* set bandwidth for each channel */
 255    for (blk = 0; blk < s->num_blocks; blk++) {
 256        AC3Block *block = &s->blocks[blk];
 257        for (ch = 1; ch <= s->fbw_channels; ch++) {
 258            if (block->channel_in_cpl[ch])
 259                block->end_freq[ch] = s->start_freq[CPL_CH];
 260            else
 261                block->end_freq[ch] = s->bandwidth_code * 3 + 73;
 262        }
 263    }
 264}
 265
 266
 267/**
 268 * Apply stereo rematrixing to coefficients based on rematrixing flags.
 269 *
 270 * @param s  AC-3 encoder private context
 271 */
 272void ff_ac3_apply_rematrixing(AC3EncodeContext *s)
 273{
 274    int nb_coefs;
 275    int blk, bnd, i;
 276    int start, end;
 277    uint8_t *flags = NULL;
 278
 279    if (!s->rematrixing_enabled)
 280        return;
 281
 282    for (blk = 0; blk < s->num_blocks; blk++) {
 283        AC3Block *block = &s->blocks[blk];
 284        if (block->new_rematrixing_strategy)
 285            flags = block->rematrixing_flags;
 286        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
 287        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
 288            if (flags[bnd]) {
 289                start = ff_ac3_rematrix_band_tab[bnd];
 290                end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
 291                for (i = start; i < end; i++) {
 292                    int32_t lt = block->fixed_coef[1][i];
 293                    int32_t rt = block->fixed_coef[2][i];
 294                    block->fixed_coef[1][i] = (lt + rt) >> 1;
 295                    block->fixed_coef[2][i] = (lt - rt) >> 1;
 296                }
 297            }
 298        }
 299    }
 300}
 301
 302
 303/*
 304 * Initialize exponent tables.
 305 */
 306static av_cold void exponent_init(AC3EncodeContext *s)
 307{
 308    int expstr, i, grpsize;
 309
 310    for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
 311        grpsize = 3 << expstr;
 312        for (i = 12; i < 256; i++) {
 313            exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;
 314            exponent_group_tab[1][expstr][i] = (i              ) / grpsize;
 315        }
 316    }
 317    /* LFE */
 318    exponent_group_tab[0][0][7] = 2;
 319
 320    if (CONFIG_EAC3_ENCODER && s->eac3)
 321        ff_eac3_exponent_init();
 322}
 323
 324
 325/*
 326 * Extract exponents from the MDCT coefficients.
 327 */
 328static 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 * Exponent Difference Threshold.
 340 * New exponents are sent if their SAD exceed this number.
 341 */
 342#define EXP_DIFF_THRESHOLD 500
 343
 344/**
 345 * Table used to select exponent strategy based on exponent reuse block interval.
 346 */
 347static const uint8_t exp_strategy_reuse_tab[4][6] = {
 348    { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
 349    { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
 350    { EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
 351    { EXP_D45, EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15 }
 352};
 353
 354/*
 355 * Calculate exponent strategies for all channels.
 356 * Array arrangement is reversed to simplify the per-channel calculation.
 357 */
 358static 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        uint8_t *exp_strategy = s->exp_strategy[ch];
 364        uint8_t *exp          = s->blocks[0].exp[ch];
 365        int exp_diff;
 366
 367        /* estimate if the exponent variation & decide if they should be
 368           reused in the next frame */
 369        exp_strategy[0] = EXP_NEW;
 370        exp += AC3_MAX_COEFS;
 371        for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {
 372            if (ch == CPL_CH) {
 373                if (!s->blocks[blk-1].cpl_in_use) {
 374                    exp_strategy[blk] = EXP_NEW;
 375                    continue;
 376                } else if (!s->blocks[blk].cpl_in_use) {
 377                    exp_strategy[blk] = EXP_REUSE;
 378                    continue;
 379                }
 380            } else if (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
 381                exp_strategy[blk] = EXP_NEW;
 382                continue;
 383            }
 384            exp_diff = s->mecc.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
 385            exp_strategy[blk] = EXP_REUSE;
 386            if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))
 387                exp_strategy[blk] = EXP_NEW;
 388            else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)
 389                exp_strategy[blk] = EXP_NEW;
 390        }
 391
 392        /* now select the encoding strategy type : if exponents are often
 393           recoded, we use a coarse encoding */
 394        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            blk = blk1;
 401        }
 402    }
 403    if (s->lfe_on) {
 404        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    /* for E-AC-3, determine frame exponent strategy */
 411    if (CONFIG_EAC3_ENCODER && s->eac3)
 412        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.
 418 *
 419 * @param[in,out] exp   array of exponents for 1 block in 1 channel
 420 * @param nb_exps       number of exponents in active bandwidth
 421 * @param exp_strategy  exponent strategy for the block
 422 * @param cpl           indicates if the block is in the coupling channel
 423 */
 424static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
 425                                    int cpl)
 426{
 427    int nb_groups, i, k;
 428
 429    nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
 430
 431    /* for each group, compute the minimum exponent */
 432    switch(exp_strategy) {
 433    case EXP_D25:
 434        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
 435            uint8_t exp_min = exp[k];
 436            if (exp[k+1] < exp_min)
 437                exp_min = exp[k+1];
 438            exp[i-cpl] = exp_min;
 439            k += 2;
 440        }
 441        break;
 442    case EXP_D45:
 443        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
 444            uint8_t exp_min = exp[k];
 445            if (exp[k+1] < exp_min)
 446                exp_min = exp[k+1];
 447            if (exp[k+2] < exp_min)
 448                exp_min = exp[k+2];
 449            if (exp[k+3] < exp_min)
 450                exp_min = exp[k+3];
 451            exp[i-cpl] = exp_min;
 452            k += 4;
 453        }
 454        break;
 455    }
 456
 457    /* constraint for DC exponent */
 458    if (!cpl && exp[0] > 15)
 459        exp[0] = 15;
 460
 461    /* decrease the delta between each groups to within 2 so that they can be
 462       differentially encoded */
 463    for (i = 1; i <= nb_groups; i++)
 464        exp[i] = FFMIN(exp[i], exp[i-1] + 2);
 465    i--;
 466    while (--i >= 0)
 467        exp[i] = FFMIN(exp[i], exp[i+1] + 2);
 468
 469    if (cpl)
 470        exp[-1] = exp[0] & ~1;
 471
 472    /* now we have the exponent values the decoder will see */
 473    switch (exp_strategy) {
 474    case EXP_D25:
 475        for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {
 476            uint8_t exp1 = exp[i-cpl];
 477            exp[k--] = exp1;
 478            exp[k--] = exp1;
 479        }
 480        break;
 481    case EXP_D45:
 482        for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {
 483            exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];
 484            k -= 4;
 485        }
 486        break;
 487    }
 488}
 489
 490
 491/*
 492 * Encode exponents from original extracted form to what the decoder will see.
 493 * This copies and groups exponents based on exponent strategy and reduces
 494 * deltas between adjacent exponent groups so that they can be differentially
 495 * encoded.
 496 */
 497static 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    for (ch = !s->cpl_on; ch <= s->channels; ch++) {
 504        exp          = s->blocks[0].exp[ch] + s->start_freq[ch];
 505        exp_strategy = s->exp_strategy[ch];
 506
 507        cpl = (ch == CPL_CH);
 508        blk = 0;
 509        while (blk < s->num_blocks) {
 510            AC3Block *block = &s->blocks[blk];
 511            if (cpl && !block->cpl_in_use) {
 512                exp += AC3_MAX_COEFS;
 513                blk++;
 514                continue;
 515            }
 516            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               and set exponent reference block numbers */
 521            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            num_reuse_blocks = blk1 - blk - 1;
 527
 528            /* for the EXP_REUSE case we select the min of the exponents */
 529            s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,
 530                                       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            blk = blk1;
 536        }
 537    }
 538
 539    /* reference block numbers have been changed, so reset ref_bap_set */
 540    s->ref_bap_set = 0;
 541}
 542
 543
 544/*
 545 * Count exponent bits based on bandwidth, coupling, and exponent strategies.
 546 */
 547static int count_exponent_bits(AC3EncodeContext *s)
 548{
 549    int blk, ch;
 550    int nb_groups, bit_count;
 551
 552    bit_count = 0;
 553    for (blk = 0; blk < s->num_blocks; blk++) {
 554        AC3Block *block = &s->blocks[blk];
 555        for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
 556            int exp_strategy = s->exp_strategy[ch][blk];
 557            int cpl          = (ch == CPL_CH);
 558            int nb_coefs     = block->end_freq[ch] - s->start_freq[ch];
 559
 560            if (exp_strategy == EXP_REUSE)
 561                continue;
 562
 563            nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs];
 564            bit_count += 4 + (nb_groups * 7);
 565        }
 566    }
 567
 568    return bit_count;
 569}
 570
 571
 572/**
 573 * Group exponents.
 574 * 3 delta-encoded exponents are in each 7-bit group. The number of groups
 575 * varies depending on exponent strategy and bandwidth.
 576 *
 577 * @param s  AC-3 encoder private context
 578 */
 579void ff_ac3_group_exponents(AC3EncodeContext *s)
 580{
 581    int blk, ch, i, cpl;
 582    int group_size, nb_groups;
 583    uint8_t *p;
 584    int delta0, delta1, delta2;
 585    int exp0, exp1;
 586
 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            int exp_strategy = s->exp_strategy[ch][blk];
 591            if (exp_strategy == EXP_REUSE)
 592                continue;
 593            cpl = (ch == CPL_CH);
 594            group_size = exp_strategy + (exp_strategy == EXP_D45);
 595            nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
 596            p = block->exp[ch] + s->start_freq[ch] - cpl;
 597
 598            /* DC exponent */
 599            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                /* merge three delta in one code */
 605                exp0   = exp1;
 606                exp1   = p[0];
 607                p     += group_size;
 608                delta0 = exp1 - exp0 + 2;
 609                av_assert2(delta0 >= 0 && delta0 <= 4);
 610
 611                exp0   = exp1;
 612                exp1   = p[0];
 613                p     += group_size;
 614                delta1 = exp1 - exp0 + 2;
 615                av_assert2(delta1 >= 0 && delta1 <= 4);
 616
 617                exp0   = exp1;
 618                exp1   = p[0];
 619                p     += group_size;
 620                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 * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
 632 * Extract exponents from MDCT coefficients, calculate exponent strategies,
 633 * and encode final exponents.
 634 *
 635 * @param s  AC-3 encoder private context
 636 */
 637void 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
 649/*
 650 * Count frame bits that are based solely on fixed parameters.
 651 * This only has to be run once when the encoder is initialized.
 652 */
 653static void count_frame_bits_fixed(AC3EncodeContext *s)
 654{
 655    static const uint8_t frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
 656    int blk;
 657    int frame_bits;
 658
 659    /* assumptions:
 660     *   no dynamic range codes
 661     *   bit allocation parameters do not change between blocks
 662     *   no delta bit allocation
 663     *   no skipped data
 664     *   no auxiliary data
 665     *   no E-AC-3 metadata
 666     */
 667
 668    /* header */
 669    frame_bits = 16; /* sync info */
 670    if (s->eac3) {
 671        /* bitstream info header */
 672        frame_bits += 35;
 673        frame_bits += 1 + 1;
 674        if (s->num_blocks != 0x6)
 675            frame_bits++;
 676        frame_bits++;
 677        /* audio frame header */
 678        if (s->num_blocks == 6)
 679            frame_bits += 2;
 680        frame_bits += 10;
 681        /* exponent strategy */
 682        if (s->use_frame_exp_strategy)
 683            frame_bits += 5 * s->fbw_channels;
 684        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        if (s->num_blks_code != 0x3)
 690            frame_bits++;
 691        else
 692            frame_bits += s->fbw_channels * 5;
 693        /* snr offsets */
 694        frame_bits += 10;
 695        /* block start info */
 696        if (s->num_blocks != 1)
 697            frame_bits++;
 698    } else {
 699        frame_bits += 49;
 700        frame_bits += frame_bits_inc[s->channel_mode];
 701    }
 702
 703    /* audio blocks */
 704    for (blk = 0; blk < s->num_blocks; blk++) {
 705        if (!s->eac3) {
 706            /* block switch flags */
 707            frame_bits += s->fbw_channels;
 708
 709            /* dither flags */
 710            frame_bits += s->fbw_channels;
 711        }
 712
 713        /* dynamic range */
 714        frame_bits++;
 715
 716        /* spectral extension */
 717        if (s->eac3)
 718            frame_bits++;
 719
 720        if (!s->eac3) {
 721            /* exponent strategy */
 722            frame_bits += 2 * s->fbw_channels;
 723            if (s->lfe_on)
 724                frame_bits++;
 725
 726            /* bit allocation params */
 727            frame_bits++;
 728            if (!blk)
 729                frame_bits += 2 + 2 + 2 + 2 + 3;
 730        }
 731
 732        /* converter snr offset */
 733        if (s->eac3)
 734            frame_bits++;
 735
 736        if (!s->eac3) {
 737            /* delta bit allocation */
 738            frame_bits++;
 739
 740            /* skipped data */
 741            frame_bits++;
 742        }
 743    }
 744
 745    /* auxiliary data */
 746    frame_bits++;
 747
 748    /* CRC */
 749    frame_bits += 1 + 16;
 750
 751    s->frame_bits_fixed = frame_bits;
 752}
 753
 754
 755/*
 756 * Initialize bit allocation.
 757 * Set default parameter codes and calculate parameter values.
 758 */
 759static av_cold void bit_alloc_init(AC3EncodeContext *s)
 760{
 761    int ch;
 762
 763    /* init default parameters */
 764    s->slow_decay_code = 2;
 765    s->fast_decay_code = 1;
 766    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        s->fast_gain_code[ch] = 4;
 771
 772    /* initial snr offset */
 773    s->coarse_snr_offset = 40;
 774
 775    /* compute real values */
 776    /* currently none of these values change during encoding, so we can just
 777       set them once at initialization */
 778    s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift;
 779    s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift;
 780    s->bit_alloc.slow_gain  = ff_ac3_slow_gain_tab[s->slow_gain_code];
 781    s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
 782    s->bit_alloc.floor      = ff_ac3_floor_tab[s->floor_code];
 783    s->bit_alloc.cpl_fast_leak = 0;
 784    s->bit_alloc.cpl_slow_leak = 0;
 785
 786    count_frame_bits_fixed(s);
 787}
 788
 789
 790/*
 791 * Count the bits used to encode the frame, minus exponents and mantissas.
 792 * Bits based on fixed parameters have already been counted, so now we just
 793 * have to add the bits based on parameters that change during encoding.
 794 */
 795static 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        if (opt->eac3_mixing_metadata) {
 804            if (s->channel_mode > AC3_CHMODE_STEREO)
 805                frame_bits += 2;
 806            if (s->has_center)
 807                frame_bits += 6;
 808            if (s->has_surround)
 809                frame_bits += 6;
 810            frame_bits += s->lfe_on;
 811            frame_bits += 1 + 1 + 2;
 812            if (s->channel_mode < AC3_CHMODE_STEREO)
 813                frame_bits++;
 814            frame_bits++;
 815        }
 816        if (opt->eac3_info_metadata) {
 817            frame_bits += 3 + 1 + 1;
 818            if (s->channel_mode == AC3_CHMODE_STEREO)
 819                frame_bits += 2 + 2;
 820            if (s->channel_mode >= AC3_CHMODE_2F2R)
 821                frame_bits += 2;
 822            frame_bits++;
 823            if (opt->audio_production_info)
 824                frame_bits += 5 + 2 + 1;
 825            frame_bits++;
 826        }
 827        /* coupling */
 828        if (s->channel_mode > AC3_CHMODE_MONO) {
 829            frame_bits++;
 830            for (blk = 1; blk < s->num_blocks; blk++) {
 831                AC3Block *block = &s->blocks[blk];
 832                frame_bits++;
 833                if (block->new_cpl_strategy)
 834                    frame_bits++;
 835            }
 836        }
 837        /* coupling exponent strategy */
 838        if (s->cpl_on) {
 839            if (s->use_frame_exp_strategy) {
 840                frame_bits += 5 * s->cpl_on;
 841            } else {
 842                for (blk = 0; blk < s->num_blocks; blk++)
 843                    frame_bits += 2 * s->blocks[blk].cpl_in_use;
 844            }
 845        }
 846    } else {
 847        if (opt->audio_production_info)
 848            frame_bits += 7;
 849        if (s->bitstream_id == 6) {
 850            if (opt->extended_bsi_1)
 851                frame_bits += 14;
 852            if (opt->extended_bsi_2)
 853                frame_bits += 14;
 854        }
 855    }
 856
 857    /* audio blocks */
 858    for (blk = 0; blk < s->num_blocks; blk++) {
 859        AC3Block *block = &s->blocks[blk];
 860
 861        /* coupling strategy */
 862        if (!s->eac3)
 863            frame_bits++;
 864        if (block->new_cpl_strategy) {
 865            if (!s->eac3)
 866                frame_bits++;
 867            if (block->cpl_in_use) {
 868                if (s->eac3)
 869                    frame_bits++;
 870                if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO)
 871                    frame_bits += s->fbw_channels;
 872                if (s->channel_mode == AC3_CHMODE_STEREO)
 873                    frame_bits++;
 874                frame_bits += 4 + 4;
 875                if (s->eac3)
 876                    frame_bits++;
 877                else
 878                    frame_bits += s->num_cpl_subbands - 1;
 879            }
 880        }
 881
 882        /* coupling coordinates */
 883        if (block->cpl_in_use) {
 884            for (ch = 1; ch <= s->fbw_channels; ch++) {
 885                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                        frame_bits += 2;
 890                        frame_bits += (4 + 4) * s->num_cpl_bands;
 891                    }
 892                }
 893            }
 894        }
 895
 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        for (ch = 1; ch <= s->fbw_channels; ch++) {
 906            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
 907                if (!block->channel_in_cpl[ch])
 908                    frame_bits += 6;
 909                frame_bits += 2;
 910            }
 911        }
 912
 913        /* coupling exponent strategy */
 914        if (!s->eac3 && block->cpl_in_use)
 915            frame_bits += 2;
 916
 917        /* snr offsets and fast gain codes */
 918        if (!s->eac3) {
 919            frame_bits++;
 920            if (block->new_snr_offsets)
 921                frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3);
 922        }
 923
 924        /* coupling leak info */
 925        if (block->cpl_in_use) {
 926            if (!s->eac3 || block->new_cpl_leak != 2)
 927                frame_bits++;
 928            if (block->new_cpl_leak)
 929                frame_bits += 3 + 3;
 930        }
 931    }
 932
 933    s->frame_bits = s->frame_bits_fixed + frame_bits;
 934}
 935
 936
 937/*
 938 * Calculate masking curve based on the final exponents.
 939 * Also calculate the power spectral densities to use in future calculations.
 940 */
 941static void bit_alloc_masking(AC3EncodeContext *s)
 942{
 943    int blk, ch;
 944
 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            /* We only need psd and mask for calculating bap.
 949               Since we currently do not calculate bap when exponent
 950               strategy is EXP_REUSE we do not need to calculate psd or mask. */
 951            if (s->exp_strategy[ch][blk] != EXP_REUSE) {
 952                ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
 953                                          block->end_freq[ch], block->psd[ch],
 954                                          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
 967/*
 968 * Ensure that bap for each block and channel point to the current bap_buffer.
 969 * They may have been switched during the bit allocation search.
 970 */
 971static void reset_block_bap(AC3EncodeContext *s)
 972{
 973    int blk, ch;
 974    uint8_t *ref_bap;
 975
 976    if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
 977        return;
 978
 979    ref_bap = s->bap_buffer;
 980    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 * Initialize mantissa counts.
 991 * These are set so that they are padded to the next whole group size when bits
 992 * are counted in compute_mantissa_size.
 993 *
 994 * @param[in,out] mant_cnt  running counts for each bap value for each block
 995 */
 996static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
 997{
 998    int blk;
 999
1000    for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1001        memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk]));
1002        mant_cnt[blk][1] = mant_cnt[blk][2] = 2;
1003        mant_cnt[blk][4] = 1;
1004    }
1005}
1006
1007
1008/**
1009 * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
1010 * range.
1011 *
1012 * @param s                 AC-3 encoder private context
1013 * @param ch                channel index
1014 * @param[in,out] mant_cnt  running counts for each bap value for each block
1015 * @param start             starting coefficient bin
1016 * @param end               ending coefficient bin
1017 */
1018static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch,
1019                                          uint16_t mant_cnt[AC3_MAX_BLOCKS][16],
1020                                          int start, int end)
1021{
1022    int blk;
1023
1024    for (blk = 0; blk < s->num_blocks; blk++) {
1025        AC3Block *block = &s->blocks[blk];
1026        if (ch == CPL_CH && !block->cpl_in_use)
1027            continue;
1028        s->ac3dsp.update_bap_counts(mant_cnt[blk],
1029                                    s->ref_bap[ch][blk] + start,
1030                                    FFMIN(end, block->end_freq[ch]) - start);
1031    }
1032}
1033
1034
1035/*
1036 * Count the number of mantissa bits in the frame based on the bap values.
1037 */
1038static int count_mantissa_bits(AC3EncodeContext *s)
1039{
1040    int ch, max_end_freq;
1041    LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
1042
1043    count_mantissa_bits_init(mant_cnt);
1044
1045    max_end_freq = s->bandwidth_code * 3 + 73;
1046    for (ch = !s->cpl_enabled; ch <= s->channels; ch++)
1047        count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch],
1048                                      max_end_freq);
1049
1050    return s->ac3dsp.compute_mantissa_size(mant_cnt);
1051}
1052
1053
1054/**
1055 * Run the bit allocation with a given SNR offset.
1056 * This calculates the bit allocation pointers that will be used to determine
1057 * the quantization of each mantissa.
1058 *
1059 * @param s           AC-3 encoder private context
1060 * @param snr_offset  SNR offset, 0 to 1023
1061 * @return the number of bits needed for mantissas if the given SNR offset is
1062 *         is used.
1063 */
1064static int bit_alloc(AC3EncodeContext *s, int snr_offset)
1065{
1066    int blk, ch;
1067
1068    snr_offset = (snr_offset - 240) * 4;
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            /* Currently the only bit allocation parameters which vary across
1076               blocks within a frame are the exponent values.  We can take
1077               advantage of that by reusing the bit allocation pointers
1078               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                                             s->start_freq[ch], block->end_freq[ch],
1082                                             snr_offset, s->bit_alloc.floor,
1083                                             ff_ac3_bap_tab, s->ref_bap[ch][blk]);
1084            }
1085        }
1086    }
1087    return count_mantissa_bits(s);
1088}
1089
1090
1091/*
1092 * Constant bitrate bit allocation search.
1093 * Find the largest SNR offset that will allow data to fit in the frame.
1094 */
1095static int cbr_bit_allocation(AC3EncodeContext *s)
1096{
1097    int ch;
1098    int bits_left;
1099    int snr_offset, snr_incr;
1100
1101    bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
1102    if (bits_left < 0)
1103        return AVERROR(EINVAL);
1104
1105    snr_offset = s->coarse_snr_offset << 4;
1106
1107    /* if previous frame SNR offset was 1023, check if current frame can also
1108       use SNR offset of 1023. if so, skip the search. */
1109    if ((snr_offset | s->fine_snr_offset[1]) == 1023) {
1110        if (bit_alloc(s, 1023) <= bits_left)
1111            return 0;
1112    }
1113
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               bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
1125            snr_offset += snr_incr;
1126            FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1127        }
1128    }
1129    FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1130    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
1136    return 0;
1137}
1138
1139
1140/*
1141 * Perform bit allocation search.
1142 * Finds the SNR offset value that maximizes quality and fits in the specified
1143 * frame size.  Output is the SNR offset and a set of bit allocation pointers
1144 * used to quantize the mantissas.
1145 */
1146int ff_ac3_compute_bit_allocation(AC3EncodeContext *s)
1147{
1148    count_frame_bits(s);
1149
1150    s->exponent_bits = count_exponent_bits(s);
1151
1152    bit_alloc_masking(s);
1153
1154    return cbr_bit_allocation(s);
1155}
1156
1157
1158/**
1159 * Symmetric quantization on 'levels' levels.
1160 *
1161 * @param c       unquantized coefficient
1162 * @param e       exponent
1163 * @param levels  number of quantization levels
1164 * @return        quantized coefficient
1165 */
1166static inline int sym_quant(int c, int e, int levels)
1167{
1168    int v = (((levels * c) >> (24 - e)) + levels) >> 1;
1169    av_assert2(v >= 0 && v < levels);
1170    return v;
1171}
1172
1173
1174/**
1175 * Asymmetric quantization on 2^qbits levels.
1176 *
1177 * @param c      unquantized coefficient
1178 * @param e      exponent
1179 * @param qbits  number of quantization bits
1180 * @return       quantized coefficient
1181 */
1182static inline int asym_quant(int c, int e, int qbits)
1183{
1184    int m;
1185
1186    c = (((c * (1<<e)) >> (24 - qbits)) + 1) >> 1;
1187    m = (1 << (qbits-1));
1188    if (c >= m)
1189        c = m - 1;
1190    av_assert2(c >= -m);
1191    return c;
1192}
1193
1194
1195/**
1196 * Quantize a set of mantissas for a single channel in a single block.
1197 *
1198 * @param s           Mantissa count context
1199 * @param fixed_coef  unquantized fixed-point coefficients
1200 * @param exp         exponents
1201 * @param bap         bit allocation pointer indices
1202 * @param[out] qmant  quantized coefficients
1203 * @param start_freq  starting coefficient bin
1204 * @param end_freq    ending coefficient bin
1205 */
1206static 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    int i;
1212
1213    for (i = start_freq; i < end_freq; i++) {
1214        int c = fixed_coef[i];
1215        int e = exp[i];
1216        int v = bap[i];
1217        if (v)
1218        switch (v) {
1219        case 1:
1220            v = sym_quant(c, e, 3);
1221            switch (s->mant1_cnt) {
1222            case 0:
1223                s->qmant1_ptr = &qmant[i];
1224                v = 9 * v;
1225                s->mant1_cnt = 1;
1226                break;
1227            case 1:
1228                *s->qmant1_ptr += 3 * v;
1229                s->mant1_cnt = 2;
1230                v = 128;
1231                break;
1232            default:
1233                *s->qmant1_ptr += v;
1234                s->mant1_cnt = 0;
1235                v = 128;
1236                break;
1237            }
1238            break;
1239        case 2:
1240            v = sym_quant(c, e, 5);
1241            switch (s->mant2_cnt) {
1242            case 0:
1243                s->qmant2_ptr = &qmant[i];
1244                v = 25 * v;
1245                s->mant2_cnt = 1;
1246                break;
1247            case 1:
1248                *s->qmant2_ptr += 5 * v;
1249                s->mant2_cnt = 2;
1250                v = 128;
1251                break;
1252            default:
1253                *s->qmant2_ptr += v;
1254                s->mant2_cnt = 0;
1255                v = 128;
1256                break;
1257            }
1258            break;
1259        case 3:
1260            v = sym_quant(c, e, 7);
1261            break;
1262        case 4:
1263            v = sym_quant(c, e, 11);
1264            switch (s->mant4_cnt) {
1265            case 0:
1266                s->qmant4_ptr = &qmant[i];
1267                v = 11 * v;
1268                s->mant4_cnt = 1;
1269                break;
1270            default:
1271                *s->qmant4_ptr += v;
1272                s->mant4_cnt = 0;
1273                v = 128;
1274                break;
1275            }
1276            break;
1277        case 5:
1278            v = sym_quant(c, e, 15);
1279            break;
1280        case 14:
1281            v = asym_quant(c, e, 14);
1282            break;
1283        case 15:
1284            v = asym_quant(c, e, 16);
1285            break;
1286        default:
1287            v = asym_quant(c, e, v - 1);
1288            break;
1289        }
1290        qmant[i] = v;
1291    }
1292}
1293
1294
1295/**
1296 * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
1297 *
1298 * @param s  AC-3 encoder private context
1299 */
1300void 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        got_cpl = !block->cpl_in_use;
1309        for (ch = 1; ch <= s->channels; ch++) {
1310            if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1311                ch0     = ch - 1;
1312                ch      = CPL_CH;
1313                got_cpl = 1;
1314            }
1315            quantize_mantissas_blk_ch(&m, block->fixed_coef[ch],
1316                                      s->blocks[s->exp_ref_block[ch][blk]].exp[ch],
1317                                      s->ref_bap[ch][blk], block->qmant[ch],
1318                                      s->start_freq[ch], block->end_freq[ch]);
1319            if (ch == CPL_CH)
1320                ch = ch0;
1321        }
1322    }
1323}
1324
1325
1326/*
1327 * Write the AC-3 frame header to the output bitstream.
1328 */
1329static void ac3_output_frame_header(AC3EncodeContext *s)
1330{
1331    AC3EncOptions *opt = &s->options;
1332
1333    put_bits(&s->pb, 16, 0x0b77);   /* frame header */
1334    put_bits(&s->pb, 16, 0);        /* crc1: will be filled later */
1335    put_bits(&s->pb, 2,  s->bit_alloc.sr_code);
1336    put_bits(&s->pb, 6,  s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
1337    put_bits(&s->pb, 5,  s->bitstream_id);
1338    put_bits(&s->pb, 3,  s->bitstream_mode);
1339    put_bits(&s->pb, 3,  s->channel_mode);
1340    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    put_bits(&s->pb, 1, 0);         /* no compression control word */
1349    put_bits(&s->pb, 1, 0);         /* no lang code */
1350    put_bits(&s->pb, 1, opt->audio_production_info);
1351    if (opt->audio_production_info) {
1352        put_bits(&s->pb, 5, opt->mixing_level - 80);
1353        put_bits(&s->pb, 2, opt->room_type);
1354    }
1355    put_bits(&s->pb, 1, opt->copyright);
1356    put_bits(&s->pb, 1, opt->original);
1357    if (s->bitstream_id == 6) {
1358        /* alternate bit stream syntax */
1359        put_bits(&s->pb, 1, opt->extended_bsi_1);
1360        if (opt->extended_bsi_1) {
1361            put_bits(&s->pb, 2, opt->preferred_stereo_downmix);
1362            put_bits(&s->pb, 3, s->ltrt_center_mix_level);
1363            put_bits(&s->pb, 3, s->ltrt_surround_mix_level);
1364            put_bits(&s->pb, 3, s->loro_center_mix_level);
1365            put_bits(&s->pb, 3, s->loro_surround_mix_level);
1366        }
1367        put_bits(&s->pb, 1, opt->extended_bsi_2);
1368        if (opt->extended_bsi_2) {
1369            put_bits(&s->pb, 2, opt->dolby_surround_ex_mode);
1370            put_bits(&s->pb, 2, opt->dolby_headphone_mode);
1371            put_bits(&s->pb, 1, opt->ad_converter_type);
1372            put_bits(&s->pb, 9, 0);     /* xbsi2 and encinfo : reserved */
1373        }
1374    } else {
1375    put_bits(&s->pb, 1, 0);         /* no time code 1 */
1376    put_bits(&s->pb, 1, 0);         /* no time code 2 */
1377    }
1378    put_bits(&s->pb, 1, 0);         /* no additional bit stream info */
1379}
1380
1381
1382/*
1383 * Write one audio block to the output bitstream.
1384 */
1385static void output_audio_block(AC3EncodeContext *s, int blk)
1386{
1387    int ch, i, baie, bnd, got_cpl, av_uninit(ch0);
1388    AC3Block *block = &s->blocks[blk];
1389
1390    /* block switching */
1391    if (!s->eac3) {
1392        for (ch = 0; ch < s->fbw_channels; ch++)
1393            put_bits(&s->pb, 1, 0);
1394    }
1395
1396    /* dither flags */
1397    if (!s->eac3) {
1398        for (ch = 0; ch < s->fbw_channels; ch++)
1399            put_bits(&s->pb, 1, 1);
1400    }
1401
1402    /* dynamic range codes */
1403    put_bits(&s->pb, 1, 0);
1404
1405    /* spectral extension */
1406    if (s->eac3)
1407        put_bits(&s->pb, 1, 0);
1408
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        if (block->cpl_in_use) {
1416            int start_sub, end_sub;
1417            if (s->eac3)
1418                put_bits(&s->pb, 1, 0); /* enhanced coupling */
1419            if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) {
1420                for (ch = 1; ch <= s->fbw_channels; ch++)
1421                    put_bits(&s->pb, 1, block->channel_in_cpl[ch]);
1422            }
1423            if (s->channel_mode == AC3_CHMODE_STEREO)
1424                put_bits(&s->pb, 1, 0); /* phase flags in use */
1425            start_sub = (s->start_freq[CPL_CH] - 37) / 12;
1426            end_sub   = (s->cpl_end_freq       - 37) / 12;
1427            put_bits(&s->pb, 4, start_sub);
1428            put_bits(&s->pb, 4, end_sub - 3);
1429            /* coupling band structure */
1430            if (s->eac3) {
1431                put_bits(&s->pb, 1, 0); /* use default */
1432            } else {
1433                for (bnd = start_sub+1; bnd < end_sub; bnd++)
1434                    put_bits(&s->pb, 1, ff_eac3_default_cpl_band_struct[bnd]);
1435            }
1436        }
1437    }
1438
1439    /* coupling coordinates */
1440    if (block->cpl_in_use) {
1441        for (ch = 1; ch <= s->fbw_channels; ch++) {
1442            if (block->channel_in_cpl[ch]) {
1443                if (!s->eac3 || block->new_cpl_coords[ch] != 2)
1444                    put_bits(&s->pb, 1, block->new_cpl_coords[ch]);
1445                if (block->new_cpl_coords[ch]) {
1446                    put_bits(&s->pb, 2, block->cpl_master_exp[ch]);
1447                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1448                        put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]);
1449                        put_bits(&s->pb, 4, block->cpl_coord_mant[ch][bnd]);
1450                    }
1451                }
1452            }
1453        }
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        if (block->new_rematrixing_strategy) {
1461            /* rematrixing flags */
1462            for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++)
1463                put_bits(&s->pb, 1, block->rematrixing_flags[bnd]);
1464        }
1465    }
1466
1467    /* exponent strategy */
1468    if (!s->eac3) {
1469        for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++)
1470            put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
1471        if (s->lfe_on)
1472            put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
1473    }
1474
1475    /* bandwidth */
1476    for (ch = 1; ch <= s->fbw_channels; ch++) {
1477        if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch])
1478            put_bits(&s->pb, 6, s->bandwidth_code);
1479    }
1480
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)
1487            continue;
1488
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]);
1496
1497        /* gain range info */
1498        if (ch != s->lfe_channel && !cpl)
1499            put_bits(&s->pb, 2, 0);
1500    }
1501
1502    /* bit allocation info */
1503    if (!s->eac3) {
1504        baie = (blk == 0);
1505        put_bits(&s->pb, 1, baie);
1506        if (baie) {
1507            put_bits(&s->pb, 2, s->slow_decay_code);
1508            put_bits(&s->pb, 2, s->fast_decay_code);
1509            put_bits(&s->pb, 2, s->slow_gain_code);
1510            put_bits(&s->pb, 2, s->db_per_bit_code);
1511            put_bits(&s->pb, 3, s->floor_code);
1512        }
1513    }
1514
1515    /* snr offset */
1516    if (!s->eac3) {
1517        put_bits(&s->pb, 1, block->new_snr_offsets);
1518        if (block->new_snr_offsets) {
1519            put_bits(&s->pb, 6, s->coarse_snr_offset);
1520            for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1521                put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
1522                put_bits(&s->pb, 3, s->fast_gain_code[ch]);
1523            }
1524        }
1525    } else {
1526        put_bits(&s->pb, 1, 0); /* no converter snr offset */
1527    }
1528
1529    /* coupling leak */
1530    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        if (block->new_cpl_leak) {
1534            put_bits(&s->pb, 3, s->bit_alloc.cpl_fast_leak);
1535            put_bits(&s->pb, 3, s->bit_alloc.cpl_slow_leak);
1536        }
1537    }
1538
1539

Large files files are truncated, but you can click here to view the full file