/* * AC-3 Audio Decoder * This code was developed as part of Google Summer of Code 2006. * E-AC-3 support was added as part of Google Summer of Code 2007. * * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com) * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com> * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com> * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <stdio.h>#include <stddef.h>#include <math.h>#include <string.h> #include "libavutil/channel_layout.h"#include "libavutil/crc.h"#include "libavutil/downmix_info.h"#include "libavutil/opt.h"#include "bswapdsp.h"#include "internal.h"#include "aac_ac3_parser.h"#include "ac3_parser.h"#include "ac3dec.h"#include "ac3dec_data.h"#include "kbdwin.h" /** * table for ungrouping 3 values in 7 bits. * used for exponents and bap=2 mantissas */static uint8_t ungroup_3_in_7_bits_tab[128][3]; /** tables for ungrouping mantissas */static int b1_mantissas[32][3];static int b2_mantissas[128][3];static int b3_mantissas[8];static int b4_mantissas[128][2];static int b5_mantissas[16]; /** * Quantization table: levels for symmetric. bits for asymmetric. * reference: Table 7.18 Mapping of bap to Quantizer */static const uint8_t quantization_tab[16] = {    0, 3, 5, 7, 11, 15,    5, 6, 7, 8, 9, 10, 11, 12, 14, 16}; #if (!USE_FIXED)/** dynamic range table. converts codes to scale factors. */static float dynamic_range_tab[256];float ff_ac3_heavy_dynamic_range_tab[256];#endif /** Adjustments in dB gain */static const float gain_levels[9] = {    LEVEL_PLUS_3DB,    LEVEL_PLUS_1POINT5DB,    LEVEL_ONE,    LEVEL_MINUS_1POINT5DB,    LEVEL_MINUS_3DB,    LEVEL_MINUS_4POINT5DB,    LEVEL_MINUS_6DB,    LEVEL_ZERO,    LEVEL_MINUS_9DB}; /** Adjustments in dB gain (LFE, +10 to -21 dB) */static const float gain_levels_lfe[32] = {    3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,    1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,    0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,    0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,    0.125892, 0.112201, 0.100000, 0.089125}; /** * 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] = {    { { 2, 7 }, { 7, 2 },                               },    { { 4, 4 },                                         },    { { 2, 7 }, { 7, 2 },                               },    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },}; /** * Symmetrical Dequantization * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization *            Tables 7.19 to 7.23 */static inline intsymmetric_dequant(int code, int levels){    return ((code - (levels >> 1)) * (1 << 24)) / levels;} /* * Initialize tables at runtime. */static av_cold void ac3_tables_init(void){    int i;     /* generate table for ungrouping 3 values in 7 bits       reference: Section 7.1.3 Exponent Decoding */    for (i = 0; i < 128; i++) {        ungroup_3_in_7_bits_tab[i][0] =  i / 25;        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;    }     /* generate grouped mantissa tables       reference: Section 7.3.5 Ungrouping of Mantissas */    for (i = 0; i < 32; i++) {        /* bap=1 mantissas */        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);    }    for (i = 0; i < 128; i++) {        /* bap=2 mantissas */        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);         /* bap=4 mantissas */        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);    }    /* generate ungrouped mantissa tables       reference: Tables 7.21 and 7.23 */    for (i = 0; i < 7; i++) {        /* bap=3 mantissas */        b3_mantissas[i] = symmetric_dequant(i, 7);    }    for (i = 0; i < 15; i++) {        /* bap=5 mantissas */        b5_mantissas[i] = symmetric_dequant(i, 15);    } #if (!USE_FIXED)    /* generate dynamic range table       reference: Section 7.7.1 Dynamic Range Control */    for (i = 0; i < 256; i++) {        int v = (i >> 5) - ((i >> 7) << 3) - 5;        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);    }     /* generate compr dynamic range table       reference: Section 7.7.2 Heavy Compression */    for (i = 0; i < 256; i++) {        int v = (i >> 4) - ((i >> 7) << 4) - 4;        ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);    }#endif} /** * AVCodec initialization */static av_cold int ac3_decode_init(AVCodecContext *avctx){    AC3DecodeContext *s = avctx->priv_data;    int i;     s->avctx = avctx;     ac3_tables_init();    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);    AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);    ff_bswapdsp_init(&s->bdsp); #if (USE_FIXED)    s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);#else    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);    ff_fmt_convert_init(&s->fmt_conv, avctx);#endif     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);    av_lfg_init(&s->dith_state, 0);     if (USE_FIXED)        avctx->sample_fmt = AV_SAMPLE_FMT_S16P;    else        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;     /* allow downmixing to stereo or mono */    if (avctx->channels > 1 &&        avctx->request_channel_layout == AV_CH_LAYOUT_MONO)        avctx->channels = 1;    else if (avctx->channels > 2 &&             avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)        avctx->channels = 2;    s->downmixed = 1;     for (i = 0; i < AC3_MAX_CHANNELS; i++) {        s->xcfptr[i] = s->transform_coeffs[i];        s->dlyptr[i] = s->delay[i];    }     return 0;} /** * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream. * GetBitContext within AC3DecodeContext must point to * the start of the synchronized AC-3 bitstream. */static int ac3_parse_header(AC3DecodeContext *s){    GetBitContext *gbc = &s->gbc;    int i;     /* read the rest of the bsi. read twice for dual mono mode. */    i = !s->channel_mode;    do {        s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);        if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {            s->dialog_normalization[(!s->channel_mode)-i] = -31;        }        if (s->target_level != 0) {            s->level_gain[(!s->channel_mode)-i] = powf(2.0f,                (float)(s->target_level -                s->dialog_normalization[(!s->channel_mode)-i])/6.0f);        }        if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {            s->heavy_dynamic_range[(!s->channel_mode)-i] =                AC3_HEAVY_RANGE(get_bits(gbc, 8));        }        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(gbc, 2); //skip copyright bit and original bitstream bit     /* skip the timecodes or parse the Alternate Bit Stream Syntax */    if (s->bitstream_id != 6) {        if (get_bits1(gbc))            skip_bits(gbc, 14); //skip timecode1        if (get_bits1(gbc))            skip_bits(gbc, 14); //skip timecode2    } else {        if (get_bits1(gbc)) {            s->preferred_downmix       = get_bits(gbc, 2);            s->center_mix_level_ltrt   = get_bits(gbc, 3);            s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);            s->center_mix_level        = get_bits(gbc, 3);            s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);        }        if (get_bits1(gbc)) {            s->dolby_surround_ex_mode = get_bits(gbc, 2);            s->dolby_headphone_mode   = get_bits(gbc, 2);            skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)        }    }     /* skip additional bitstream info */    if (get_bits1(gbc)) {        i = get_bits(gbc, 6);        do {            skip_bits(gbc, 8);        } while (i--);    }     return 0;} /** * Common function to parse AC-3 or E-AC-3 frame header */static int parse_frame_header(AC3DecodeContext *s){    AC3HeaderInfo hdr, *phdr=&hdr;    int err;     err = avpriv_ac3_parse_header(&s->gbc, &phdr);    if (err)        return err;     /* get decoding parameters from header info */    s->bit_alloc_params.sr_code     = hdr.sr_code;    s->bitstream_id                 = hdr.bitstream_id;    s->bitstream_mode               = hdr.bitstream_mode;    s->channel_mode                 = hdr.channel_mode;    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;    s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;    s->center_mix_level             = hdr.center_mix_level;    s->center_mix_level_ltrt        = 4; // -3.0dB    s->surround_mix_level           = hdr.surround_mix_level;    s->surround_mix_level_ltrt      = 4; // -3.0dB    s->lfe_mix_level_exists         = 0;    s->num_blocks                   = hdr.num_blocks;    s->frame_type                   = hdr.frame_type;    s->substreamid                  = hdr.substreamid;    s->dolby_surround_mode          = hdr.dolby_surround_mode;    s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;    s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;     if (s->lfe_on) {        s->start_freq[s->lfe_ch]     = 0;        s->end_freq[s->lfe_ch]       = 7;        s->num_exp_groups[s->lfe_ch] = 2;        s->channel_in_cpl[s->lfe_ch] = 0;    }     if (s->bitstream_id <= 10) {        s->eac3                  = 0;        s->snr_offset_strategy   = 2;        s->block_switch_syntax   = 1;        s->dither_flag_syntax    = 1;        s->bit_allocation_syntax = 1;        s->fast_gain_syntax      = 0;        s->first_cpl_leak        = 0;        s->dba_syntax            = 1;        s->skip_syntax           = 1;        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));        return ac3_parse_header(s);    } else if (CONFIG_EAC3_DECODER) {        s->eac3 = 1;        return ff_eac3_parse_header(s);    } else {        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");        return AVERROR(ENOSYS);    }} /** * Set stereo downmixing coefficients based on frame header info. * reference: Section 7.8.2 Downmixing Into Two Channels */static void set_downmix_coeffs(AC3DecodeContext *s){    int i;    float cmix = gain_levels[s->  center_mix_level];    float smix = gain_levels[s->surround_mix_level];    float norm0, norm1;    float downmix_coeffs[AC3_MAX_CHANNELS][2];     for (i = 0; i < s->fbw_channels; i++) {        downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];        downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];    }    if (s->channel_mode > 1 && s->channel_mode & 1) {        downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;    }    if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {        int nf = s->channel_mode - 2;        downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;    }    if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {        int nf = s->channel_mode - 4;        downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;    }     /* renormalize */    norm0 = norm1 = 0.0;    for (i = 0; i < s->fbw_channels; i++) {        norm0 += downmix_coeffs[i][0];        norm1 += downmix_coeffs[i][1];    }    norm0 = 1.0f / norm0;    norm1 = 1.0f / norm1;    for (i = 0; i < s->fbw_channels; i++) {        downmix_coeffs[i][0] *= norm0;        downmix_coeffs[i][1] *= norm1;    }     if (s->output_mode == AC3_CHMODE_MONO) {        for (i = 0; i < s->fbw_channels; i++)            downmix_coeffs[i][0] = (downmix_coeffs[i][0] +                                    downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;    }    for (i = 0; i < s->fbw_channels; i++) {        s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);        s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);    }} /** * Decode the grouped exponents according to exponent strategy. * reference: Section 7.1.3 Exponent Decoding */static int decode_exponents(AC3DecodeContext *s,                            GetBitContext *gbc, int exp_strategy, int ngrps,                            uint8_t absexp, int8_t *dexps){    int i, j, grp, group_size;    int dexp[256];    int expacc, prevexp;     /* unpack groups */    group_size = exp_strategy + (exp_strategy == EXP_D45);    for (grp = 0, i = 0; grp < ngrps; grp++) {        expacc = get_bits(gbc, 7);        if (expacc >= 125) {            av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);            return AVERROR_INVALIDDATA;        }        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];    }     /* convert to absolute exps and expand groups */    prevexp = absexp;    for (i = 0, j = 0; i < ngrps * 3; i++) {        prevexp += dexp[i] - 2;        if (prevexp > 24U) {            av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp);            return -1;        }        switch (group_size) {        case 4: dexps[j++] = prevexp;                dexps[j++] = prevexp;        case 2: dexps[j++] = prevexp;        case 1: dexps[j++] = prevexp;        }    }    return 0;} /** * Generate transform coefficients for each coupled channel in the coupling * range using the coupling coefficients and coupling coordinates. * reference: Section 7.4.3 Coupling Coordinate Format */static void calc_transform_coeffs_cpl(AC3DecodeContext *s){    int bin, band, ch;     bin = s->start_freq[CPL_CH];    for (band = 0; band < s->num_cpl_bands; band++) {        int band_start = bin;        int band_end = bin + s->cpl_band_sizes[band];        for (ch = 1; ch <= s->fbw_channels; ch++) {            if (s->channel_in_cpl[ch]) {                int cpl_coord = s->cpl_coords[ch][band] << 5;                for (bin = band_start; bin < band_end; bin++) {                    s->fixed_coeffs[ch][bin] =                        MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);                }                if (ch == 2 && s->phase_flags[band]) {                    for (bin = band_start; bin < band_end; bin++)                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];                }            }        }        bin = band_end;    }} /** * Grouped mantissas for 3-level 5-level and 11-level quantization */typedef struct mant_groups {    int b1_mant[2];    int b2_mant[2];    int b4_mant;    int b1;    int b2;    int b4;} mant_groups; /** * Decode the transform coefficients for a particular channel * reference: Section 7.3 Quantization and Decoding of Mantissas

Lines 1–500 of 1652. Load more