X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fac3dec.c;h=ceb04b63000e4d42020c611edca0f8560bff9af7;hb=9389e63c838d03ae9b0688b7957a994b9a2bd61c;hp=0571b007dc724b50f3d2ab646bc2d88413daf7dc;hpb=3357ff338b54ed1897443c712fbb52bed5ca48a1;p=ffmpeg diff --git a/libavcodec/ac3dec.c b/libavcodec/ac3dec.c index 0571b007dc7..ceb04b63000 100644 --- a/libavcodec/ac3dec.c +++ b/libavcodec/ac3dec.c @@ -35,6 +35,7 @@ #include "avcodec.h" #include "ac3_parser.h" #include "bitstream.h" +#include "crc.h" #include "dsputil.h" #include "random.h" @@ -42,15 +43,16 @@ * Table of bin locations for rematrixing bands * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions */ -static const uint8_t rematrix_band_tbl[5] = { 13, 25, 37, 61, 253 }; +static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 }; -/* table for exponent to scale_factor mapping - * scale_factor[i] = 2 ^ -(i + 15) +/** + * table for exponent to scale_factor mapping + * scale_factors[i] = 2 ^ -i */ static float scale_factors[25]; /** table for grouping exponents */ -static uint8_t exp_ungroup_tbl[128][3]; +static uint8_t exp_ungroup_tab[128][3]; /** tables for ungrouping mantissas */ @@ -64,114 +66,134 @@ static float b5_mantissas[16]; * Quantization table: levels for symmetric. bits for asymmetric. * reference: Table 7.18 Mapping of bap to Quantizer */ -static const uint8_t qntztab[16] = { +static const uint8_t quantization_tab[16] = { 0, 3, 5, 7, 11, 15, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 }; /** dynamic range table. converts codes to scale factors. */ -static float dynrng_tbl[256]; +static float dynamic_range_tab[256]; -/* Adjustmens in dB gain */ +/** Adjustments in dB gain */ #define LEVEL_MINUS_3DB 0.7071067811865476 #define LEVEL_MINUS_4POINT5DB 0.5946035575013605 #define LEVEL_MINUS_6DB 0.5000000000000000 -#define LEVEL_PLUS_3DB 1.4142135623730951 -#define LEVEL_PLUS_6DB 2.0000000000000000 +#define LEVEL_MINUS_9DB 0.3535533905932738 #define LEVEL_ZERO 0.0000000000000000 +#define LEVEL_ONE 1.0000000000000000 + +static const float gain_levels[6] = { + LEVEL_ZERO, + LEVEL_ONE, + LEVEL_MINUS_3DB, + LEVEL_MINUS_4POINT5DB, + LEVEL_MINUS_6DB, + LEVEL_MINUS_9DB +}; + +/** + * Table for center mix levels + * reference: Section 5.4.2.4 cmixlev + */ +static const uint8_t center_levels[4] = { 2, 3, 4, 3 }; + +/** + * Table for surround mix levels + * reference: Section 5.4.2.5 surmixlev + */ +static const uint8_t surround_levels[4] = { 2, 4, 0, 4 }; -static const float clevs[4] = { LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, - LEVEL_MINUS_6DB, LEVEL_MINUS_4POINT5DB }; +/** + * Table for default stereo downmixing coefficients + * reference: Section 7.8.2 Downmixing Into Two Channels + */ +static const uint8_t ac3_default_coeffs[8][5][2] = { + { { 1, 0 }, { 0, 1 }, }, + { { 2, 2 }, }, + { { 1, 0 }, { 0, 1 }, }, + { { 1, 0 }, { 3, 3 }, { 0, 1 }, }, + { { 1, 0 }, { 0, 1 }, { 4, 4 }, }, + { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 }, }, + { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, }, + { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, }, +}; -static const float slevs[4] = { LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO, LEVEL_MINUS_6DB }; +/* override ac3.h to include coupling channel */ +#undef AC3_MAX_CHANNELS +#define AC3_MAX_CHANNELS 7 +#define CPL_CH 0 #define AC3_OUTPUT_LFEON 8 typedef struct { - int acmod; - int cmixlev; - int surmixlev; - int dsurmod; - - int blksw[AC3_MAX_CHANNELS]; - int dithflag[AC3_MAX_CHANNELS]; - int dither_all; - int cplinu; - int chincpl[AC3_MAX_CHANNELS]; - int phsflginu; - int cplcoe; - uint32_t cplbndstrc; - int rematstr; - int nrematbnd; - int rematflg[AC3_MAX_CHANNELS]; - int cplexpstr; - int lfeexpstr; - int chexpstr[5]; - int cplsnroffst; - int cplfgain; - int snroffst[5]; - int fgain[5]; - int lfesnroffst; - int lfefgain; - int cpldeltbae; - int deltbae[5]; - int cpldeltnseg; - uint8_t cpldeltoffst[8]; - uint8_t cpldeltlen[8]; - uint8_t cpldeltba[8]; - int deltnseg[5]; - uint8_t deltoffst[5][8]; - uint8_t deltlen[5][8]; - uint8_t deltba[5][8]; - - /* Derived Attributes. */ - int sampling_rate; - int bit_rate; - int frame_size; - - int nchans; //number of total channels - int nfchans; //number of full-bandwidth channels - int lfeon; //lfe channel in use - int output_mode; ///< output channel configuration - int out_channels; ///< number of output channels - - float dynrng; //dynamic range gain - float dynrng2; //dynamic range gain for 1+1 mode - float cplco[5][18]; //coupling coordinates - int ncplbnd; //number of coupling bands - int ncplsubnd; //number of coupling sub bands - int cplstrtmant; //coupling start mantissa - int cplendmant; //coupling end mantissa - int endmant[5]; //channel end mantissas + int channel_mode; ///< channel mode (acmod) + int block_switch[AC3_MAX_CHANNELS]; ///< block switch flags + int dither_flag[AC3_MAX_CHANNELS]; ///< dither flags + int dither_all; ///< true if all channels are dithered + int cpl_in_use; ///< coupling in use + int channel_in_cpl[AC3_MAX_CHANNELS]; ///< channel in coupling + int phase_flags_in_use; ///< phase flags in use + int cpl_band_struct[18]; ///< coupling band structure + int rematrixing_strategy; ///< rematrixing strategy + int num_rematrixing_bands; ///< number of rematrixing bands + int rematrixing_flags[4]; ///< rematrixing flags + int exp_strategy[AC3_MAX_CHANNELS]; ///< exponent strategies + int snr_offset[AC3_MAX_CHANNELS]; ///< signal-to-noise ratio offsets + int fast_gain[AC3_MAX_CHANNELS]; ///< fast gain values (signal-to-mask ratio) + int dba_mode[AC3_MAX_CHANNELS]; ///< delta bit allocation mode + int dba_nsegs[AC3_MAX_CHANNELS]; ///< number of delta segments + uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets + uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths + uint8_t dba_values[AC3_MAX_CHANNELS][8]; ///< delta values for each segment + + int sample_rate; ///< sample frequency, in Hz + int bit_rate; ///< stream bit rate, in bits-per-second + int frame_size; ///< current frame size, in bytes + + int channels; ///< number of total channels + int fbw_channels; ///< number of full-bandwidth channels + int lfe_on; ///< lfe channel in use + int lfe_ch; ///< index of LFE channel + int output_mode; ///< output channel configuration + int out_channels; ///< number of output channels + + float downmix_coeffs[AC3_MAX_CHANNELS][2]; ///< stereo downmix coefficients + float dynamic_range[2]; ///< dynamic range + float cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates + int num_cpl_bands; ///< number of coupling bands + int num_cpl_subbands; ///< number of coupling sub bands + int start_freq[AC3_MAX_CHANNELS]; ///< start frequency bin + int end_freq[AC3_MAX_CHANNELS]; ///< end frequency bin AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters - int8_t dcplexps[256]; //decoded coupling exponents - int8_t dexps[5][256]; //decoded fbw channel exponents - int8_t dlfeexps[256]; //decoded lfe channel exponents - uint8_t cplbap[256]; //coupling bit allocation pointers - uint8_t bap[5][256]; //fbw channel bit allocation pointers - uint8_t lfebap[256]; //lfe channel bit allocation pointers + int8_t dexps[AC3_MAX_CHANNELS][256]; ///< decoded exponents + uint8_t bap[AC3_MAX_CHANNELS][256]; ///< bit allocation pointers + int16_t psd[AC3_MAX_CHANNELS][256]; ///< scaled exponents + int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents + int16_t mask[AC3_MAX_CHANNELS][50]; ///< masking curve values - float transform_coeffs_cpl[256]; - DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); //transform coefficients + DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); ///< transform coefficients /* For IMDCT. */ - MDCTContext imdct_512; //for 512 sample imdct transform - MDCTContext imdct_256; //for 256 sample imdct transform - DSPContext dsp; //for optimization - - DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][256]); //output after imdct transform and windowing - DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][256]); //delay - added to the next block - DECLARE_ALIGNED_16(float, tmp_imdct[256]); //temporary storage for imdct transform - DECLARE_ALIGNED_16(float, tmp_output[512]); //temporary storage for output before windowing - DECLARE_ALIGNED_16(float, window[256]); //window coefficients + MDCTContext imdct_512; ///< for 512 sample IMDCT + MDCTContext imdct_256; ///< for 256 sample IMDCT + DSPContext dsp; ///< for optimization + float add_bias; ///< offset for float_to_int16 conversion + float mul_bias; ///< scaling for float_to_int16 conversion + + DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS-1][256]); ///< output after imdct transform and windowing + DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output + DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS-1][256]); ///< delay - added to the next block + DECLARE_ALIGNED_16(float, tmp_imdct[256]); ///< temporary storage for imdct transform + DECLARE_ALIGNED_16(float, tmp_output[512]); ///< temporary storage for output before windowing + DECLARE_ALIGNED_16(float, window[256]); ///< window coefficients /* Miscellaneous. */ - GetBitContext gb; - AVRandomState dith_state; //for dither generation + GetBitContext gbc; ///< bitstream reader + AVRandomState dith_state; ///< for dither generation + AVCodecContext *avctx; ///< parent context } AC3DecodeContext; -/*********** BEGIN INIT HELPER FUNCTIONS ***********/ /** * Generate a Kaiser-Bessel Derived Window. */ @@ -185,7 +207,7 @@ static void ac3_window_init(float *window) for (i = 0; i < 256; i++) { tmp = i * (256 - i) * alpha2; bessel = 1.0; - for (j = 100; j > 0; j--) /* defaul to 100 iterations */ + for (j = 100; j > 0; j--) /* default to 100 iterations */ bessel = bessel * tmp / (j * j) + 1; sum += bessel; local_window[i] = sum; @@ -196,6 +218,11 @@ static void ac3_window_init(float *window) window[i] = sqrt(local_window[i] / sum); } +/** + * Symmetrical Dequantization + * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization + * Tables 7.19 to 7.23 + */ static inline float symmetric_dequant(int code, int levels) { @@ -242,182 +269,212 @@ static void ac3_tables_init(void) reference: Section 7.7.1 Dynamic Range Control */ for(i=0; i<256; i++) { int v = (i >> 5) - ((i >> 7) << 3) - 5; - dynrng_tbl[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20); + dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20); } - //generate scale factors + /* generate scale factors for exponents and asymmetrical dequantization + reference: Section 7.3.2 Expansion of Mantissas for Asymmetric Quantization */ for (i = 0; i < 25; i++) scale_factors[i] = pow(2.0, -i); /* generate exponent tables reference: Section 7.1.3 Exponent Decoding */ for(i=0; i<128; i++) { - exp_ungroup_tbl[i][0] = i / 25; - exp_ungroup_tbl[i][1] = (i % 25) / 5; - exp_ungroup_tbl[i][2] = (i % 25) % 5; + exp_ungroup_tab[i][0] = i / 25; + exp_ungroup_tab[i][1] = (i % 25) / 5; + exp_ungroup_tab[i][2] = (i % 25) % 5; } } +/** + * AVCodec initialization + */ static int ac3_decode_init(AVCodecContext *avctx) { - AC3DecodeContext *ctx = avctx->priv_data; + AC3DecodeContext *s = avctx->priv_data; + s->avctx = avctx; ac3_common_init(); ac3_tables_init(); - ff_mdct_init(&ctx->imdct_256, 8, 1); - ff_mdct_init(&ctx->imdct_512, 9, 1); - ac3_window_init(ctx->window); - dsputil_init(&ctx->dsp, avctx); - av_init_random(0, &ctx->dith_state); + ff_mdct_init(&s->imdct_256, 8, 1); + ff_mdct_init(&s->imdct_512, 9, 1); + ac3_window_init(s->window); + dsputil_init(&s->dsp, avctx); + av_init_random(0, &s->dith_state); + + /* set bias values for float to int16 conversion */ + if(s->dsp.float_to_int16 == ff_float_to_int16_c) { + s->add_bias = 385.0f; + s->mul_bias = 1.0f; + } else { + s->add_bias = 0.0f; + s->mul_bias = 32767.0f; + } return 0; } -/*********** END INIT FUNCTIONS ***********/ /** - * Parses the 'sync info' and 'bit stream info' from the AC-3 bitstream. + * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream. * GetBitContext within AC3DecodeContext must point to * start of the synchronized ac3 bitstream. */ -static int ac3_parse_header(AC3DecodeContext *ctx) +static int ac3_parse_header(AC3DecodeContext *s) { AC3HeaderInfo hdr; - GetBitContext *gb = &ctx->gb; + GetBitContext *gbc = &s->gbc; + float center_mix_level, surround_mix_level; int err, i; - err = ff_ac3_parse_header(gb->buffer, &hdr); + err = ff_ac3_parse_header(gbc->buffer, &hdr); if(err) return err; /* get decoding parameters from header info */ - ctx->bit_alloc_params.fscod = hdr.fscod; - ctx->acmod = hdr.acmod; - ctx->cmixlev = hdr.cmixlev; - ctx->surmixlev = hdr.surmixlev; - ctx->dsurmod = hdr.dsurmod; - ctx->lfeon = hdr.lfeon; - ctx->bit_alloc_params.halfratecod = hdr.halfratecod; - ctx->sampling_rate = hdr.sample_rate; - ctx->bit_rate = hdr.bit_rate; - ctx->nchans = hdr.channels; - ctx->nfchans = ctx->nchans - ctx->lfeon; - ctx->frame_size = hdr.frame_size; + s->bit_alloc_params.sr_code = hdr.sr_code; + s->channel_mode = hdr.channel_mode; + center_mix_level = gain_levels[center_levels[hdr.center_mix_level]]; + surround_mix_level = gain_levels[surround_levels[hdr.surround_mix_level]]; + s->lfe_on = hdr.lfe_on; + s->bit_alloc_params.sr_shift = hdr.sr_shift; + s->sample_rate = hdr.sample_rate; + s->bit_rate = hdr.bit_rate; + s->channels = hdr.channels; + s->fbw_channels = s->channels - s->lfe_on; + s->lfe_ch = s->fbw_channels + 1; + s->frame_size = hdr.frame_size; /* set default output to all source channels */ - ctx->out_channels = ctx->nchans; - ctx->output_mode = ctx->acmod; - if(ctx->lfeon) - ctx->output_mode |= AC3_OUTPUT_LFEON; + s->out_channels = s->channels; + s->output_mode = s->channel_mode; + if(s->lfe_on) + s->output_mode |= AC3_OUTPUT_LFEON; /* skip over portion of header which has already been read */ - skip_bits(gb, 16); //skip the sync_word, sync_info->sync_word = get_bits(gb, 16); - skip_bits(gb, 16); // skip crc1 - skip_bits(gb, 8); // skip fscod and frmsizecod - skip_bits(gb, 11); // skip bsid, bsmod, and acmod - if(ctx->acmod == AC3_ACMOD_STEREO) { - skip_bits(gb, 2); // skip dsurmod + skip_bits(gbc, 16); // skip the sync_word + skip_bits(gbc, 16); // skip crc1 + skip_bits(gbc, 8); // skip fscod and frmsizecod + skip_bits(gbc, 11); // skip bsid, bsmod, and acmod + if(s->channel_mode == AC3_CHMODE_STEREO) { + skip_bits(gbc, 2); // skip dsurmod } else { - if((ctx->acmod & 1) && ctx->acmod != AC3_ACMOD_MONO) - skip_bits(gb, 2); // skip cmixlev - if(ctx->acmod & 4) - skip_bits(gb, 2); // skip surmixlev + if((s->channel_mode & 1) && s->channel_mode != AC3_CHMODE_MONO) + skip_bits(gbc, 2); // skip cmixlev + if(s->channel_mode & 4) + skip_bits(gbc, 2); // skip surmixlev } - skip_bits1(gb); // skip lfeon + skip_bits1(gbc); // skip lfeon /* read the rest of the bsi. read twice for dual mono mode. */ - i = !(ctx->acmod); + i = !(s->channel_mode); do { - skip_bits(gb, 5); //skip dialog normalization - if (get_bits1(gb)) - skip_bits(gb, 8); //skip compression - if (get_bits1(gb)) - skip_bits(gb, 8); //skip language code - if (get_bits1(gb)) - skip_bits(gb, 7); //skip audio production information + skip_bits(gbc, 5); // skip dialog normalization + if (get_bits1(gbc)) + skip_bits(gbc, 8); //skip compression + if (get_bits1(gbc)) + skip_bits(gbc, 8); //skip language code + if (get_bits1(gbc)) + skip_bits(gbc, 7); //skip audio production information } while (i--); - skip_bits(gb, 2); //skip copyright bit and original bitstream bit + skip_bits(gbc, 2); //skip copyright bit and original bitstream bit - /* FIXME: read & use the xbsi1 downmix levels */ - if (get_bits1(gb)) - skip_bits(gb, 14); //skip timecode1 - if (get_bits1(gb)) - skip_bits(gb, 14); //skip timecode2 + /* skip the timecodes (or extra bitstream information for Alternate Syntax) + TODO: read & use the xbsi1 downmix levels */ + if (get_bits1(gbc)) + skip_bits(gbc, 14); //skip timecode1 / xbsi1 + if (get_bits1(gbc)) + skip_bits(gbc, 14); //skip timecode2 / xbsi2 - if (get_bits1(gb)) { - i = get_bits(gb, 6); //additional bsi length + /* skip additional bitstream info */ + if (get_bits1(gbc)) { + i = get_bits(gbc, 6); do { - skip_bits(gb, 8); + skip_bits(gbc, 8); } while(i--); } + /* set stereo downmixing coefficients + reference: Section 7.8.2 Downmixing Into Two Channels */ + for(i=0; ifbw_channels; i++) { + s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]]; + s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]]; + } + if(s->channel_mode > 1 && s->channel_mode & 1) { + s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = center_mix_level; + } + if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) { + int nf = s->channel_mode - 2; + s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = surround_mix_level * LEVEL_MINUS_3DB; + } + if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) { + int nf = s->channel_mode - 4; + s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = surround_mix_level; + } + return 0; } /** - * Decodes the grouped exponents. - * This function decodes the coded exponents according to exponent strategy - * and stores them in the decoded exponents buffer. - * - * @param[in] gb GetBitContext which points to start of coded exponents - * @param[in] expstr Exponent coding strategy - * @param[in] ngrps Number of grouped exponents - * @param[in] absexp Absolute exponent or DC exponent - * @param[out] dexps Decoded exponents are stored in dexps + * Decode the grouped exponents according to exponent strategy. + * reference: Section 7.1.3 Exponent Decoding */ -static void decode_exponents(GetBitContext *gb, int expstr, int ngrps, +static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, uint8_t absexp, int8_t *dexps) { - int i, j, grp, grpsize; + int i, j, grp, group_size; int dexp[256]; int expacc, prevexp; /* unpack groups */ - grpsize = expstr + (expstr == EXP_D45); + group_size = exp_strategy + (exp_strategy == EXP_D45); for(grp=0,i=0; grpcplstrtmant; - for(bnd=0; bndncplbnd; bnd++) { + i = s->start_freq[CPL_CH]; + for(bnd=0; bndnum_cpl_bands; bnd++) { do { subbnd++; for(j=0; j<12; j++) { - for(ch=1; ch<=ctx->nfchans; ch++) { - if(ctx->chincpl[ch-1]) - ctx->transform_coeffs[ch][i] = ctx->transform_coeffs_cpl[i] * ctx->cplco[ch-1][bnd] * 8.0f; + for(ch=1; ch<=s->fbw_channels; ch++) { + if(s->channel_in_cpl[ch]) + s->transform_coeffs[ch][i] = s->transform_coeffs[CPL_CH][i] * s->cpl_coords[ch][bnd] * 8.0f; } i++; } - } while((ctx->cplbndstrc >> subbnd) & 1); + } while(s->cpl_band_struct[subbnd]); } } -typedef struct { /* grouped mantissas for 3-level 5-leve and 11-level quantization */ +/** + * Grouped mantissas for 3-level 5-level and 11-level quantization + */ +typedef struct { float b1_mant[3]; float b2_mant[3]; float b4_mant[2]; @@ -426,46 +483,34 @@ typedef struct { /* grouped mantissas for 3-level 5-leve and 11-level quantizati int b4ptr; } mant_groups; -/* Get the transform coefficients for particular channel */ -static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_groups *m) +/** + * Get the transform coefficients for a particular channel + * reference: Section 7.3 Quantization and Decoding of Mantissas + */ +static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) { - GetBitContext *gb = &ctx->gb; + GetBitContext *gbc = &s->gbc; int i, gcode, tbap, start, end; uint8_t *exps; uint8_t *bap; float *coeffs; - if (ch_index >= 0) { /* fbw channels */ - exps = ctx->dexps[ch_index]; - bap = ctx->bap[ch_index]; - coeffs = ctx->transform_coeffs[ch_index + 1]; - start = 0; - end = ctx->endmant[ch_index]; - } else if (ch_index == -1) { - exps = ctx->dlfeexps; - bap = ctx->lfebap; - coeffs = ctx->transform_coeffs[0]; - start = 0; - end = 7; - } else { - exps = ctx->dcplexps; - bap = ctx->cplbap; - coeffs = ctx->transform_coeffs_cpl; - start = ctx->cplstrtmant; - end = ctx->cplendmant; - } - + exps = s->dexps[ch_index]; + bap = s->bap[ch_index]; + coeffs = s->transform_coeffs[ch_index]; + start = s->start_freq[ch_index]; + end = s->end_freq[ch_index]; for (i = start; i < end; i++) { tbap = bap[i]; switch (tbap) { case 0: - coeffs[i] = ((av_random(&ctx->dith_state) & 0xFFFF) * LEVEL_MINUS_3DB) / 32768.0f; + coeffs[i] = ((av_random(&s->dith_state) & 0xFFFF) / 65535.0f) - 0.5f; break; case 1: if(m->b1ptr > 2) { - gcode = get_bits(gb, 5); + gcode = get_bits(gbc, 5); m->b1_mant[0] = b1_mantissas[gcode][0]; m->b1_mant[1] = b1_mantissas[gcode][1]; m->b1_mant[2] = b1_mantissas[gcode][2]; @@ -476,7 +521,7 @@ static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_gro case 2: if(m->b2ptr > 2) { - gcode = get_bits(gb, 7); + gcode = get_bits(gbc, 7); m->b2_mant[0] = b2_mantissas[gcode][0]; m->b2_mant[1] = b2_mantissas[gcode][1]; m->b2_mant[2] = b2_mantissas[gcode][2]; @@ -486,12 +531,12 @@ static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_gro break; case 3: - coeffs[i] = b3_mantissas[get_bits(gb, 3)]; + coeffs[i] = b3_mantissas[get_bits(gbc, 3)]; break; case 4: if(m->b4ptr > 1) { - gcode = get_bits(gb, 7); + gcode = get_bits(gbc, 7); m->b4_mant[0] = b4_mantissas[gcode][0]; m->b4_mant[1] = b4_mantissas[gcode][1]; m->b4ptr = 0; @@ -500,11 +545,12 @@ static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_gro break; case 5: - coeffs[i] = b5_mantissas[get_bits(gb, 4)]; + coeffs[i] = b5_mantissas[get_bits(gbc, 4)]; break; default: - coeffs[i] = get_sbits(gb, qntztab[tbap]) * scale_factors[qntztab[tbap]-1]; + /* asymmetric dequantization */ + coeffs[i] = get_sbits(gbc, quantization_tab[tbap]) * scale_factors[quantization_tab[tbap]-1]; break; } coeffs[i] *= scale_factors[exps[i]]; @@ -514,31 +560,31 @@ static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_gro } /** - * Removes random dithering from coefficients with zero-bit mantissas + * Remove random dithering from coefficients with zero-bit mantissas * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0) */ -static void remove_dithering(AC3DecodeContext *ctx) { +static void remove_dithering(AC3DecodeContext *s) { int ch, i; int end=0; float *coeffs; uint8_t *bap; - for(ch=1; ch<=ctx->nfchans; ch++) { - if(!ctx->dithflag[ch-1]) { - coeffs = ctx->transform_coeffs[ch]; - bap = ctx->bap[ch-1]; - if(ctx->chincpl[ch-1]) - end = ctx->cplstrtmant; + for(ch=1; ch<=s->fbw_channels; ch++) { + if(!s->dither_flag[ch]) { + coeffs = s->transform_coeffs[ch]; + bap = s->bap[ch]; + if(s->channel_in_cpl[ch]) + end = s->start_freq[CPL_CH]; else - end = ctx->endmant[ch-1]; + end = s->end_freq[ch]; for(i=0; ichincpl[ch-1]) { - bap = ctx->cplbap; - for(; icplendmant; i++) { - if(bap[i] == 0) + if(s->channel_in_cpl[ch]) { + bap = s->bap[CPL_CH]; + for(; iend_freq[CPL_CH]; i++) { + if(!bap[i]) coeffs[i] = 0.0f; } } @@ -546,97 +592,91 @@ static void remove_dithering(AC3DecodeContext *ctx) { } } -/* Get the transform coefficients. - * This function extracts the tranform coefficients form the ac3 bitstream. - * This function is called after bit allocation is performed. +/** + * Get the transform coefficients. */ -static int get_transform_coeffs(AC3DecodeContext * ctx) +static int get_transform_coeffs(AC3DecodeContext *s) { - int i, end; + int ch, end; int got_cplchan = 0; mant_groups m; m.b1ptr = m.b2ptr = m.b4ptr = 3; - for (i = 0; i < ctx->nfchans; i++) { - /* transform coefficients for individual channel */ - if (get_transform_coeffs_ch(ctx, i, &m)) + for (ch = 1; ch <= s->channels; ch++) { + /* transform coefficients for full-bandwidth channel */ + if (get_transform_coeffs_ch(s, ch, &m)) return -1; - /* tranform coefficients for coupling channels */ - if (ctx->chincpl[i]) { + /* tranform coefficients for coupling channel come right after the + coefficients for the first coupled channel*/ + if (s->channel_in_cpl[ch]) { if (!got_cplchan) { - if (get_transform_coeffs_ch(ctx, -2, &m)) { - av_log(NULL, AV_LOG_ERROR, "error in decoupling channels\n"); + if (get_transform_coeffs_ch(s, CPL_CH, &m)) { + av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n"); return -1; } - uncouple_channels(ctx); + uncouple_channels(s); got_cplchan = 1; } - end = ctx->cplendmant; - } else - end = ctx->endmant[i]; + end = s->end_freq[CPL_CH]; + } else { + end = s->end_freq[ch]; + } do - ctx->transform_coeffs[i + 1][end] = 0; + s->transform_coeffs[ch][end] = 0; while(++end < 256); } - if (ctx->lfeon) { - if (get_transform_coeffs_ch(ctx, -1, &m)) - return -1; - for (i = 7; i < 256; i++) { - ctx->transform_coeffs[0][i] = 0; - } - } /* if any channel doesn't use dithering, zero appropriate coefficients */ - if(!ctx->dither_all) - remove_dithering(ctx); + if(!s->dither_all) + remove_dithering(s); return 0; } /** - * Performs stereo rematrixing. + * Stereo rematrixing. * reference: Section 7.5.4 Rematrixing : Decoding Technique */ -static void do_rematrixing(AC3DecodeContext *ctx) +static void do_rematrixing(AC3DecodeContext *s) { int bnd, i; int end, bndend; float tmp0, tmp1; - end = FFMIN(ctx->endmant[0], ctx->endmant[1]); + end = FFMIN(s->end_freq[1], s->end_freq[2]); - for(bnd=0; bndnrematbnd; bnd++) { - if(ctx->rematflg[bnd]) { - bndend = FFMIN(end, rematrix_band_tbl[bnd+1]); - for(i=rematrix_band_tbl[bnd]; itransform_coeffs[1][i]; - tmp1 = ctx->transform_coeffs[2][i]; - ctx->transform_coeffs[1][i] = tmp0 + tmp1; - ctx->transform_coeffs[2][i] = tmp0 - tmp1; + for(bnd=0; bndnum_rematrixing_bands; bnd++) { + if(s->rematrixing_flags[bnd]) { + bndend = FFMIN(end, rematrix_band_tab[bnd+1]); + for(i=rematrix_band_tab[bnd]; itransform_coeffs[1][i]; + tmp1 = s->transform_coeffs[2][i]; + s->transform_coeffs[1][i] = tmp0 + tmp1; + s->transform_coeffs[2][i] = tmp0 - tmp1; } } } } -/* This function performs the imdct on 256 sample transform - * coefficients. +/** + * Perform the 256-point IMDCT */ -static void do_imdct_256(AC3DecodeContext *ctx, int chindex) +static void do_imdct_256(AC3DecodeContext *s, int chindex) { int i, k; DECLARE_ALIGNED_16(float, x[128]); FFTComplex z[2][64]; - float *o_ptr = ctx->tmp_output; + float *o_ptr = s->tmp_output; for(i=0; i<2; i++) { /* de-interleave coefficients */ for(k=0; k<128; k++) { - x[k] = ctx->transform_coeffs[chindex][2*k+i]; + x[k] = s->transform_coeffs[chindex][2*k+i]; } /* run standard IMDCT */ - ctx->imdct_256.fft.imdct_calc(&ctx->imdct_256, o_ptr, x, ctx->tmp_imdct); + s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct); /* reverse the post-rotation & reordering from standard IMDCT */ for(k=0; k<32; k++) { @@ -660,410 +700,458 @@ static void do_imdct_256(AC3DecodeContext *ctx, int chindex) } } -/* IMDCT Transform. */ -static inline void do_imdct(AC3DecodeContext *ctx) +/** + * Inverse MDCT Transform. + * Convert frequency domain coefficients to time-domain audio samples. + * reference: Section 7.9.4 Transformation Equations + */ +static inline void do_imdct(AC3DecodeContext *s) { int ch; + int channels; - if (ctx->output_mode & AC3_OUTPUT_LFEON) { - ctx->imdct_512.fft.imdct_calc(&ctx->imdct_512, ctx->tmp_output, - ctx->transform_coeffs[0], ctx->tmp_imdct); - ctx->dsp.vector_fmul_add_add(ctx->output[0], ctx->tmp_output, - ctx->window, ctx->delay[0], 384, 256, 1); - ctx->dsp.vector_fmul_reverse(ctx->delay[0], ctx->tmp_output+256, - ctx->window, 256); - } - for (ch=1; ch<=ctx->nfchans; ch++) { - if (ctx->blksw[ch-1]) - do_imdct_256(ctx, ch); - else - ctx->imdct_512.fft.imdct_calc(&ctx->imdct_512, ctx->tmp_output, - ctx->transform_coeffs[ch], - ctx->tmp_imdct); - - ctx->dsp.vector_fmul_add_add(ctx->output[ch], ctx->tmp_output, - ctx->window, ctx->delay[ch], 384, 256, 1); - ctx->dsp.vector_fmul_reverse(ctx->delay[ch], ctx->tmp_output+256, - ctx->window, 256); + /* Don't perform the IMDCT on the LFE channel unless it's used in the output */ + channels = s->fbw_channels; + if(s->output_mode & AC3_OUTPUT_LFEON) + channels++; + + for (ch=1; ch<=channels; ch++) { + if (s->block_switch[ch]) { + do_imdct_256(s, ch); + } else { + s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output, + s->transform_coeffs[ch], s->tmp_imdct); + } + /* For the first half of the block, apply the window, add the delay + from the previous block, and send to output */ + s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output, + s->window, s->delay[ch-1], 0, 256, 1); + /* For the second half of the block, apply the window and store the + samples to delay, to be combined with the next block */ + s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256, + s->window, 256); } } -/* Parse the audio block from ac3 bitstream. - * This function extract the audio block from the ac3 bitstream - * and produces the output for the block. This function must - * be called for each of the six audio block in the ac3 bitstream. +/** + * Downmix the output to mono or stereo. */ -static int ac3_parse_audio_block(AC3DecodeContext *ctx, int blk) +static void ac3_downmix(AC3DecodeContext *s) { - int nfchans = ctx->nfchans; - int acmod = ctx->acmod; - int i, bnd, seg, grpsize, ch; - GetBitContext *gb = &ctx->gb; - int bit_alloc_flags = 0; - int8_t *dexps; - int mstrcplco, cplcoexp, cplcomant; - int chbwcod, ngrps, cplabsexp, skipl; - - for (i = 0; i < nfchans; i++) /*block switch flag */ - ctx->blksw[i] = get_bits1(gb); - - ctx->dither_all = 1; - for (i = 0; i < nfchans; i++) { /* dithering flag */ - ctx->dithflag[i] = get_bits1(gb); - if(!ctx->dithflag[i]) - ctx->dither_all = 0; + int i, j; + float v0, v1, s0, s1; + + for(i=0; i<256; i++) { + v0 = v1 = s0 = s1 = 0.0f; + for(j=0; jfbw_channels; j++) { + v0 += s->output[j][i] * s->downmix_coeffs[j][0]; + v1 += s->output[j][i] * s->downmix_coeffs[j][1]; + s0 += s->downmix_coeffs[j][0]; + s1 += s->downmix_coeffs[j][1]; + } + v0 /= s0; + v1 /= s1; + if(s->output_mode == AC3_CHMODE_MONO) { + s->output[0][i] = (v0 + v1) * LEVEL_MINUS_3DB; + } else if(s->output_mode == AC3_CHMODE_STEREO) { + s->output[0][i] = v0; + s->output[1][i] = v1; + } } +} - if (get_bits1(gb)) { /* dynamic range */ - ctx->dynrng = dynrng_tbl[get_bits(gb, 8)]; - } else if(blk == 0) { - ctx->dynrng = 1.0; +/** + * Parse an audio block from AC-3 bitstream. + */ +static int ac3_parse_audio_block(AC3DecodeContext *s, int blk) +{ + int fbw_channels = s->fbw_channels; + int channel_mode = s->channel_mode; + int i, bnd, seg, ch; + GetBitContext *gbc = &s->gbc; + uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; + + memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS); + + /* block switch flags */ + for (ch = 1; ch <= fbw_channels; ch++) + s->block_switch[ch] = get_bits1(gbc); + + /* dithering flags */ + s->dither_all = 1; + for (ch = 1; ch <= fbw_channels; ch++) { + s->dither_flag[ch] = get_bits1(gbc); + if(!s->dither_flag[ch]) + s->dither_all = 0; } - if(acmod == AC3_ACMOD_DUALMONO) { /* dynamic range 1+1 mode */ - if(get_bits1(gb)) { - ctx->dynrng2 = dynrng_tbl[get_bits(gb, 8)]; + /* dynamic range */ + i = !(s->channel_mode); + do { + if(get_bits1(gbc)) { + s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) * + s->avctx->drc_scale)+1.0; } else if(blk == 0) { - ctx->dynrng2 = 1.0; + s->dynamic_range[i] = 1.0f; } - } - - if (get_bits1(gb)) { /* coupling strategy */ - ctx->cplinu = get_bits1(gb); - ctx->cplbndstrc = 0; - if (ctx->cplinu) { /* coupling in use */ - int cplbegf, cplendf; - - for (i = 0; i < nfchans; i++) - ctx->chincpl[i] = get_bits1(gb); - - if (acmod == AC3_ACMOD_STEREO) - ctx->phsflginu = get_bits1(gb); //phase flag in use - - cplbegf = get_bits(gb, 4); - cplendf = get_bits(gb, 4); - - if (3 + cplendf - cplbegf < 0) { - av_log(NULL, AV_LOG_ERROR, "cplendf = %d < cplbegf = %d\n", cplendf, cplbegf); + } while(i--); + + /* coupling strategy */ + if (get_bits1(gbc)) { + memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); + s->cpl_in_use = get_bits1(gbc); + if (s->cpl_in_use) { + /* coupling in use */ + int cpl_begin_freq, cpl_end_freq; + + /* determine which channels are coupled */ + for (ch = 1; ch <= fbw_channels; ch++) + s->channel_in_cpl[ch] = get_bits1(gbc); + + /* phase flags in use */ + if (channel_mode == AC3_CHMODE_STEREO) + s->phase_flags_in_use = get_bits1(gbc); + + /* coupling frequency range and band structure */ + cpl_begin_freq = get_bits(gbc, 4); + cpl_end_freq = get_bits(gbc, 4); + if (3 + cpl_end_freq - cpl_begin_freq < 0) { + av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq); return -1; } - - ctx->ncplbnd = ctx->ncplsubnd = 3 + cplendf - cplbegf; - ctx->cplstrtmant = cplbegf * 12 + 37; - ctx->cplendmant = cplendf * 12 + 73; - for (i = 0; i < ctx->ncplsubnd - 1; i++) /* coupling band structure */ - if (get_bits1(gb)) { - ctx->cplbndstrc |= 1 << i; - ctx->ncplbnd--; + s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq; + s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37; + s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73; + for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) { + if (get_bits1(gbc)) { + s->cpl_band_struct[bnd] = 1; + s->num_cpl_bands--; } + } } else { - for (i = 0; i < nfchans; i++) - ctx->chincpl[i] = 0; + /* coupling not in use */ + for (ch = 1; ch <= fbw_channels; ch++) + s->channel_in_cpl[ch] = 0; } } - if (ctx->cplinu) { - ctx->cplcoe = 0; - - for (i = 0; i < nfchans; i++) - if (ctx->chincpl[i]) - if (get_bits1(gb)) { /* coupling co-ordinates */ - ctx->cplcoe |= 1 << i; - mstrcplco = 3 * get_bits(gb, 2); - for (bnd = 0; bnd < ctx->ncplbnd; bnd++) { - cplcoexp = get_bits(gb, 4); - cplcomant = get_bits(gb, 4); - if (cplcoexp == 15) - ctx->cplco[i][bnd] = cplcomant / 16.0f; + /* coupling coordinates */ + if (s->cpl_in_use) { + int cpl_coords_exist = 0; + + for (ch = 1; ch <= fbw_channels; ch++) { + if (s->channel_in_cpl[ch]) { + if (get_bits1(gbc)) { + int master_cpl_coord, cpl_coord_exp, cpl_coord_mant; + cpl_coords_exist = 1; + master_cpl_coord = 3 * get_bits(gbc, 2); + for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { + cpl_coord_exp = get_bits(gbc, 4); + cpl_coord_mant = get_bits(gbc, 4); + if (cpl_coord_exp == 15) + s->cpl_coords[ch][bnd] = cpl_coord_mant / 16.0f; else - ctx->cplco[i][bnd] = (cplcomant + 16.0f) / 32.0f; - ctx->cplco[i][bnd] *= scale_factors[cplcoexp + mstrcplco]; + s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f; + s->cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord]; } } - - if (acmod == AC3_ACMOD_STEREO && ctx->phsflginu && (ctx->cplcoe & 1 || ctx->cplcoe & 2)) - for (bnd = 0; bnd < ctx->ncplbnd; bnd++) - if (get_bits1(gb)) - ctx->cplco[1][bnd] = -ctx->cplco[1][bnd]; + } + } + /* phase flags */ + if (channel_mode == AC3_CHMODE_STEREO && s->phase_flags_in_use && cpl_coords_exist) { + for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { + if (get_bits1(gbc)) + s->cpl_coords[2][bnd] = -s->cpl_coords[2][bnd]; + } + } } - if (acmod == AC3_ACMOD_STEREO) {/* rematrixing */ - ctx->rematstr = get_bits1(gb); - if (ctx->rematstr) { - ctx->nrematbnd = 4; - if(ctx->cplinu && ctx->cplstrtmant <= 61) - ctx->nrematbnd -= 1 + (ctx->cplstrtmant == 37); - for(bnd=0; bndnrematbnd; bnd++) - ctx->rematflg[bnd] = get_bits1(gb); + /* stereo rematrixing strategy and band structure */ + if (channel_mode == AC3_CHMODE_STEREO) { + s->rematrixing_strategy = get_bits1(gbc); + if (s->rematrixing_strategy) { + s->num_rematrixing_bands = 4; + if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61) + s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37); + for(bnd=0; bndnum_rematrixing_bands; bnd++) + s->rematrixing_flags[bnd] = get_bits1(gbc); } } - ctx->cplexpstr = EXP_REUSE; - ctx->lfeexpstr = EXP_REUSE; - if (ctx->cplinu) /* coupling exponent strategy */ - ctx->cplexpstr = get_bits(gb, 2); - for (i = 0; i < nfchans; i++) /* channel exponent strategy */ - ctx->chexpstr[i] = get_bits(gb, 2); - if (ctx->lfeon) /* lfe exponent strategy */ - ctx->lfeexpstr = get_bits1(gb); - - for (i = 0; i < nfchans; i++) /* channel bandwidth code */ - if (ctx->chexpstr[i] != EXP_REUSE) { - if (ctx->chincpl[i]) - ctx->endmant[i] = ctx->cplstrtmant; + /* exponent strategies for each channel */ + s->exp_strategy[CPL_CH] = EXP_REUSE; + s->exp_strategy[s->lfe_ch] = EXP_REUSE; + for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { + if(ch == s->lfe_ch) + s->exp_strategy[ch] = get_bits(gbc, 1); + else + s->exp_strategy[ch] = get_bits(gbc, 2); + if(s->exp_strategy[ch] != EXP_REUSE) + bit_alloc_stages[ch] = 3; + } + + /* channel bandwidth */ + for (ch = 1; ch <= fbw_channels; ch++) { + s->start_freq[ch] = 0; + if (s->exp_strategy[ch] != EXP_REUSE) { + int prev = s->end_freq[ch]; + if (s->channel_in_cpl[ch]) + s->end_freq[ch] = s->start_freq[CPL_CH]; else { - chbwcod = get_bits(gb, 6); - if (chbwcod > 60) { - av_log(NULL, AV_LOG_ERROR, "chbwcod = %d > 60", chbwcod); + int bandwidth_code = get_bits(gbc, 6); + if (bandwidth_code > 60) { + av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code); return -1; } - ctx->endmant[i] = chbwcod * 3 + 73; + s->end_freq[ch] = bandwidth_code * 3 + 73; } + if(blk > 0 && s->end_freq[ch] != prev) + memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); } - - if (ctx->cplexpstr != EXP_REUSE) {/* coupling exponents */ - bit_alloc_flags = 64; - cplabsexp = get_bits(gb, 4) << 1; - ngrps = (ctx->cplendmant - ctx->cplstrtmant) / (3 << (ctx->cplexpstr - 1)); - decode_exponents(gb, ctx->cplexpstr, ngrps, cplabsexp, ctx->dcplexps + ctx->cplstrtmant); } - - for (i = 0; i < nfchans; i++) /* fbw channel exponents */ - if (ctx->chexpstr[i] != EXP_REUSE) { - bit_alloc_flags |= 1 << i; - grpsize = 3 << (ctx->chexpstr[i] - 1); - ngrps = (ctx->endmant[i] + grpsize - 4) / grpsize; - dexps = ctx->dexps[i]; - dexps[0] = get_bits(gb, 4); - decode_exponents(gb, ctx->chexpstr[i], ngrps, dexps[0], dexps + 1); - skip_bits(gb, 2); /* skip gainrng */ + s->start_freq[s->lfe_ch] = 0; + s->end_freq[s->lfe_ch] = 7; + + /* decode exponents for each channel */ + for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { + if (s->exp_strategy[ch] != EXP_REUSE) { + int group_size, num_groups; + group_size = 3 << (s->exp_strategy[ch] - 1); + if(ch == CPL_CH) + num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size; + else if(ch == s->lfe_ch) + num_groups = 2; + else + num_groups = (s->end_freq[ch] + group_size - 4) / group_size; + s->dexps[ch][0] = get_bits(gbc, 4) << !ch; + decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0], + &s->dexps[ch][s->start_freq[ch]+!!ch]); + if(ch != CPL_CH && ch != s->lfe_ch) + skip_bits(gbc, 2); /* skip gainrng */ } - - if (ctx->lfeexpstr != EXP_REUSE) { /* lfe exponents */ - bit_alloc_flags |= 32; - ctx->dlfeexps[0] = get_bits(gb, 4); - decode_exponents(gb, ctx->lfeexpstr, 2, ctx->dlfeexps[0], ctx->dlfeexps + 1); } - if (get_bits1(gb)) { /* bit allocation information */ - bit_alloc_flags = 127; - ctx->bit_alloc_params.sdecay = ff_sdecaytab[get_bits(gb, 2)]; - ctx->bit_alloc_params.fdecay = ff_fdecaytab[get_bits(gb, 2)]; - ctx->bit_alloc_params.sgain = ff_sgaintab[get_bits(gb, 2)]; - ctx->bit_alloc_params.dbknee = ff_dbkneetab[get_bits(gb, 2)]; - ctx->bit_alloc_params.floor = ff_floortab[get_bits(gb, 3)]; + /* bit allocation information */ + if (get_bits1(gbc)) { + s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; + s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; + s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)]; + s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)]; + s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)]; + for(ch=!s->cpl_in_use; ch<=s->channels; ch++) { + bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); + } } - if (get_bits1(gb)) { /* snroffset */ + /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */ + if (get_bits1(gbc)) { int csnr; - bit_alloc_flags = 127; - csnr = (get_bits(gb, 6) - 15) << 4; - if (ctx->cplinu) { /* coupling fine snr offset and fast gain code */ - ctx->cplsnroffst = (csnr + get_bits(gb, 4)) << 2; - ctx->cplfgain = ff_fgaintab[get_bits(gb, 3)]; - } - for (i = 0; i < nfchans; i++) { /* channel fine snr offset and fast gain code */ - ctx->snroffst[i] = (csnr + get_bits(gb, 4)) << 2; - ctx->fgain[i] = ff_fgaintab[get_bits(gb, 3)]; - } - if (ctx->lfeon) { /* lfe fine snr offset and fast gain code */ - ctx->lfesnroffst = (csnr + get_bits(gb, 4)) << 2; - ctx->lfefgain = ff_fgaintab[get_bits(gb, 3)]; + csnr = (get_bits(gbc, 6) - 15) << 4; + for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */ + s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2; + s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; } + memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); } - if (ctx->cplinu && get_bits1(gb)) { /* coupling leak information */ - bit_alloc_flags |= 64; - ctx->bit_alloc_params.cplfleak = get_bits(gb, 3); - ctx->bit_alloc_params.cplsleak = get_bits(gb, 3); + /* coupling leak information */ + if (s->cpl_in_use && get_bits1(gbc)) { + s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3); + s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3); + bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2); } - if (get_bits1(gb)) { /* delta bit allocation information */ - bit_alloc_flags = 127; - - if (ctx->cplinu) { - ctx->cpldeltbae = get_bits(gb, 2); - if (ctx->cpldeltbae == DBA_RESERVED) { - av_log(NULL, AV_LOG_ERROR, "coupling delta bit allocation strategy reserved\n"); - return -1; - } - } - - for (i = 0; i < nfchans; i++) { - ctx->deltbae[i] = get_bits(gb, 2); - if (ctx->deltbae[i] == DBA_RESERVED) { - av_log(NULL, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); + /* delta bit allocation information */ + if (get_bits1(gbc)) { + /* delta bit allocation exists (strategy) */ + for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) { + s->dba_mode[ch] = get_bits(gbc, 2); + if (s->dba_mode[ch] == DBA_RESERVED) { + av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); return -1; } + bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); } - - if (ctx->cplinu) - if (ctx->cpldeltbae == DBA_NEW) { /*coupling delta offset, len and bit allocation */ - ctx->cpldeltnseg = get_bits(gb, 3); - for (seg = 0; seg <= ctx->cpldeltnseg; seg++) { - ctx->cpldeltoffst[seg] = get_bits(gb, 5); - ctx->cpldeltlen[seg] = get_bits(gb, 4); - ctx->cpldeltba[seg] = get_bits(gb, 3); - } - } - - for (i = 0; i < nfchans; i++) - if (ctx->deltbae[i] == DBA_NEW) {/*channel delta offset, len and bit allocation */ - ctx->deltnseg[i] = get_bits(gb, 3); - for (seg = 0; seg <= ctx->deltnseg[i]; seg++) { - ctx->deltoffst[i][seg] = get_bits(gb, 5); - ctx->deltlen[i][seg] = get_bits(gb, 4); - ctx->deltba[i][seg] = get_bits(gb, 3); + /* channel delta offset, len and bit allocation */ + for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) { + if (s->dba_mode[ch] == DBA_NEW) { + s->dba_nsegs[ch] = get_bits(gbc, 3); + for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) { + s->dba_offsets[ch][seg] = get_bits(gbc, 5); + s->dba_lengths[ch][seg] = get_bits(gbc, 4); + s->dba_values[ch][seg] = get_bits(gbc, 3); } } + } } else if(blk == 0) { - if(ctx->cplinu) - ctx->cpldeltbae = DBA_NONE; - for(i=0; ideltbae[i] = DBA_NONE; + for(ch=0; ch<=s->channels; ch++) { + s->dba_mode[ch] = DBA_NONE; } } - if (bit_alloc_flags) { - if (ctx->cplinu && (bit_alloc_flags & 64)) - ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->cplbap, - ctx->dcplexps, ctx->cplstrtmant, - ctx->cplendmant, ctx->cplsnroffst, - ctx->cplfgain, 0, - ctx->cpldeltbae, ctx->cpldeltnseg, - ctx->cpldeltoffst, ctx->cpldeltlen, - ctx->cpldeltba); - for (i = 0; i < nfchans; i++) - if ((bit_alloc_flags >> i) & 1) - ac3_parametric_bit_allocation(&ctx->bit_alloc_params, - ctx->bap[i], ctx->dexps[i], 0, - ctx->endmant[i], ctx->snroffst[i], - ctx->fgain[i], 0, ctx->deltbae[i], - ctx->deltnseg[i], ctx->deltoffst[i], - ctx->deltlen[i], ctx->deltba[i]); - if (ctx->lfeon && (bit_alloc_flags & 32)) - ac3_parametric_bit_allocation(&ctx->bit_alloc_params, ctx->lfebap, - ctx->dlfeexps, 0, 7, ctx->lfesnroffst, - ctx->lfefgain, 1, - DBA_NONE, 0, NULL, NULL, NULL); + /* Bit allocation */ + for(ch=!s->cpl_in_use; ch<=s->channels; ch++) { + if(bit_alloc_stages[ch] > 2) { + /* Exponent mapping into PSD and PSD integration */ + ff_ac3_bit_alloc_calc_psd(s->dexps[ch], + s->start_freq[ch], s->end_freq[ch], + s->psd[ch], s->band_psd[ch]); + } + if(bit_alloc_stages[ch] > 1) { + /* Compute excitation function, Compute masking curve, and + Apply delta bit allocation */ + ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch], + s->start_freq[ch], s->end_freq[ch], + s->fast_gain[ch], (ch == s->lfe_ch), + s->dba_mode[ch], s->dba_nsegs[ch], + s->dba_offsets[ch], s->dba_lengths[ch], + s->dba_values[ch], s->mask[ch]); + } + if(bit_alloc_stages[ch] > 0) { + /* Compute bit allocation */ + ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch], + s->start_freq[ch], s->end_freq[ch], + s->snr_offset[ch], + s->bit_alloc_params.floor, + s->bap[ch]); + } } - if (get_bits1(gb)) { /* unused dummy data */ - skipl = get_bits(gb, 9); + /* unused dummy data */ + if (get_bits1(gbc)) { + int skipl = get_bits(gbc, 9); while(skipl--) - skip_bits(gb, 8); + skip_bits(gbc, 8); } + /* unpack the transform coefficients - * * this also uncouples channels if coupling is in use. - */ - if (get_transform_coeffs(ctx)) { - av_log(NULL, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n"); + this also uncouples channels if coupling is in use. */ + if (get_transform_coeffs(s)) { + av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n"); return -1; } /* recover coefficients if rematrixing is in use */ - if(ctx->acmod == AC3_ACMOD_STEREO) - do_rematrixing(ctx); + if(s->channel_mode == AC3_CHMODE_STEREO) + do_rematrixing(s); /* apply scaling to coefficients (headroom, dynrng) */ - if(ctx->lfeon) { - for(i=0; i<7; i++) { - ctx->transform_coeffs[0][i] *= 2.0f * ctx->dynrng; - } - } - for(ch=1; ch<=ctx->nfchans; ch++) { - float gain = 2.0f; - if(ctx->acmod == AC3_ACMOD_DUALMONO && ch == 2) { - gain *= ctx->dynrng2; + for(ch=1; ch<=s->channels; ch++) { + float gain = 2.0f * s->mul_bias; + if(s->channel_mode == AC3_CHMODE_DUALMONO) { + gain *= s->dynamic_range[ch-1]; } else { - gain *= ctx->dynrng; + gain *= s->dynamic_range[0]; } - for(i=0; iendmant[ch-1]; i++) { - ctx->transform_coeffs[ch][i] *= gain; + for(i=0; iend_freq[ch]; i++) { + s->transform_coeffs[ch][i] *= gain; } } - do_imdct(ctx); + do_imdct(s); - return 0; -} + /* downmix output if needed */ + if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) && + s->fbw_channels == s->out_channels)) { + ac3_downmix(s); + } -static inline int16_t convert(int32_t i) -{ - if (i > 0x43c07fff) - return 32767; - else if (i <= 0x43bf8000) - return -32768; - else - return (i - 0x43c00000); + /* convert float to 16-bit integer */ + for(ch=0; chout_channels; ch++) { + for(i=0; i<256; i++) { + s->output[ch][i] += s->add_bias; + } + s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256); + } + + return 0; } -/* Decode ac3 frame. - * - * @param avctx Pointer to AVCodecContext - * @param data Pointer to pcm smaples - * @param data_size Set to number of pcm samples produced by decoding - * @param buf Data to be decoded - * @param buf_size Size of the buffer +/** + * Decode a single AC-3 frame. */ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size) { - AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data; + AC3DecodeContext *s = avctx->priv_data; int16_t *out_samples = (int16_t *)data; - int i, j, k, start; - int32_t *int_ptr[6]; + int i, blk, ch, err; - for (i = 0; i < 6; i++) - int_ptr[i] = (int32_t *)(&ctx->output[i]); + /* initialize the GetBitContext with the start of valid AC-3 Frame */ + init_get_bits(&s->gbc, buf, buf_size * 8); - //Initialize the GetBitContext with the start of valid AC3 Frame. - init_get_bits(&ctx->gb, buf, buf_size * 8); + /* parse the syncinfo */ + err = ac3_parse_header(s); + if(err) { + switch(err) { + case AC3_PARSE_ERROR_SYNC: + av_log(avctx, AV_LOG_ERROR, "frame sync error\n"); + break; + case AC3_PARSE_ERROR_BSID: + av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n"); + break; + case AC3_PARSE_ERROR_SAMPLE_RATE: + av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n"); + break; + case AC3_PARSE_ERROR_FRAME_SIZE: + av_log(avctx, AV_LOG_ERROR, "invalid frame size\n"); + break; + default: + av_log(avctx, AV_LOG_ERROR, "invalid header\n"); + break; + } + return -1; + } - //Parse the syncinfo. - if (ac3_parse_header(ctx)) { - av_log(avctx, AV_LOG_ERROR, "\n"); - *data_size = 0; - return buf_size; + /* check that reported frame size fits in input buffer */ + if(s->frame_size > buf_size) { + av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); + return -1; } - avctx->sample_rate = ctx->sampling_rate; - avctx->bit_rate = ctx->bit_rate; + /* check for crc mismatch */ + if(avctx->error_resilience > 0) { + if(av_crc(av_crc8005, 0, &buf[2], s->frame_size-2)) { + av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n"); + return -1; + } + /* TODO: error concealment */ + } + + avctx->sample_rate = s->sample_rate; + avctx->bit_rate = s->bit_rate; /* channel config */ - if (avctx->channels == 0) { - avctx->channels = ctx->out_channels; - } - if(avctx->channels != ctx->out_channels) { - av_log(avctx, AV_LOG_ERROR, "Cannot mix AC3 to %d channels.\n", - avctx->channels); - return -1; + s->out_channels = s->channels; + if (avctx->request_channels > 0 && avctx->request_channels <= 2 && + avctx->request_channels < s->channels) { + s->out_channels = avctx->request_channels; + s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; } + avctx->channels = s->out_channels; - //av_log(avctx, AV_LOG_INFO, "channels = %d \t bit rate = %d \t sampling rate = %d \n", avctx->channels, avctx->bit_rate * 1000, avctx->sample_rate); - - //Parse the Audio Blocks. - for (i = 0; i < NB_BLOCKS; i++) { - if (ac3_parse_audio_block(ctx, i)) { + /* parse the audio blocks */ + for (blk = 0; blk < NB_BLOCKS; blk++) { + if (ac3_parse_audio_block(s, blk)) { av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n"); *data_size = 0; - return ctx->frame_size; + return s->frame_size; } - start = (ctx->output_mode & AC3_OUTPUT_LFEON) ? 0 : 1; - for (k = 0; k < 256; k++) - for (j = start; j <= ctx->nfchans; j++) - *(out_samples++) = convert(int_ptr[j][k]); + for (i = 0; i < 256; i++) + for (ch = 0; ch < s->out_channels; ch++) + *(out_samples++) = s->int_output[ch][i]; } *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t); - return ctx->frame_size; + return s->frame_size; } -/* Uninitialize ac3 decoder. +/** + * Uninitialize the AC-3 decoder. */ static int ac3_decode_end(AVCodecContext *avctx) { - AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data; - ff_mdct_end(&ctx->imdct_512); - ff_mdct_end(&ctx->imdct_256); + AC3DecodeContext *s = avctx->priv_data; + ff_mdct_end(&s->imdct_512); + ff_mdct_end(&s->imdct_256); return 0; } @@ -1077,4 +1165,3 @@ AVCodec ac3_decoder = { .close = ac3_decode_end, .decode = ac3_decode_frame, }; -