X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fac3enc.c;h=04e8b4fb0bb265346e7d334a5cd697190a933e7b;hb=2310ee4b1cca48609d06774b7c3c70a5f38f3473;hp=107fe937f978a63f64ae8b5513dc92ab151d6375;hpb=2d82d9b1df38033c734c2f993c9f6b634fe4dc6b;p=ffmpeg diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c index 107fe937f97..04e8b4fb0bb 100644 --- a/libavcodec/ac3enc.c +++ b/libavcodec/ac3enc.c @@ -1,21 +1,23 @@ /* * The simplest AC-3 encoder * Copyright (c) 2000 Fabrice Bellard + * Copyright (c) 2006-2010 Justin Ruggles + * Copyright (c) 2006-2010 Prakash Punnoor * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav 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, + * Libav 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 + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -25,58 +27,113 @@ */ //#define DEBUG +//#define ASSERT_LEVEL 2 -#include "libavcore/audioconvert.h" +#include + +#include "libavutil/audioconvert.h" +#include "libavutil/avassert.h" #include "libavutil/crc.h" +#include "libavutil/opt.h" #include "avcodec.h" #include "put_bits.h" +#include "dsputil.h" +#include "ac3dsp.h" #include "ac3.h" #include "audioconvert.h" +#include "fft.h" + +#ifndef CONFIG_AC3ENC_FLOAT +#define CONFIG_AC3ENC_FLOAT 0 +#endif -#define MDCT_NBITS 9 -#define MDCT_SAMPLES (1 << MDCT_NBITS) /** Maximum number of exponent groups. +1 for separate DC exponent. */ #define AC3_MAX_EXP_GROUPS 85 -/** Scale a float value by 2^bits and convert to an integer. */ -#define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits))) - -/** Scale a float value by 2^15, convert to an integer, and clip to int16_t range. */ -#define FIX15(a) av_clip_int16(SCALE_FLOAT(a, 15)) - +/* stereo rematrixing algorithms */ +#define AC3_REMATRIXING_IS_STATIC 0x1 +#define AC3_REMATRIXING_SUMS 0 +#define AC3_REMATRIXING_NONE 1 +#define AC3_REMATRIXING_ALWAYS 3 + +#if CONFIG_AC3ENC_FLOAT +#define MAC_COEF(d,a,b) ((d)+=(a)*(b)) +typedef float SampleType; +typedef float CoefType; +typedef float CoefSumType; +#else +#define MAC_COEF(d,a,b) MAC64(d,a,b) +typedef int16_t SampleType; +typedef int32_t CoefType; +typedef int64_t CoefSumType; +#endif + +typedef struct AC3MDCTContext { + const SampleType *window; ///< MDCT window function + FFTContext fft; ///< FFT context for MDCT calculation +} AC3MDCTContext; /** - * Compex number. - * Used in fixed-point MDCT calculation. + * Encoding Options used by AVOption. */ -typedef struct IComplex { - int16_t re,im; -} IComplex; +typedef struct AC3EncOptions { + /* AC-3 metadata options*/ + int dialogue_level; + int bitstream_mode; + float center_mix_level; + float surround_mix_level; + int dolby_surround_mode; + int audio_production_info; + int mixing_level; + int room_type; + int copyright; + int original; + int extended_bsi_1; + int preferred_stereo_downmix; + float ltrt_center_mix_level; + float ltrt_surround_mix_level; + float loro_center_mix_level; + float loro_surround_mix_level; + int extended_bsi_2; + int dolby_surround_ex_mode; + int dolby_headphone_mode; + int ad_converter_type; + + /* other encoding options */ + int allow_per_frame_metadata; +} AC3EncOptions; /** * Data for a single audio block. */ typedef struct AC3Block { - int32_t mdct_coef[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; - uint8_t exp[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; - uint8_t exp_strategy[AC3_MAX_CHANNELS]; - uint8_t encoded_exp[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; - uint8_t num_exp_groups[AC3_MAX_CHANNELS]; - uint8_t grouped_exp[AC3_MAX_CHANNELS][AC3_MAX_EXP_GROUPS]; - int16_t psd[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; - int16_t band_psd[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]; - int16_t mask[AC3_MAX_CHANNELS][AC3_CRITICAL_BANDS]; - int8_t exp_shift[AC3_MAX_CHANNELS]; - uint16_t qmant[AC3_MAX_CHANNELS][AC3_MAX_COEFS]; + uint8_t **bap; ///< bit allocation pointers (bap) + CoefType **mdct_coef; ///< MDCT coefficients + int32_t **fixed_coef; ///< fixed-point MDCT coefficients + uint8_t **exp; ///< original exponents + uint8_t **grouped_exp; ///< grouped exponents + int16_t **psd; ///< psd per frequency bin + int16_t **band_psd; ///< psd per critical band + int16_t **mask; ///< masking curve + uint16_t **qmant; ///< quantized mantissas + uint8_t coeff_shift[AC3_MAX_CHANNELS]; ///< fixed-point coefficient shift values + uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block + uint8_t rematrixing_flags[4]; ///< rematrixing flags + struct AC3Block *exp_ref_block[AC3_MAX_CHANNELS]; ///< reference blocks for EXP_REUSE } AC3Block; /** * AC-3 encoder private context. */ typedef struct AC3EncodeContext { + AVClass *av_class; ///< AVClass used for AVOption + AC3EncOptions options; ///< encoding options PutBitContext pb; ///< bitstream writer context + DSPContext dsp; + AC3DSPContext ac3dsp; ///< AC-3 optimized functions + AC3MDCTContext mdct; ///< MDCT context AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info @@ -89,6 +146,7 @@ typedef struct AC3EncodeContext { int frame_size_min; ///< minimum frame size in case rounding is necessary int frame_size; ///< current frame size in bytes int frame_size_code; ///< frame size code (frmsizecod) + uint16_t crc_inv[2]; int bits_written; ///< bit count (used to avg. bitrate) int samples_written; ///< sample count (used to avg. bitrate) @@ -96,12 +154,25 @@ typedef struct AC3EncodeContext { int channels; ///< total number of channels (nchans) int lfe_on; ///< indicates if there is an LFE channel (lfeon) int lfe_channel; ///< channel index of the LFE channel + int has_center; ///< indicates if there is a center channel + int has_surround; ///< indicates if there are one or more surround channels int channel_mode; ///< channel mode (acmod) const uint8_t *channel_map; ///< channel map used to reorder channels + int center_mix_level; ///< center mix level code + int surround_mix_level; ///< surround mix level code + int ltrt_center_mix_level; ///< Lt/Rt center mix level code + int ltrt_surround_mix_level; ///< Lt/Rt surround mix level code + int loro_center_mix_level; ///< Lo/Ro center mix level code + int loro_surround_mix_level; ///< Lo/Ro surround mix level code + + int cutoff; ///< user-specified cutoff frequency, in Hz int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod) int nb_coefs[AC3_MAX_CHANNELS]; + int rematrixing; ///< determines how rematrixing strategy is calculated + int num_rematrixing_bands; ///< number of rematrixing bands + /* bitrate allocation control */ int slow_gain_code; ///< slow gain code (sgaincod) int slow_decay_code; ///< slow decay code (sdcycod) @@ -112,26 +183,180 @@ typedef struct AC3EncodeContext { int coarse_snr_offset; ///< coarse SNR offsets (csnroffst) int fast_gain_code[AC3_MAX_CHANNELS]; ///< fast gain codes (signal-to-mask ratio) (fgaincod) int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst) + int frame_bits_fixed; ///< number of non-coefficient bits for fixed parameters int frame_bits; ///< all frame bits except exponents and mantissas int exponent_bits; ///< number of bits used for exponents - /* mantissa encoding */ - int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4 + SampleType **planar_samples; + uint8_t *bap_buffer; + uint8_t *bap1_buffer; + CoefType *mdct_coef_buffer; + int32_t *fixed_coef_buffer; + uint8_t *exp_buffer; + uint8_t *grouped_exp_buffer; + int16_t *psd_buffer; + int16_t *band_psd_buffer; + int16_t *mask_buffer; + uint16_t *qmant_buffer; + + uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies + + DECLARE_ALIGNED(16, SampleType, windowed_samples)[AC3_WINDOW_SIZE]; +} AC3EncodeContext; + +typedef struct AC3Mant { uint16_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; - int16_t last_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE]; ///< last 256 samples from previous frame - int16_t planar_samples[AC3_MAX_CHANNELS][AC3_BLOCK_SIZE+AC3_FRAME_SIZE]; - int16_t windowed_samples[AC3_WINDOW_SIZE]; - uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS]; - uint8_t bap1[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS]; -} AC3EncodeContext; +#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 +}; + + +#define OFFSET(param) offsetof(AC3EncodeContext, options.param) +#define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) + +static const AVOption options[] = { +/* Metadata Options */ +{"per_frame_metadata", "Allow Changing Metadata Per-Frame", OFFSET(allow_per_frame_metadata), FF_OPT_TYPE_INT, 0, 0, 1, AC3ENC_PARAM}, +/* downmix levels */ +{"center_mixlev", "Center Mix Level", OFFSET(center_mix_level), FF_OPT_TYPE_FLOAT, LEVEL_MINUS_4POINT5DB, 0.0, 1.0, AC3ENC_PARAM}, +{"surround_mixlev", "Surround Mix Level", OFFSET(surround_mix_level), FF_OPT_TYPE_FLOAT, LEVEL_MINUS_6DB, 0.0, 1.0, AC3ENC_PARAM}, +/* audio production information */ +{"mixing_level", "Mixing Level", OFFSET(mixing_level), FF_OPT_TYPE_INT, -1, -1, 111, AC3ENC_PARAM}, +{"room_type", "Room Type", OFFSET(room_type), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "room_type"}, + {"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"}, + {"large", "Large Room", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"}, + {"small", "Small Room", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"}, +/* other metadata options */ +{"copyright", "Copyright Bit", OFFSET(copyright), FF_OPT_TYPE_INT, 0, 0, 1, AC3ENC_PARAM}, +{"dialnorm", "Dialogue Level (dB)", OFFSET(dialogue_level), FF_OPT_TYPE_INT, -31, -31, -1, AC3ENC_PARAM}, +{"dsur_mode", "Dolby Surround Mode", OFFSET(dolby_surround_mode), FF_OPT_TYPE_INT, 0, 0, 2, AC3ENC_PARAM, "dsur_mode"}, + {"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"}, + {"on", "Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"}, + {"off", "Not Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"}, +{"original", "Original Bit Stream", OFFSET(original), FF_OPT_TYPE_INT, 1, 0, 1, AC3ENC_PARAM}, +/* extended bitstream information */ +{"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dmix_mode"}, + {"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"}, + {"ltrt", "Lt/Rt Downmix Preferred", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"}, + {"loro", "Lo/Ro Downmix Preferred", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"}, +{"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM}, +{"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM}, +{"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM}, +{"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM}, +{"dsurex_mode", "Dolby Surround EX Mode", OFFSET(dolby_surround_ex_mode), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dsurex_mode"}, + {"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"}, + {"on", "Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"}, + {"off", "Not Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"}, +{"dheadphone_mode", "Dolby Headphone Mode", OFFSET(dolby_headphone_mode), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dheadphone_mode"}, + {"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"}, + {"on", "Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"}, + {"off", "Not Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"}, +{"ad_conv_type", "A/D Converter Type", OFFSET(ad_converter_type), FF_OPT_TYPE_INT, -1, -1, 1, AC3ENC_PARAM, "ad_conv_type"}, + {"standard", "Standard (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"}, + {"hdcd", "HDCD", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"}, +{NULL} +}; + +#if CONFIG_AC3ENC_FLOAT +static AVClass ac3enc_class = { "AC-3 Encoder", av_default_item_name, + options, LIBAVUTIL_VERSION_INT }; +#else +static AVClass ac3enc_class = { "Fixed-Point AC-3 Encoder", av_default_item_name, + options, LIBAVUTIL_VERSION_INT }; +#endif + + +/* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */ + +static av_cold void mdct_end(AC3MDCTContext *mdct); +static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, + int nbits); -/** MDCT and FFT tables */ -static int16_t costab[64]; -static int16_t sintab[64]; -static int16_t xcos1[128]; -static int16_t xsin1[128]; +static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input, + const SampleType *window, unsigned int len); + +static int normalize_samples(AC3EncodeContext *s); + +static void scale_coefficients(AC3EncodeContext *s); + + +/** + * LUT for number of exponent groups. + * exponent_group_tab[exponent strategy-1][number of coefficients] + */ +static uint8_t exponent_group_tab[3][256]; + + +/** + * List of supported channel layouts. + */ +static const int64_t ac3_channel_layouts[] = { + 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 } } +}; /** @@ -153,20 +378,20 @@ static void adjust_frame_size(AC3EncodeContext *s) /** * Deinterleave input samples. - * Channels are reordered from FFmpeg's default order to AC-3 order. + * Channels are reordered from Libav's default order to AC-3 order. */ static void deinterleave_input_samples(AC3EncodeContext *s, - const int16_t *samples) + const SampleType *samples) { int ch, i; /* deinterleave and remap input samples */ for (ch = 0; ch < s->channels; ch++) { - const int16_t *sptr; + const SampleType *sptr; int sinc; /* copy last 256 samples of previous frame to the start of the current frame */ - memcpy(&s->planar_samples[ch][0], s->last_samples[ch], + memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_FRAME_SIZE], AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0])); /* deinterleave */ @@ -176,279 +401,157 @@ static void deinterleave_input_samples(AC3EncodeContext *s, s->planar_samples[ch][i] = *sptr; sptr += sinc; } - - /* save last 256 samples for next frame */ - memcpy(s->last_samples[ch], &s->planar_samples[ch][6* AC3_BLOCK_SIZE], - AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0])); } } /** - * Initialize FFT tables. - * @param ln log2(FFT size) + * Apply the MDCT to input samples to generate frequency coefficients. + * This applies the KBD window and normalizes the input to reduce precision + * loss due to fixed-point calculations. */ -static av_cold void fft_init(int ln) +static void apply_mdct(AC3EncodeContext *s) { - int i, n, n2; - float alpha; - - n = 1 << ln; - n2 = n >> 1; - - for (i = 0; i < n2; i++) { - alpha = 2.0 * M_PI * i / n; - costab[i] = FIX15(cos(alpha)); - sintab[i] = FIX15(sin(alpha)); - } -} - + int blk, ch; -/** - * Initialize MDCT tables. - * @param nbits log2(MDCT size) - */ -static av_cold void mdct_init(int nbits) -{ - int i, n, n4; + for (ch = 0; ch < s->channels; ch++) { + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE]; - n = 1 << nbits; - n4 = n >> 2; + apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct.window, AC3_WINDOW_SIZE); - fft_init(nbits - 2); + block->coeff_shift[ch] = normalize_samples(s); - for (i = 0; i < n4; i++) { - float alpha = 2.0 * M_PI * (i + 1.0 / 8.0) / n; - xcos1[i] = FIX15(-cos(alpha)); - xsin1[i] = FIX15(-sin(alpha)); + s->mdct.fft.mdct_calcw(&s->mdct.fft, block->mdct_coef[ch], + s->windowed_samples); + } } } -/** Butterfly op */ -#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \ -{ \ - int ax, ay, bx, by; \ - bx = pre1; \ - by = pim1; \ - ax = qre1; \ - ay = qim1; \ - pre = (bx + ax) >> 1; \ - pim = (by + ay) >> 1; \ - qre = (bx - ax) >> 1; \ - qim = (by - ay) >> 1; \ -} - - -/** Complex multiply */ -#define CMUL(pre, pim, are, aim, bre, bim) \ -{ \ - pre = (MUL16(are, bre) - MUL16(aim, bim)) >> 15; \ - pim = (MUL16(are, bim) + MUL16(bre, aim)) >> 15; \ -} - - /** - * Calculate a 2^n point complex FFT on 2^ln points. - * @param z complex input/output samples - * @param ln log2(FFT size) + * Initialize stereo rematrixing. + * If the strategy does not change for each frame, set the rematrixing flags. */ -static void fft(IComplex *z, int ln) +static void rematrixing_init(AC3EncodeContext *s) { - int j, l, np, np2; - int nblocks, nloops; - register IComplex *p,*q; - int tmp_re, tmp_im; - - np = 1 << ln; - - /* reverse */ - for (j = 0; j < np; j++) { - int k = av_reverse[j] >> (8 - ln); - if (k < j) - FFSWAP(IComplex, z[k], z[j]); - } - - /* pass 0 */ - - p = &z[0]; - j = np >> 1; - do { - BF(p[0].re, p[0].im, p[1].re, p[1].im, - p[0].re, p[0].im, p[1].re, p[1].im); - p += 2; - } while (--j); - - /* pass 1 */ - - p = &z[0]; - j = np >> 2; - do { - BF(p[0].re, p[0].im, p[2].re, p[2].im, - p[0].re, p[0].im, p[2].re, p[2].im); - BF(p[1].re, p[1].im, p[3].re, p[3].im, - p[1].re, p[1].im, p[3].im, -p[3].re); - p+=4; - } while (--j); - - /* pass 2 .. ln-1 */ - - nblocks = np >> 3; - nloops = 1 << 2; - np2 = np >> 1; - do { - p = z; - q = z + nloops; - for (j = 0; j < nblocks; j++) { - BF(p->re, p->im, q->re, q->im, - p->re, p->im, q->re, q->im); - p++; - q++; - for(l = nblocks; l < np2; l += nblocks) { - CMUL(tmp_re, tmp_im, costab[l], -sintab[l], q->re, q->im); - BF(p->re, p->im, q->re, q->im, - p->re, p->im, tmp_re, tmp_im); - p++; - q++; - } - p += nloops; - q += nloops; - } - nblocks = nblocks >> 1; - nloops = nloops << 1; - } while (nblocks); + if (s->channel_mode == AC3_CHMODE_STEREO) + s->rematrixing = AC3_REMATRIXING_SUMS; + else + s->rematrixing = AC3_REMATRIXING_NONE; + /* NOTE: AC3_REMATRIXING_ALWAYS might be used in + the future in conjunction with channel coupling. */ + + if (s->rematrixing & AC3_REMATRIXING_IS_STATIC) { + int flag = (s->rematrixing == AC3_REMATRIXING_ALWAYS); + s->blocks[0].new_rematrixing_strategy = 1; + memset(s->blocks[0].rematrixing_flags, flag, + sizeof(s->blocks[0].rematrixing_flags)); + } } /** - * Calculate a 512-point MDCT - * @param out 256 output frequency coefficients - * @param in 512 windowed input audio samples + * Determine rematrixing flags for each block and band. */ -static void mdct512(int32_t *out, int16_t *in) +static void compute_rematrixing_strategy(AC3EncodeContext *s) { - int i, re, im, re1, im1; - int16_t rot[MDCT_SAMPLES]; - IComplex x[MDCT_SAMPLES/4]; + int nb_coefs; + int blk, bnd, i; + AC3Block *block, *block0; - /* shift to simplify computations */ - for (i = 0; i < MDCT_SAMPLES/4; i++) - rot[i] = -in[i + 3*MDCT_SAMPLES/4]; - for (;i < MDCT_SAMPLES; i++) - rot[i] = in[i - MDCT_SAMPLES/4]; + s->num_rematrixing_bands = 4; - /* pre rotation */ - for (i = 0; i < MDCT_SAMPLES/4; i++) { - re = ((int)rot[ 2*i] - (int)rot[MDCT_SAMPLES -1-2*i]) >> 1; - im = -((int)rot[MDCT_SAMPLES/2+2*i] - (int)rot[MDCT_SAMPLES/2-1-2*i]) >> 1; - CMUL(x[i].re, x[i].im, re, im, -xcos1[i], xsin1[i]); - } + if (s->rematrixing & AC3_REMATRIXING_IS_STATIC) + return; - fft(x, MDCT_NBITS - 2); + nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]); - /* post rotation */ - for (i = 0; i < MDCT_SAMPLES/4; i++) { - re = x[i].re; - im = x[i].im; - CMUL(re1, im1, re, im, xsin1[i], xcos1[i]); - out[ 2*i] = im1; - out[MDCT_SAMPLES/2-1-2*i] = re1; - } -} + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + block = &s->blocks[blk]; + block->new_rematrixing_strategy = !blk; + for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) { + /* calculate calculate sum of squared coeffs for one band in one block */ + int start = ff_ac3_rematrix_band_tab[bnd]; + int end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]); + CoefSumType sum[4] = {0,}; + for (i = start; i < end; i++) { + CoefType lt = block->mdct_coef[0][i]; + CoefType rt = block->mdct_coef[1][i]; + CoefType md = lt + rt; + CoefType sd = lt - rt; + MAC_COEF(sum[0], lt, lt); + MAC_COEF(sum[1], rt, rt); + MAC_COEF(sum[2], md, md); + MAC_COEF(sum[3], sd, sd); + } + /* compare sums to determine if rematrixing will be used for this band */ + if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1])) + block->rematrixing_flags[bnd] = 1; + else + block->rematrixing_flags[bnd] = 0; -/** - * Apply KBD window to input samples prior to MDCT. - */ -static void apply_window(int16_t *output, const int16_t *input, - const int16_t *window, int n) -{ - int i; - int n2 = n >> 1; - - for (i = 0; i < n2; i++) { - output[i] = MUL16(input[i], window[i]) >> 15; - output[n-i-1] = MUL16(input[n-i-1], window[i]) >> 15; + /* determine if new rematrixing flags will be sent */ + if (blk && + block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) { + block->new_rematrixing_strategy = 1; + } + } + block0 = block; } } /** - * Calculate the log2() of the maximum absolute value in an array. - * @param tab input array - * @param n number of values in the array - * @return log2(max(abs(tab[]))) + * Apply stereo rematrixing to coefficients based on rematrixing flags. */ -static int log2_tab(int16_t *tab, int n) +static void apply_rematrixing(AC3EncodeContext *s) { - int i, v; + int nb_coefs; + int blk, bnd, i; + int start, end; + uint8_t *flags; - v = 0; - for (i = 0; i < n; i++) - v |= abs(tab[i]); - - return av_log2(v); -} + if (s->rematrixing == AC3_REMATRIXING_NONE) + return; + nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]); -/** - * Left-shift each value in an array by a specified amount. - * @param tab input array - * @param n number of values in the array - * @param lshift left shift amount. a negative value means right shift. - */ -static void lshift_tab(int16_t *tab, int n, int lshift) -{ - int i; - - if (lshift > 0) { - for (i = 0; i < n; i++) - tab[i] <<= lshift; - } else if (lshift < 0) { - lshift = -lshift; - for (i = 0; i < n; i++) - tab[i] >>= lshift; + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + if (block->new_rematrixing_strategy) + flags = block->rematrixing_flags; + for (bnd = 0; bnd < s->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[0][i]; + int32_t rt = block->fixed_coef[1][i]; + block->fixed_coef[0][i] = (lt + rt) >> 1; + block->fixed_coef[1][i] = (lt - rt) >> 1; + } + } + } } } /** - * Normalize the input samples to use the maximum available precision. - * This assumes signed 16-bit input samples. Exponents are reduced by 9 to - * match the 24-bit internal precision for MDCT coefficients. - * - * @return exponent shift + * Initialize exponent tables. */ -static int normalize_samples(AC3EncodeContext *s) +static av_cold void exponent_init(AC3EncodeContext *s) { - int v = 14 - log2_tab(s->windowed_samples, AC3_WINDOW_SIZE); - v = FFMAX(0, v); - lshift_tab(s->windowed_samples, AC3_WINDOW_SIZE, v); - return v - 9; -} - - -/** - * Apply the MDCT to input samples to generate frequency coefficients. - * This applies the KBD window and normalizes the input to reduce precision - * loss due to fixed-point calculations. - */ -static void apply_mdct(AC3EncodeContext *s) -{ - int blk, ch; - - for (ch = 0; ch < s->channels; ch++) { - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - const int16_t *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE]; - - apply_window(s->windowed_samples, input_samples, ff_ac3_window, AC3_WINDOW_SIZE); - - block->exp_shift[ch] = normalize_samples(s); - - mdct512(block->mdct_coef[ch], s->windowed_samples); - } + int i; + for (i = 73; i < 256; i++) { + exponent_group_tab[0][i] = (i - 1) / 3; + exponent_group_tab[1][i] = (i + 2) / 6; + exponent_group_tab[2][i] = (i + 8) / 12; } + /* LFE */ + exponent_group_tab[0][7] = 2; } @@ -459,54 +562,30 @@ static void apply_mdct(AC3EncodeContext *s) */ static void extract_exponents(AC3EncodeContext *s) { - int blk, ch, i; + int blk, ch; for (ch = 0; ch < s->channels; ch++) { for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { AC3Block *block = &s->blocks[blk]; - for (i = 0; i < AC3_MAX_COEFS; i++) { - int e; - int v = abs(block->mdct_coef[ch][i]); - if (v == 0) - e = 24; - else { - e = 23 - av_log2(v) + block->exp_shift[ch]; - if (e >= 24) { - e = 24; - block->mdct_coef[ch][i] = 0; - } - } - block->exp[ch][i] = e; - } + s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], + AC3_MAX_COEFS); } } } -/** - * Calculate the sum of absolute differences (SAD) between 2 sets of exponents. - */ -static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n) -{ - int sum, i; - sum = 0; - for (i = 0; i < n; i++) - sum += abs(exp1[i] - exp2[i]); - return sum; -} - - /** * Exponent Difference Threshold. * New exponents are sent if their SAD exceed this number. */ -#define EXP_DIFF_THRESHOLD 1000 +#define EXP_DIFF_THRESHOLD 500 /** * Calculate exponent strategies for all blocks in a single channel. */ -static void compute_exp_strategy_ch(uint8_t *exp_strategy, uint8_t **exp) +static void compute_exp_strategy_ch(AC3EncodeContext *s, uint8_t *exp_strategy, + uint8_t *exp) { int blk, blk1; int exp_diff; @@ -514,12 +593,14 @@ static void compute_exp_strategy_ch(uint8_t *exp_strategy, uint8_t **exp) /* 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 < AC3_MAX_BLOCKS; blk++) { - exp_diff = calc_exp_diff(exp[blk], exp[blk-1], AC3_MAX_COEFS); + exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16); if (exp_diff > EXP_DIFF_THRESHOLD) exp_strategy[blk] = EXP_NEW; else exp_strategy[blk] = EXP_REUSE; + exp += AC3_MAX_COEFS; } /* now select the encoding strategy type : if exponents are often @@ -546,41 +627,16 @@ static void compute_exp_strategy_ch(uint8_t *exp_strategy, uint8_t **exp) */ static void compute_exp_strategy(AC3EncodeContext *s) { - uint8_t *exp1[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; - uint8_t exp_str1[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; int ch, blk; for (ch = 0; ch < s->fbw_channels; ch++) { - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - exp1[ch][blk] = s->blocks[blk].exp[ch]; - exp_str1[ch][blk] = s->blocks[blk].exp_strategy[ch]; - } - - compute_exp_strategy_ch(exp_str1[ch], exp1[ch]); - - for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) - s->blocks[blk].exp_strategy[ch] = exp_str1[ch][blk]; + compute_exp_strategy_ch(s, s->exp_strategy[ch], s->blocks[0].exp[ch]); } if (s->lfe_on) { ch = s->lfe_channel; - s->blocks[0].exp_strategy[ch] = EXP_D15; + s->exp_strategy[ch][0] = EXP_D15; for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) - s->blocks[blk].exp_strategy[ch] = EXP_REUSE; - } -} - - -/** - * Set each encoded exponent in a block to the minimum of itself and the - * exponent in the same frequency bin of a following block. - * exp[i] = min(exp[i], exp1[i] - */ -static void exponent_min(uint8_t *exp, uint8_t *exp1, int n) -{ - int i; - for (i = 0; i < n; i++) { - if (exp1[i] < exp[i]) - exp[i] = exp1[i]; + s->exp_strategy[ch][blk] = EXP_REUSE; } } @@ -588,49 +644,65 @@ static void exponent_min(uint8_t *exp, uint8_t *exp1, int n) /** * Update the exponents so that they are the ones the decoder will decode. */ -static void encode_exponents_blk_ch(uint8_t *encoded_exp, uint8_t *exp, - int nb_exps, int exp_strategy, - uint8_t *num_exp_groups) +static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy) { - int group_size, nb_groups, i, j, k, exp_min; - uint8_t exp1[AC3_MAX_COEFS]; + int nb_groups, i, k; - group_size = exp_strategy + (exp_strategy == EXP_D45); - *num_exp_groups = (nb_exps + (group_size * 3) - 4) / (3 * group_size); - nb_groups = *num_exp_groups * 3; + nb_groups = exponent_group_tab[exp_strategy-1][nb_exps] * 3; /* for each group, compute the minimum exponent */ - exp1[0] = exp[0]; /* DC exponent is handled separately */ - k = 1; - for (i = 1; i <= nb_groups; i++) { - exp_min = exp[k]; - assert(exp_min >= 0 && exp_min <= 24); - for (j = 1; j < group_size; j++) { - if (exp[k+j] < exp_min) - exp_min = exp[k+j]; + switch(exp_strategy) { + case EXP_D25: + for (i = 1, k = 1; i <= nb_groups; i++) { + uint8_t exp_min = exp[k]; + if (exp[k+1] < exp_min) + exp_min = exp[k+1]; + exp[i] = exp_min; + k += 2; + } + break; + case EXP_D45: + for (i = 1, k = 1; 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] = exp_min; + k += 4; } - exp1[i] = exp_min; - k += group_size; + break; } /* constraint for DC exponent */ - if (exp1[0] > 15) - exp1[0] = 15; + if (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++) - exp1[i] = FFMIN(exp1[i], exp1[i-1] + 2); - for (i = nb_groups-1; i >= 0; i--) - exp1[i] = FFMIN(exp1[i], exp1[i+1] + 2); + exp[i] = FFMIN(exp[i], exp[i-1] + 2); + i--; + while (--i >= 0) + exp[i] = FFMIN(exp[i], exp[i+1] + 2); /* now we have the exponent values the decoder will see */ - encoded_exp[0] = exp1[0]; - k = 1; - for (i = 1; i <= nb_groups; i++) { - for (j = 0; j < group_size; j++) - encoded_exp[k+j] = exp1[i]; - k += group_size; + switch (exp_strategy) { + case EXP_D25: + for (i = nb_groups, k = nb_groups * 2; i > 0; i--) { + uint8_t exp1 = exp[i]; + exp[k--] = exp1; + exp[k--] = exp1; + } + break; + case EXP_D45: + for (i = nb_groups, k = nb_groups * 4; i > 0; i--) { + exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i]; + k -= 4; + } + break; } } @@ -643,33 +715,35 @@ static void encode_exponents_blk_ch(uint8_t *encoded_exp, uint8_t *exp, */ static void encode_exponents(AC3EncodeContext *s) { - int blk, blk1, blk2, ch; - AC3Block *block, *block1, *block2; + int blk, blk1, ch; + uint8_t *exp, *exp_strategy; + int nb_coefs, num_reuse_blocks; for (ch = 0; ch < s->channels; ch++) { + exp = s->blocks[0].exp[ch]; + exp_strategy = s->exp_strategy[ch]; + nb_coefs = s->nb_coefs[ch]; + blk = 0; - block = &s->blocks[0]; while (blk < AC3_MAX_BLOCKS) { blk1 = blk + 1; - block1 = block + 1; - /* for the EXP_REUSE case we select the min of the exponents */ - while (blk1 < AC3_MAX_BLOCKS && block1->exp_strategy[ch] == EXP_REUSE) { - exponent_min(block->exp[ch], block1->exp[ch], s->nb_coefs[ch]); + + /* count the number of EXP_REUSE blocks after the current block + and set exponent reference block pointers */ + s->blocks[blk].exp_ref_block[ch] = &s->blocks[blk]; + while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE) { + s->blocks[blk1].exp_ref_block[ch] = &s->blocks[blk]; blk1++; - block1++; - } - encode_exponents_blk_ch(block->encoded_exp[ch], - block->exp[ch], s->nb_coefs[ch], - block->exp_strategy[ch], - &block->num_exp_groups[ch]); - /* copy encoded exponents for reuse case */ - block2 = block + 1; - for (blk2 = blk+1; blk2 < blk1; blk2++, block2++) { - memcpy(block2->encoded_exp[ch], block->encoded_exp[ch], - s->nb_coefs[ch] * sizeof(uint8_t)); } + num_reuse_blocks = blk1 - blk - 1; + + /* for the EXP_REUSE case we select the min of the exponents */ + s->ac3dsp.ac3_exponent_min(exp, num_reuse_blocks, nb_coefs); + + encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk]); + + exp += AC3_MAX_COEFS * (num_reuse_blocks + 1); blk = blk1; - block = block1; } } } @@ -683,7 +757,7 @@ static void encode_exponents(AC3EncodeContext *s) static void group_exponents(AC3EncodeContext *s) { int blk, ch, i; - int group_size, bit_count; + int group_size, nb_groups, bit_count; uint8_t *p; int delta0, delta1, delta2; int exp0, exp1; @@ -692,35 +766,38 @@ static void group_exponents(AC3EncodeContext *s) for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { AC3Block *block = &s->blocks[blk]; for (ch = 0; ch < s->channels; ch++) { - if (block->exp_strategy[ch] == EXP_REUSE) { - block->num_exp_groups[ch] = 0; + int exp_strategy = s->exp_strategy[ch][blk]; + if (exp_strategy == EXP_REUSE) continue; - } - group_size = block->exp_strategy[ch] + (block->exp_strategy[ch] == EXP_D45); - bit_count += 4 + (block->num_exp_groups[ch] * 7); - p = block->encoded_exp[ch]; + group_size = exp_strategy + (exp_strategy == EXP_D45); + nb_groups = exponent_group_tab[exp_strategy-1][s->nb_coefs[ch]]; + bit_count += 4 + (nb_groups * 7); + p = block->exp[ch]; /* DC exponent */ exp1 = *p++; block->grouped_exp[ch][0] = exp1; /* remaining exponents are delta encoded */ - for (i = 1; i <= block->num_exp_groups[ch]; i++) { + for (i = 1; i <= nb_groups; i++) { /* merge three delta in one code */ exp0 = exp1; exp1 = p[0]; p += group_size; delta0 = exp1 - exp0 + 2; + av_assert2(delta0 >= 0 && delta0 <= 4); exp0 = exp1; exp1 = p[0]; p += group_size; delta1 = exp1 - exp0 + 2; + av_assert2(delta1 >= 0 && delta1 <= 4); exp0 = exp1; exp1 = p[0]; p += group_size; delta2 = exp1 - exp0 + 2; + av_assert2(delta2 >= 0 && delta2 <= 4); block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2; } @@ -745,6 +822,62 @@ static void process_exponents(AC3EncodeContext *s) encode_exponents(s); group_exponents(s); + + emms_c(); +} + + +/** + * 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 + * no channel coupling + * bit allocation parameters do not change between blocks + * SNR offsets do not change between blocks + * no delta bit allocation + * no skipped data + * no auxilliary data + */ + + /* header size */ + frame_bits = 65; + frame_bits += frame_bits_inc[s->channel_mode]; + + /* audio blocks */ + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + frame_bits += s->fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ + if (s->channel_mode == AC3_CHMODE_STEREO) { + frame_bits++; /* rematstr */ + } + frame_bits += 2 * s->fbw_channels; /* chexpstr[2] * c */ + if (s->lfe_on) + frame_bits++; /* lfeexpstr */ + frame_bits++; /* baie */ + frame_bits++; /* snr */ + frame_bits += 2; /* delta / skip */ + } + frame_bits++; /* cplinu for block 0 */ + /* bit alloc info */ + /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */ + /* csnroffset[6] */ + /* (fsnoffset[4] + fgaincod[4]) * c */ + frame_bits += 2*4 + 3 + 6 + s->channels * (4 + 3); + + /* auxdatae, crcrsv */ + frame_bits += 2; + + /* CRC */ + frame_bits += 16; + + s->frame_bits_fixed = frame_bits; } @@ -760,8 +893,8 @@ static void bit_alloc_init(AC3EncodeContext *s) s->slow_decay_code = 2; s->fast_decay_code = 1; s->slow_gain_code = 1; - s->db_per_bit_code = 2; - s->floor_code = 4; + s->db_per_bit_code = 3; + s->floor_code = 7; for (ch = 0; ch < s->channels; ch++) s->fast_gain_code[ch] = 4; @@ -776,107 +909,59 @@ static void bit_alloc_init(AC3EncodeContext *s) 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]; + + count_frame_bits_fixed(s); } /** * Count the bits used to encode the frame, minus exponents and mantissas. + * 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. */ static void count_frame_bits(AC3EncodeContext *s) { - static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; + AC3EncOptions *opt = &s->options; int blk, ch; - int frame_bits; - - /* header size */ - frame_bits = 65; - frame_bits += frame_bits_inc[s->channel_mode]; + int frame_bits = 0; + + 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; + } - /* audio blocks */ for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - frame_bits += s->fbw_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */ - if (s->channel_mode == AC3_CHMODE_STEREO) { - frame_bits++; /* rematstr */ - if (!blk) - frame_bits += 4; + /* stereo rematrixing */ + if (s->channel_mode == AC3_CHMODE_STEREO && + s->blocks[blk].new_rematrixing_strategy) { + frame_bits += s->num_rematrixing_bands; } - frame_bits += 2 * s->fbw_channels; /* chexpstr[2] * c */ - if (s->lfe_on) - frame_bits++; /* lfeexpstr */ + for (ch = 0; ch < s->fbw_channels; ch++) { - if (s->blocks[blk].exp_strategy[ch] != EXP_REUSE) + if (s->exp_strategy[ch][blk] != EXP_REUSE) frame_bits += 6 + 2; /* chbwcod[6], gainrng[2] */ } - frame_bits++; /* baie */ - frame_bits++; /* snr */ - frame_bits += 2; /* delta / skip */ } - frame_bits++; /* cplinu for block 0 */ - /* bit alloc info */ - /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */ - /* csnroffset[6] */ - /* (fsnoffset[4] + fgaincod[4]) * c */ - frame_bits += 2*4 + 3 + 6 + s->channels * (4 + 3); - - /* auxdatae, crcrsv */ - frame_bits += 2; - - /* CRC */ - frame_bits += 16; - - s->frame_bits = frame_bits; + s->frame_bits = s->frame_bits_fixed + frame_bits; } /** - * Calculate the number of bits needed to encode a set of mantissas. + * Finalize the mantissa bit count by adding in the grouped mantissas. */ -static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *bap, int nb_coefs) +static int compute_mantissa_size_final(int mant_cnt[5]) { - int bits, b, i; - - bits = 0; - for (i = 0; i < nb_coefs; i++) { - b = bap[i]; - switch (b) { - case 0: - /* bap=0 mantissas are not encoded */ - break; - case 1: - /* 3 mantissas in 5 bits */ - if (s->mant1_cnt == 0) - bits += 5; - if (++s->mant1_cnt == 3) - s->mant1_cnt = 0; - break; - case 2: - /* 3 mantissas in 7 bits */ - if (s->mant2_cnt == 0) - bits += 7; - if (++s->mant2_cnt == 3) - s->mant2_cnt = 0; - break; - case 3: - bits += 3; - break; - case 4: - /* 2 mantissas in 7 bits */ - if (s->mant4_cnt == 0) - bits += 7; - if (++s->mant4_cnt == 2) - s->mant4_cnt = 0; - break; - case 14: - bits += 14; - break; - case 15: - bits += 16; - break; - default: - bits += b - 1; - break; - } - } + // bap=1 : 3 mantissas in 5 bits + int bits = (mant_cnt[1] / 3) * 5; + // bap=2 : 3 mantissas in 7 bits + // bap=4 : 2 mantissas in 7 bits + bits += ((mant_cnt[2] / 3) + (mant_cnt[4] >> 1)) * 7; + // bap=3 : each mantissa is 3 bits + bits += mant_cnt[3] * 3; return bits; } @@ -892,12 +977,11 @@ static void bit_alloc_masking(AC3EncodeContext *s) for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { AC3Block *block = &s->blocks[blk]; for (ch = 0; ch < s->channels; ch++) { - if (block->exp_strategy[ch] == EXP_REUSE) { - AC3Block *block1 = &s->blocks[blk-1]; - memcpy(block->psd[ch], block1->psd[ch], AC3_MAX_COEFS*sizeof(block->psd[0][0])); - memcpy(block->mask[ch], block1->mask[ch], AC3_CRITICAL_BANDS*sizeof(block->mask[0][0])); - } else { - ff_ac3_bit_alloc_calc_psd(block->encoded_exp[ch], 0, + /* 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. */ + if (s->exp_strategy[ch][blk] != EXP_REUSE) { + ff_ac3_bit_alloc_calc_psd(block->exp[ch], 0, s->nb_coefs[ch], block->psd[ch], block->band_psd[ch]); ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch], @@ -912,6 +996,23 @@ static void bit_alloc_masking(AC3EncodeContext *s) } +/** + * 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; + if (s->blocks[0].bap[0] == s->bap_buffer) + return; + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + for (ch = 0; ch < s->channels; ch++) { + s->blocks[blk].bap[ch] = &s->bap_buffer[AC3_MAX_COEFS * (blk * s->channels + ch)]; + } + } +} + + /** * Run the bit allocation with a given SNR offset. * This calculates the bit allocation pointers that will be used to determine @@ -919,28 +1020,39 @@ static void bit_alloc_masking(AC3EncodeContext *s) * @return the number of bits needed for mantissas if the given SNR offset is * is used. */ -static int bit_alloc(AC3EncodeContext *s, - uint8_t bap[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][AC3_MAX_COEFS], - int snr_offset) +static int bit_alloc(AC3EncodeContext *s, int snr_offset) { int blk, ch; int mantissa_bits; + int mant_cnt[5]; snr_offset = (snr_offset - 240) << 2; + reset_block_bap(s); mantissa_bits = 0; for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { - AC3Block *block = &s->blocks[blk]; - s->mant1_cnt = 0; - s->mant2_cnt = 0; - s->mant4_cnt = 0; + AC3Block *block; + // initialize grouped mantissa counts. these are set so that they are + // padded to the next whole group size when bits are counted in + // compute_mantissa_size_final + mant_cnt[0] = mant_cnt[3] = 0; + mant_cnt[1] = mant_cnt[2] = 2; + mant_cnt[4] = 1; for (ch = 0; ch < s->channels; ch++) { - ff_ac3_bit_alloc_calc_bap(block->mask[ch], block->psd[ch], 0, - s->nb_coefs[ch], snr_offset, - s->bit_alloc.floor, ff_ac3_bap_tab, - bap[blk][ch]); - mantissa_bits += compute_mantissa_size(s, bap[blk][ch], s->nb_coefs[ch]); + /* 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. */ + block = s->blocks[blk].exp_ref_block[ch]; + if (s->exp_strategy[ch][blk] != EXP_REUSE) { + s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch], 0, + s->nb_coefs[ch], snr_offset, + s->bit_alloc.floor, ff_ac3_bap_tab, + block->bap[ch]); + } + mantissa_bits += s->ac3dsp.compute_mantissa_size(mant_cnt, block->bap[ch], s->nb_coefs[ch]); } + mantissa_bits += compute_mantissa_size_final(mant_cnt); } return mantissa_bits; } @@ -954,39 +1066,37 @@ static int cbr_bit_allocation(AC3EncodeContext *s) { int ch; int bits_left; - int snr_offset; + int snr_offset, snr_incr; bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits); + av_assert2(bits_left >= 0); snr_offset = s->coarse_snr_offset << 4; + /* if previous frame SNR offset was 1023, check if current frame can also + use SNR offset of 1023. if so, skip the search. */ + if ((snr_offset | s->fine_snr_offset[0]) == 1023) { + if (bit_alloc(s, 1023) <= bits_left) + return 0; + } + while (snr_offset >= 0 && - bit_alloc(s, s->bap, snr_offset) > bits_left) { + bit_alloc(s, snr_offset) > bits_left) { snr_offset -= 64; } if (snr_offset < 0) return AVERROR(EINVAL); - while (snr_offset + 64 <= 1023 && - bit_alloc(s, s->bap1, snr_offset + 64) <= bits_left) { - snr_offset += 64; - memcpy(s->bap, s->bap1, sizeof(s->bap1)); - } - while (snr_offset + 16 <= 1023 && - bit_alloc(s, s->bap1, snr_offset + 16) <= bits_left) { - snr_offset += 16; - memcpy(s->bap, s->bap1, sizeof(s->bap1)); - } - while (snr_offset + 4 <= 1023 && - bit_alloc(s, s->bap1, snr_offset + 4) <= bits_left) { - snr_offset += 4; - memcpy(s->bap, s->bap1, sizeof(s->bap1)); - } - while (snr_offset + 1 <= 1023 && - bit_alloc(s, s->bap1, snr_offset + 1) <= bits_left) { - snr_offset++; - memcpy(s->bap, s->bap1, sizeof(s->bap1)); + FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); + for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) { + while (snr_offset + snr_incr <= 1023 && + bit_alloc(s, snr_offset + snr_incr) <= bits_left) { + snr_offset += snr_incr; + FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); + } } + FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); + reset_block_bap(s); s->coarse_snr_offset = snr_offset >> 4; for (ch = 0; ch < s->channels; ch++) @@ -996,6 +1106,68 @@ static int cbr_bit_allocation(AC3EncodeContext *s) } +/** + * Downgrade exponent strategies to reduce the bits used by the exponents. + * This is a fallback for when bit allocation fails with the normal exponent + * strategies. Each time this function is run it only downgrades the + * strategy in 1 channel of 1 block. + * @return non-zero if downgrade was unsuccessful + */ +static int downgrade_exponents(AC3EncodeContext *s) +{ + int ch, blk; + + for (ch = 0; ch < s->fbw_channels; ch++) { + for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) { + if (s->exp_strategy[ch][blk] == EXP_D15) { + s->exp_strategy[ch][blk] = EXP_D25; + return 0; + } + } + } + for (ch = 0; ch < s->fbw_channels; ch++) { + for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) { + if (s->exp_strategy[ch][blk] == EXP_D25) { + s->exp_strategy[ch][blk] = EXP_D45; + return 0; + } + } + } + for (ch = 0; ch < s->fbw_channels; ch++) { + /* block 0 cannot reuse exponents, so only downgrade D45 to REUSE if + the block number > 0 */ + for (blk = AC3_MAX_BLOCKS-1; blk > 0; blk--) { + if (s->exp_strategy[ch][blk] > EXP_REUSE) { + s->exp_strategy[ch][blk] = EXP_REUSE; + return 0; + } + } + } + return -1; +} + + +/** + * Reduce the bandwidth to reduce the number of bits used for a given SNR offset. + * This is a second fallback for when bit allocation still fails after exponents + * have been downgraded. + * @return non-zero if bandwidth reduction was unsuccessful + */ +static int reduce_bandwidth(AC3EncodeContext *s, int min_bw_code) +{ + int ch; + + if (s->bandwidth_code[0] > min_bw_code) { + for (ch = 0; ch < s->fbw_channels; ch++) { + s->bandwidth_code[ch]--; + s->nb_coefs[ch] = s->bandwidth_code[ch] * 3 + 73; + } + return 0; + } + return -1; +} + + /** * Perform bit allocation search. * Finds the SNR offset value that maximizes quality and fits in the specified @@ -1004,11 +1176,37 @@ static int cbr_bit_allocation(AC3EncodeContext *s) */ static int compute_bit_allocation(AC3EncodeContext *s) { + int ret; + count_frame_bits(s); bit_alloc_masking(s); - return cbr_bit_allocation(s); + ret = cbr_bit_allocation(s); + while (ret) { + /* fallback 1: downgrade exponents */ + if (!downgrade_exponents(s)) { + extract_exponents(s); + encode_exponents(s); + group_exponents(s); + ret = compute_bit_allocation(s); + continue; + } + + /* fallback 2: reduce bandwidth */ + /* only do this if the user has not specified a specific cutoff + frequency */ + if (!s->cutoff && !reduce_bandwidth(s, 0)) { + process_exponents(s); + ret = compute_bit_allocation(s); + continue; + } + + /* fallbacks were not enough... */ + break; + } + + return ret; } @@ -1017,18 +1215,8 @@ static int compute_bit_allocation(AC3EncodeContext *s) */ static inline int sym_quant(int c, int e, int levels) { - int v; - - if (c >= 0) { - v = (levels * (c << e)) >> 24; - v = (v + 1) >> 1; - v = (levels >> 1) + v; - } else { - v = (levels * ((-c) << e)) >> 24; - v = (v + 1) >> 1; - v = (levels >> 1) - v; - } - assert(v >= 0 && v < levels); + int v = (((levels * c) >> (24 - e)) + levels) >> 1; + av_assert2(v >= 0 && v < levels); return v; } @@ -1050,7 +1238,7 @@ static inline int asym_quant(int c, int e, int qbits) m = (1 << (qbits-1)); if (v >= m) v = m - 1; - assert(v >= -m); + av_assert2(v >= -m); return v & ((1 << qbits)-1); } @@ -1058,17 +1246,16 @@ static inline int asym_quant(int c, int e, int qbits) /** * Quantize a set of mantissas for a single channel in a single block. */ -static void quantize_mantissas_blk_ch(AC3EncodeContext *s, - int32_t *mdct_coef, int8_t exp_shift, - uint8_t *encoded_exp, uint8_t *bap, - uint16_t *qmant, int n) +static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef, + uint8_t *exp, + uint8_t *bap, uint16_t *qmant, int n) { int i; for (i = 0; i < n; i++) { int v; - int c = mdct_coef[i]; - int e = encoded_exp[i] - exp_shift; + int c = fixed_coef[i]; + int e = exp[i]; int b = bap[i]; switch (b) { case 0: @@ -1160,12 +1347,13 @@ static void quantize_mantissas(AC3EncodeContext *s) for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { AC3Block *block = &s->blocks[blk]; - s->mant1_cnt = s->mant2_cnt = s->mant4_cnt = 0; - s->qmant1_ptr = s->qmant2_ptr = s->qmant4_ptr = NULL; + AC3Block *ref_block; + AC3Mant m = { 0 }; for (ch = 0; ch < s->channels; ch++) { - quantize_mantissas_blk_ch(s, block->mdct_coef[ch], block->exp_shift[ch], - block->encoded_exp[ch], s->bap[blk][ch], + ref_block = block->exp_ref_block[ch]; + quantize_mantissas_blk_ch(&m, block->fixed_coef[ch], + ref_block->exp[ch], ref_block->bap[ch], block->qmant[ch], s->nb_coefs[ch]); } } @@ -1177,6 +1365,8 @@ static void quantize_mantissas(AC3EncodeContext *s) */ static void output_frame_header(AC3EncodeContext *s) { + AC3EncOptions *opt = &s->options; + 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); @@ -1185,20 +1375,43 @@ static void output_frame_header(AC3EncodeContext *s) 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) - put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */ + put_bits(&s->pb, 2, s->center_mix_level); if (s->channel_mode & 0x04) - put_bits(&s->pb, 2, 1); /* XXX -6 dB */ + put_bits(&s->pb, 2, s->surround_mix_level); if (s->channel_mode == AC3_CHMODE_STEREO) - put_bits(&s->pb, 2, 0); /* surround not indicated */ + put_bits(&s->pb, 2, opt->dolby_surround_mode); put_bits(&s->pb, 1, s->lfe_on); /* LFE */ - put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */ + put_bits(&s->pb, 5, -opt->dialogue_level); put_bits(&s->pb, 1, 0); /* no compression control word */ put_bits(&s->pb, 1, 0); /* no lang code */ - put_bits(&s->pb, 1, 0); /* no audio production info */ - put_bits(&s->pb, 1, 0); /* no copyright */ - put_bits(&s->pb, 1, 1); /* original bitstream */ + put_bits(&s->pb, 1, 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 { put_bits(&s->pb, 1, 0); /* no time code 1 */ put_bits(&s->pb, 1, 0); /* no time code 2 */ + } put_bits(&s->pb, 1, 0); /* no additional bit stream info */ } @@ -1206,11 +1419,10 @@ static void output_frame_header(AC3EncodeContext *s) /** * Write one audio block to the output bitstream. */ -static void output_audio_block(AC3EncodeContext *s, - int block_num) +static void output_audio_block(AC3EncodeContext *s, int blk) { int ch, i, baie, rbnd; - AC3Block *block = &s->blocks[block_num]; + AC3Block *block = &s->blocks[blk]; /* block switching */ for (ch = 0; ch < s->fbw_channels; ch++) @@ -1224,7 +1436,7 @@ static void output_audio_block(AC3EncodeContext *s, put_bits(&s->pb, 1, 0); /* channel coupling */ - if (!block_num) { + if (!blk) { put_bits(&s->pb, 1, 1); /* coupling strategy present */ put_bits(&s->pb, 1, 0); /* no coupling strategy */ } else { @@ -1233,41 +1445,39 @@ static void output_audio_block(AC3EncodeContext *s, /* stereo rematrixing */ if (s->channel_mode == AC3_CHMODE_STEREO) { - if (!block_num) { - /* first block must define rematrixing (rematstr) */ - put_bits(&s->pb, 1, 1); - - /* dummy rematrixing rematflg(1:4)=0 */ - for (rbnd = 0; rbnd < 4; rbnd++) - put_bits(&s->pb, 1, 0); - } else { - /* no matrixing (but should be used in the future) */ - put_bits(&s->pb, 1, 0); + put_bits(&s->pb, 1, block->new_rematrixing_strategy); + if (block->new_rematrixing_strategy) { + /* rematrixing flags */ + for (rbnd = 0; rbnd < s->num_rematrixing_bands; rbnd++) + put_bits(&s->pb, 1, block->rematrixing_flags[rbnd]); } } /* exponent strategy */ for (ch = 0; ch < s->fbw_channels; ch++) - put_bits(&s->pb, 2, block->exp_strategy[ch]); + put_bits(&s->pb, 2, s->exp_strategy[ch][blk]); if (s->lfe_on) - put_bits(&s->pb, 1, block->exp_strategy[s->lfe_channel]); + put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]); /* bandwidth */ for (ch = 0; ch < s->fbw_channels; ch++) { - if (block->exp_strategy[ch] != EXP_REUSE) + if (s->exp_strategy[ch][blk] != EXP_REUSE) put_bits(&s->pb, 6, s->bandwidth_code[ch]); } /* exponents */ for (ch = 0; ch < s->channels; ch++) { - if (block->exp_strategy[ch] == EXP_REUSE) + int nb_groups; + + if (s->exp_strategy[ch][blk] == EXP_REUSE) continue; /* DC exponent */ put_bits(&s->pb, 4, block->grouped_exp[ch][0]); /* exponent groups */ - for (i = 1; i <= block->num_exp_groups[ch]; i++) + nb_groups = exponent_group_tab[s->exp_strategy[ch][blk]-1][s->nb_coefs[ch]]; + for (i = 1; i <= nb_groups; i++) put_bits(&s->pb, 7, block->grouped_exp[ch][i]); /* gain range info */ @@ -1276,7 +1486,7 @@ static void output_audio_block(AC3EncodeContext *s, } /* bit allocation info */ - baie = (block_num == 0); + baie = (blk == 0); put_bits(&s->pb, 1, baie); if (baie) { put_bits(&s->pb, 2, s->slow_decay_code); @@ -1302,9 +1512,10 @@ static void output_audio_block(AC3EncodeContext *s, /* mantissas */ for (ch = 0; ch < s->channels; ch++) { int b, q; + AC3Block *ref_block = block->exp_ref_block[ch]; for (i = 0; i < s->nb_coefs[ch]; i++) { q = block->qmant[ch][i]; - b = s->bap[block_num][ch][i]; + b = ref_block->bap[ch][i]; switch (b) { case 0: break; case 1: if (q != 128) put_bits(&s->pb, 5, q); break; @@ -1360,42 +1571,46 @@ static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly) */ static void output_frame_end(AC3EncodeContext *s) { - int frame_size, frame_size_58, pad_bytes, crc1, crc2, crc_inv; + const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI); + int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv; uint8_t *frame; - frame_size = s->frame_size; - frame_size_58 = ((frame_size >> 2) + (frame_size >> 4)) << 1; + frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1; /* pad the remainder of the frame with zeros */ + av_assert2(s->frame_size * 8 - put_bits_count(&s->pb) >= 18); flush_put_bits(&s->pb); frame = s->pb.buf; pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2; - assert(pad_bytes >= 0); + av_assert2(pad_bytes >= 0); if (pad_bytes > 0) memset(put_bits_ptr(&s->pb), 0, pad_bytes); /* compute crc1 */ /* this is not so easy because it is at the beginning of the data... */ - crc1 = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, - frame + 4, frame_size_58 - 4)); - /* XXX: could precompute crc_inv */ - crc_inv = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY); + crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4)); + crc_inv = s->crc_inv[s->frame_size > s->frame_size_min]; crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); AV_WB16(frame + 2, crc1); /* compute crc2 */ - crc2 = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, - frame + frame_size_58, - frame_size - frame_size_58 - 2)); - AV_WB16(frame + frame_size - 2, crc2); + crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58, + s->frame_size - frame_size_58 - 3); + 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); + AV_WB16(frame + s->frame_size - 2, crc2); } /** * Write the frame to the output bitstream. */ -static void output_frame(AC3EncodeContext *s, - unsigned char *frame) +static void output_frame(AC3EncodeContext *s, unsigned char *frame) { int blk; @@ -1410,16 +1625,284 @@ static void output_frame(AC3EncodeContext *s, } +static void dprint_options(AVCodecContext *avctx) +{ +#ifdef DEBUG + AC3EncodeContext *s = avctx->priv_data; + AC3EncOptions *opt = &s->options; + char strbuf[32]; + + switch (s->bitstream_id) { + case 6: strncpy(strbuf, "AC-3 (alt syntax)", 32); break; + case 8: strncpy(strbuf, "AC-3 (standard)", 32); break; + case 9: strncpy(strbuf, "AC-3 (dnet half-rate)", 32); break; + case 10: strncpy(strbuf, "AC-3 (dnet quater-rate", 32); break; + default: snprintf(strbuf, 32, "ERROR"); + } + av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id); + av_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt)); + av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout); + av_dlog(avctx, "channel_layout: %s\n", strbuf); + av_dlog(avctx, "sample_rate: %d\n", s->sample_rate); + av_dlog(avctx, "bit_rate: %d\n", s->bit_rate); + if (s->cutoff) + av_dlog(avctx, "cutoff: %d\n", s->cutoff); + + av_dlog(avctx, "per_frame_metadata: %s\n", + opt->allow_per_frame_metadata?"on":"off"); + if (s->has_center) + av_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level, + s->center_mix_level); + else + av_dlog(avctx, "center_mixlev: {not written}\n"); + if (s->has_surround) + av_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level, + s->surround_mix_level); + else + av_dlog(avctx, "surround_mixlev: {not written}\n"); + if (opt->audio_production_info) { + av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level); + switch (opt->room_type) { + case 0: strncpy(strbuf, "notindicated", 32); break; + case 1: strncpy(strbuf, "large", 32); break; + case 2: strncpy(strbuf, "small", 32); break; + default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type); + } + av_dlog(avctx, "room_type: %s\n", strbuf); + } else { + av_dlog(avctx, "mixing_level: {not written}\n"); + av_dlog(avctx, "room_type: {not written}\n"); + } + av_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off"); + av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level); + if (s->channel_mode == AC3_CHMODE_STEREO) { + switch (opt->dolby_surround_mode) { + case 0: strncpy(strbuf, "notindicated", 32); break; + case 1: strncpy(strbuf, "on", 32); break; + case 2: strncpy(strbuf, "off", 32); break; + default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode); + } + av_dlog(avctx, "dsur_mode: %s\n", strbuf); + } else { + av_dlog(avctx, "dsur_mode: {not written}\n"); + } + av_dlog(avctx, "original: %s\n", opt->original?"on":"off"); + + if (s->bitstream_id == 6) { + if (opt->extended_bsi_1) { + switch (opt->preferred_stereo_downmix) { + case 0: strncpy(strbuf, "notindicated", 32); break; + case 1: strncpy(strbuf, "ltrt", 32); break; + case 2: strncpy(strbuf, "loro", 32); break; + default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix); + } + av_dlog(avctx, "dmix_mode: %s\n", strbuf); + av_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n", + opt->ltrt_center_mix_level, s->ltrt_center_mix_level); + av_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n", + opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level); + av_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n", + opt->loro_center_mix_level, s->loro_center_mix_level); + av_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n", + opt->loro_surround_mix_level, s->loro_surround_mix_level); + } else { + av_dlog(avctx, "extended bitstream info 1: {not written}\n"); + } + if (opt->extended_bsi_2) { + switch (opt->dolby_surround_ex_mode) { + case 0: strncpy(strbuf, "notindicated", 32); break; + case 1: strncpy(strbuf, "on", 32); break; + case 2: strncpy(strbuf, "off", 32); break; + default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode); + } + av_dlog(avctx, "dsurex_mode: %s\n", strbuf); + switch (opt->dolby_headphone_mode) { + case 0: strncpy(strbuf, "notindicated", 32); break; + case 1: strncpy(strbuf, "on", 32); break; + case 2: strncpy(strbuf, "off", 32); break; + default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode); + } + av_dlog(avctx, "dheadphone_mode: %s\n", strbuf); + + switch (opt->ad_converter_type) { + case 0: strncpy(strbuf, "standard", 32); break; + case 1: strncpy(strbuf, "hdcd", 32); break; + default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type); + } + av_dlog(avctx, "ad_conv_type: %s\n", strbuf); + } else { + av_dlog(avctx, "extended bitstream info 2: {not written}\n"); + } + } +#endif +} + + +#define FLT_OPTION_THRESHOLD 0.01 + +static int validate_float_option(float v, const float *v_list, int v_list_size) +{ + int i; + + for (i = 0; i < v_list_size; i++) { + if (v < (v_list[i] + FLT_OPTION_THRESHOLD) && + v > (v_list[i] - FLT_OPTION_THRESHOLD)) + break; + } + if (i == v_list_size) + return -1; + + return i; +} + + +static void validate_mix_level(void *log_ctx, const char *opt_name, + float *opt_param, const float *list, + int list_size, int default_value, int min_value, + int *ctx_param) +{ + int mixlev = validate_float_option(*opt_param, list, list_size); + if (mixlev < min_value) { + mixlev = default_value; + if (*opt_param >= 0.0) { + av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using " + "default value: %0.3f\n", opt_name, list[mixlev]); + } + } + *opt_param = list[mixlev]; + *ctx_param = mixlev; +} + + +/** + * Validate metadata options as set by AVOption system. + * These values can optionally be changed per-frame. + */ +static int validate_metadata(AVCodecContext *avctx) +{ + AC3EncodeContext *s = avctx->priv_data; + AC3EncOptions *opt = &s->options; + + /* validate mixing levels */ + 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); + } + + /* set audio production info flag */ + if (opt->mixing_level >= 0 || opt->room_type >= 0) { + if (opt->mixing_level < 0) { + 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 */ + if (opt->room_type < 0) + opt->room_type = 0; + opt->audio_production_info = 1; + } else { + opt->audio_production_info = 0; + } + + /* set extended bsi 1 flag */ + if ((s->has_center || s->has_surround) && + (opt->preferred_stereo_downmix >= 0 || + opt->ltrt_center_mix_level >= 0 || + opt->ltrt_surround_mix_level >= 0 || + opt->loro_center_mix_level >= 0 || + opt->loro_surround_mix_level >= 0)) { + /* default preferred stereo downmix */ + if (opt->preferred_stereo_downmix < 0) + opt->preferred_stereo_downmix = 0; + /* 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 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 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); + /* 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); + opt->extended_bsi_1 = 1; + } else { + opt->extended_bsi_1 = 0; + } + + /* set extended bsi 2 flag */ + if (opt->dolby_surround_ex_mode >= 0 || + opt->dolby_headphone_mode >= 0 || + opt->ad_converter_type >= 0) { + /* default dolby surround ex mode */ + if (opt->dolby_surround_ex_mode < 0) + opt->dolby_surround_ex_mode = 0; + /* default dolby headphone mode */ + if (opt->dolby_headphone_mode < 0) + opt->dolby_headphone_mode = 0; + /* default A/D converter type */ + if (opt->ad_converter_type < 0) + opt->ad_converter_type = 0; + opt->extended_bsi_2 = 1; + } else { + opt->extended_bsi_2 = 0; + } + + /* set bitstream id for alternate bitstream syntax */ + if (opt->extended_bsi_1 || opt->extended_bsi_2) { + 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; +} + + /** * Encode a single AC-3 frame. */ -static int ac3_encode_frame(AVCodecContext *avctx, - unsigned char *frame, int buf_size, void *data) +static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame, + int buf_size, void *data) { AC3EncodeContext *s = avctx->priv_data; - const int16_t *samples = data; + const SampleType *samples = data; int ret; + if (s->options.allow_per_frame_metadata) { + ret = validate_metadata(avctx); + if (ret) + return ret; + } + if (s->bit_alloc.sr_code == 1) adjust_frame_size(s); @@ -1427,6 +1910,12 @@ static int ac3_encode_frame(AVCodecContext *avctx, apply_mdct(s); + scale_coefficients(s); + + compute_rematrixing_strategy(s); + + apply_rematrixing(s); + process_exponents(s); ret = compute_bit_allocation(s); @@ -1448,6 +1937,37 @@ static int ac3_encode_frame(AVCodecContext *avctx, */ static av_cold int ac3_encode_close(AVCodecContext *avctx) { + int blk, ch; + AC3EncodeContext *s = avctx->priv_data; + + for (ch = 0; ch < s->channels; ch++) + av_freep(&s->planar_samples[ch]); + av_freep(&s->planar_samples); + av_freep(&s->bap_buffer); + av_freep(&s->bap1_buffer); + av_freep(&s->mdct_coef_buffer); + av_freep(&s->fixed_coef_buffer); + 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); + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + av_freep(&block->bap); + av_freep(&block->mdct_coef); + av_freep(&block->fixed_coef); + 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); + } + + mdct_end(&s->mdct); + av_freep(&avctx->coded_frame); return 0; } @@ -1491,6 +2011,8 @@ static av_cold int set_channel_info(AC3EncodeContext *s, int channels, default: return AVERROR(EINVAL); } + s->has_center = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO; + s->has_surround = s->channel_mode & 0x04; s->channel_map = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on]; *channel_layout = ch_layout; @@ -1529,6 +2051,7 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s) s->sample_rate = avctx->sample_rate; s->bit_alloc.sr_shift = i % 3; s->bit_alloc.sr_code = i / 3; + s->bitstream_id = 8 + s->bit_alloc.sr_shift; /* validate bit rate */ for (i = 0; i < 19; i++) { @@ -1542,6 +2065,31 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s) s->bit_rate = avctx->bit_rate; s->frame_size_code = i << 1; + /* 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; + + /* 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); + } + + ret = validate_metadata(avctx); + if (ret) + return ret; + return 0; } @@ -1551,21 +2099,18 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s) * The user can optionally supply a cutoff frequency. Otherwise an appropriate * default value will be used. */ -static av_cold void set_bandwidth(AC3EncodeContext *s, int cutoff) +static av_cold void set_bandwidth(AC3EncodeContext *s) { int ch, bw_code; - if (cutoff) { + if (s->cutoff) { /* calculate bandwidth based on user-specified cutoff frequency */ int fbw_coeffs; - cutoff = av_clip(cutoff, 1, s->sample_rate >> 1); - fbw_coeffs = cutoff * 2 * AC3_MAX_COEFS / s->sample_rate; + fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate; bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60); } else { /* use default bandwidth setting */ - /* XXX: should compute the bandwidth according to the frame - size, so that we avoid annoying high frequency artifacts */ - bw_code = 50; + bw_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2]; } /* set number of coefficients for each channel */ @@ -1578,163 +2123,154 @@ static av_cold void set_bandwidth(AC3EncodeContext *s, int cutoff) } +static av_cold int allocate_buffers(AVCodecContext *avctx) +{ + int blk, ch; + AC3EncodeContext *s = avctx->priv_data; + + FF_ALLOC_OR_GOTO(avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples), + alloc_fail); + for (ch = 0; ch < s->channels; ch++) { + FF_ALLOCZ_OR_GOTO(avctx, s->planar_samples[ch], + (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples), + alloc_fail); + } + FF_ALLOC_OR_GOTO(avctx, s->bap_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->bap_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->bap1_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->mdct_coef_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->mdct_coef_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->exp_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, AC3_MAX_BLOCKS * s->channels * + 128 * sizeof(*s->grouped_exp_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->psd_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, AC3_MAX_BLOCKS * s->channels * + 64 * sizeof(*s->band_psd_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, AC3_MAX_BLOCKS * s->channels * + 64 * sizeof(*s->mask_buffer), alloc_fail); + FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->qmant_buffer), alloc_fail); + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + FF_ALLOC_OR_GOTO(avctx, block->bap, s->channels * sizeof(*block->bap), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, s->channels * sizeof(*block->mdct_coef), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->exp, s->channels * sizeof(*block->exp), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, s->channels * sizeof(*block->grouped_exp), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->psd, s->channels * sizeof(*block->psd), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, s->channels * sizeof(*block->band_psd), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->mask, s->channels * sizeof(*block->mask), + alloc_fail); + FF_ALLOCZ_OR_GOTO(avctx, block->qmant, s->channels * sizeof(*block->qmant), + alloc_fail); + + for (ch = 0; ch < s->channels; ch++) { + /* arrangement: block, channel, coeff */ + block->bap[ch] = &s->bap_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; + block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; + block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * s->channels + ch)]; + block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; + block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * s->channels + ch)]; + block->mask[ch] = &s->mask_buffer [64 * (blk * s->channels + ch)]; + block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * s->channels + ch)]; + + /* arrangement: channel, block, coeff */ + block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)]; + } + } + + if (CONFIG_AC3ENC_FLOAT) { + FF_ALLOC_OR_GOTO(avctx, s->fixed_coef_buffer, AC3_MAX_BLOCKS * s->channels * + AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail); + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, s->channels * + sizeof(*block->fixed_coef), alloc_fail); + for (ch = 0; ch < s->channels; ch++) + block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (blk * s->channels + ch)]; + } + } else { + for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { + AC3Block *block = &s->blocks[blk]; + FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, s->channels * + sizeof(*block->fixed_coef), alloc_fail); + for (ch = 0; ch < s->channels; ch++) + block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch]; + } + } + + return 0; +alloc_fail: + return AVERROR(ENOMEM); +} + + /** * Initialize the encoder. */ static av_cold int ac3_encode_init(AVCodecContext *avctx) { AC3EncodeContext *s = avctx->priv_data; - int ret; + int ret, frame_size_58; avctx->frame_size = AC3_FRAME_SIZE; - ac3_common_init(); + ff_ac3_common_init(); ret = validate_options(avctx, s); if (ret) return ret; - s->bitstream_id = 8 + s->bit_alloc.sr_shift; - s->bitstream_mode = 0; /* complete main audio service */ + s->bitstream_mode = avctx->audio_service_type; + if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE) + s->bitstream_mode = 0x7; s->frame_size_min = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code]; s->bits_written = 0; s->samples_written = 0; s->frame_size = s->frame_size_min; - set_bandwidth(s, avctx->cutoff); - - bit_alloc_init(s); - - mdct_init(9); - - avctx->coded_frame= avcodec_alloc_frame(); - avctx->coded_frame->key_frame= 1; - - return 0; -} - - -#ifdef TEST -/*************************************************************************/ -/* TEST */ + /* 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); + } -#include "libavutil/lfg.h" + set_bandwidth(s); -#define FN (MDCT_SAMPLES/4) + rematrixing_init(s); + exponent_init(s); -static void fft_test(AVLFG *lfg) -{ - IComplex in[FN], in1[FN]; - int k, n, i; - float sum_re, sum_im, a; - - for (i = 0; i < FN; i++) { - in[i].re = av_lfg_get(lfg) % 65535 - 32767; - in[i].im = av_lfg_get(lfg) % 65535 - 32767; - in1[i] = in[i]; - } - fft(in, 7); - - /* do it by hand */ - for (k = 0; k < FN; k++) { - sum_re = 0; - sum_im = 0; - for (n = 0; n < FN; n++) { - a = -2 * M_PI * (n * k) / FN; - sum_re += in1[n].re * cos(a) - in1[n].im * sin(a); - sum_im += in1[n].re * sin(a) + in1[n].im * cos(a); - } - av_log(NULL, AV_LOG_DEBUG, "%3d: %6d,%6d %6.0f,%6.0f\n", - k, in[k].re, in[k].im, sum_re / FN, sum_im / FN); - } -} - - -static void mdct_test(AVLFG *lfg) -{ - int16_t input[MDCT_SAMPLES]; - int32_t output[AC3_MAX_COEFS]; - float input1[MDCT_SAMPLES]; - float output1[AC3_MAX_COEFS]; - float s, a, err, e, emax; - int i, k, n; - - for (i = 0; i < MDCT_SAMPLES; i++) { - input[i] = (av_lfg_get(lfg) % 65535 - 32767) * 9 / 10; - input1[i] = input[i]; - } - - mdct512(output, input); - - /* do it by hand */ - for (k = 0; k < AC3_MAX_COEFS; k++) { - s = 0; - for (n = 0; n < MDCT_SAMPLES; n++) { - a = (2*M_PI*(2*n+1+MDCT_SAMPLES/2)*(2*k+1) / (4 * MDCT_SAMPLES)); - s += input1[n] * cos(a); - } - output1[k] = -2 * s / MDCT_SAMPLES; - } + bit_alloc_init(s); - err = 0; - emax = 0; - for (i = 0; i < AC3_MAX_COEFS; i++) { - av_log(NULL, AV_LOG_DEBUG, "%3d: %7d %7.0f\n", i, output[i], output1[i]); - e = output[i] - output1[i]; - if (e > emax) - emax = e; - err += e * e; - } - av_log(NULL, AV_LOG_DEBUG, "err2=%f emax=%f\n", err / AC3_MAX_COEFS, emax); -} + ret = mdct_init(avctx, &s->mdct, 9); + if (ret) + goto init_fail; + ret = allocate_buffers(avctx); + if (ret) + goto init_fail; -int main(void) -{ - AVLFG lfg; + avctx->coded_frame= avcodec_alloc_frame(); - av_log_set_level(AV_LOG_DEBUG); - mdct_init(9); + dsputil_init(&s->dsp, avctx); + ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT); - fft_test(&lfg); - mdct_test(&lfg); + dprint_options(avctx); return 0; +init_fail: + ac3_encode_close(avctx); + return ret; } -#endif /* TEST */ - - -AVCodec ac3_encoder = { - "ac3", - AVMEDIA_TYPE_AUDIO, - CODEC_ID_AC3, - sizeof(AC3EncodeContext), - ac3_encode_init, - ac3_encode_frame, - ac3_encode_close, - NULL, - .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, - .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), - .channel_layouts = (const int64_t[]){ - 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 }, -};