/* * The simplest AC-3 encoder * Copyright (c) 2000 Fabrice Bellard * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com> * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de> * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** * @file * The simplest AC-3 encoder. */ #include <stdint.h> #include "libavutil/attributes.h"#include "libavutil/avassert.h"#include "libavutil/avstring.h"#include "libavutil/channel_layout.h"#include "libavutil/crc.h"#include "libavutil/internal.h"#include "libavutil/opt.h"#include "avcodec.h"#include "internal.h"#include "me_cmp.h"#include "put_bits.h"#include "audiodsp.h"#include "ac3dsp.h"#include "ac3.h"#include "fft.h"#include "ac3enc.h"#include "eac3enc.h" typedef struct AC3Mant {    int16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4    int mant1_cnt, mant2_cnt, mant4_cnt;    ///< mantissa counts for bap=1,2,4} AC3Mant; #define CMIXLEV_NUM_OPTIONS 3static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {    LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB}; #define SURMIXLEV_NUM_OPTIONS 3static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {    LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO}; #define EXTMIXLEV_NUM_OPTIONS 8static 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};  /** * LUT for number of exponent groups. * exponent_group_tab[coupling][exponent strategy-1][number of coefficients] */static uint8_t exponent_group_tab[2][3][256];  /** * List of supported channel layouts. */const uint64_t ff_ac3_channel_layouts[19] = {     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};  /** * 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 } }};  /** * 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 } },};  /** * Adjust the frame size to make the average bit rate match the target bit rate. * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3. * * @param s  AC-3 encoder private context */void ff_ac3_adjust_frame_size(AC3EncodeContext *s){    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;    }    s->frame_size = s->frame_size_min +                    2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);    s->bits_written    += s->frame_size * 8;    s->samples_written += AC3_BLOCK_SIZE * s->num_blocks;}  /** * Set the initial coupling strategy parameters prior to coupling analysis. * * @param s  AC-3 encoder private context */void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s){    int blk, ch;    int got_cpl_snr;    int num_cpl_blocks;     /* set coupling use flags for each block/channel */    /* TODO: turn coupling on/off and adjust start band based on bit usage */    for (blk = 0; blk < s->num_blocks; blk++) {        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;    num_cpl_blocks = 0;    for (blk = 0; blk < s->num_blocks; blk++) {        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;        num_cpl_blocks += block->cpl_in_use;        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;        }    }    if (!num_cpl_blocks)        s->cpl_on = 0;     /* set bandwidth for each channel */    for (blk = 0; blk < s->num_blocks; blk++) {        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;        }    }}  /** * Apply stereo rematrixing to coefficients based on rematrixing flags. * * @param s  AC-3 encoder private context */void ff_ac3_apply_rematrixing(AC3EncodeContext *s){    int nb_coefs;    int blk, bnd, i;    int start, end;    uint8_t *flags = NULL;     if (!s->rematrixing_enabled)        return;     for (blk = 0; blk < s->num_blocks; blk++) {        AC3Block *block = &s->blocks[blk];        if (block->new_rematrixing_strategy)            flags = block->rematrixing_flags;        nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);        for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {            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++) {                    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;                }            }        }    }}  /* * Initialize exponent tables. */static av_cold void exponent_init(AC3EncodeContext *s){    int expstr, i, grpsize;     for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {        grpsize = 3 << expstr;        for (i = 12; i < 256; i++) {            exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;            exponent_group_tab[1][expstr][i] = (i              ) / grpsize;        }    }    /* LFE */    exponent_group_tab[0][0][7] = 2;     if (CONFIG_EAC3_ENCODER && s->eac3)        ff_eac3_exponent_init();}  /* * Extract exponents from the MDCT coefficients. */static void extract_exponents(AC3EncodeContext *s){    int ch        = !s->cpl_on;    int chan_size = AC3_MAX_COEFS * s->num_blocks * (s->channels - ch + 1);    AC3Block *block = &s->blocks[0];     s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);}  /** * Exponent Difference Threshold. * New exponents are sent if their SAD exceed this number. */#define EXP_DIFF_THRESHOLD 500 /** * 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 }}; /* * Calculate exponent strategies for all channels. * Array arrangement is reversed to simplify the per-channel calculation. */static void compute_exp_strategy(AC3EncodeContext *s){    int ch, blk, blk1;     for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {        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;        for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {            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]) {                exp_strategy[blk] = EXP_NEW;                continue;            }            exp_diff = s->mecc.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);            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)                exp_strategy[blk] = EXP_NEW;        }         /* now select the encoding strategy type : if exponents are often           recoded, we use a coarse encoding */        blk = 0;        while (blk < s->num_blocks) {            blk1 = blk + 1;            while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE)                blk1++;            exp_strategy[blk] = exp_strategy_reuse_tab[s->num_blks_code][blk1-blk-1];            blk = blk1;        }    }    if (s->lfe_on) {        ch = s->lfe_channel;        s->exp_strategy[ch][0] = EXP_D15;        for (blk = 1; blk < s->num_blocks; blk++)            s->exp_strategy[ch][blk] = EXP_REUSE;    }     /* for E-AC-3, determine frame exponent strategy */    if (CONFIG_EAC3_ENCODER && s->eac3)        ff_eac3_get_frame_exp_strategy(s);}  /** * Update the exponents so that they are the ones the decoder will decode. * * @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 */static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,                                    int cpl){    int nb_groups, i, k;     nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;     /* for each group, compute the minimum exponent */    switch(exp_strategy) {    case EXP_D25:        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {            uint8_t exp_min = exp[k];            if (exp[k+1] < exp_min)                exp_min = exp[k+1];            exp[i-cpl] = exp_min;            k += 2;        }        break;    case EXP_D45:        for (i = 1, k = 1-cpl; i <= nb_groups; i++) {            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];            exp[i-cpl] = exp_min;            k += 4;        }        break;    }     /* constraint for DC exponent */    if (!cpl && exp[0] > 15)        exp[0] = 15;     /* decrease the delta between each groups to within 2 so that they can be       differentially encoded */    for (i = 1; i <= nb_groups; i++)        exp[i] = FFMIN(exp[i], exp[i-1] + 2);    i--;    while (--i >= 0)        exp[i] = FFMIN(exp[i], exp[i+1] + 2);     if (cpl)        exp[-1] = exp[0] & ~1;     /* now we have the exponent values the decoder will see */    switch (exp_strategy) {    case EXP_D25:        for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {            uint8_t exp1 = exp[i-cpl];            exp[k--] = exp1;            exp[k--] = exp1;        }        break;    case EXP_D45:        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];            k -= 4;        }        break;    }}  /* * 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. */static void encode_exponents(AC3EncodeContext *s){    int blk, blk1, ch, cpl;    uint8_t *exp, *exp_strategy;

Lines 1–500 of 2495. Load more