Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * AC-3 Audio Decoder
  3.  * This code was developed as part of Google Summer of Code 2006.
  4.  * E-AC-3 support was added as part of Google Summer of Code 2007.
  5.  *
  6.  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
  7.  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
  8.  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
  9.  *
  10.  * This file is part of FFmpeg.
  11.  *
  12.  * FFmpeg is free software; you can redistribute it and/or
  13.  * modify it under the terms of the GNU Lesser General Public
  14.  * License as published by the Free Software Foundation; either
  15.  * version 2.1 of the License, or (at your option) any later version.
  16.  *
  17.  * FFmpeg is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20.  * Lesser General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU Lesser General Public
  23.  * License along with FFmpeg; if not, write to the Free Software
  24.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25.  */
  26.  
  27. #include <stdio.h>
  28. #include <stddef.h>
  29. #include <math.h>
  30. #include <string.h>
  31.  
  32. #include "libavutil/channel_layout.h"
  33. #include "libavutil/crc.h"
  34. #include "libavutil/downmix_info.h"
  35. #include "libavutil/opt.h"
  36. #include "bswapdsp.h"
  37. #include "internal.h"
  38. #include "aac_ac3_parser.h"
  39. #include "ac3_parser.h"
  40. #include "ac3dec.h"
  41. #include "ac3dec_data.h"
  42. #include "kbdwin.h"
  43.  
  44. /**
  45.  * table for ungrouping 3 values in 7 bits.
  46.  * used for exponents and bap=2 mantissas
  47.  */
  48. static uint8_t ungroup_3_in_7_bits_tab[128][3];
  49.  
  50. /** tables for ungrouping mantissas */
  51. static int b1_mantissas[32][3];
  52. static int b2_mantissas[128][3];
  53. static int b3_mantissas[8];
  54. static int b4_mantissas[128][2];
  55. static int b5_mantissas[16];
  56.  
  57. /**
  58.  * Quantization table: levels for symmetric. bits for asymmetric.
  59.  * reference: Table 7.18 Mapping of bap to Quantizer
  60.  */
  61. static const uint8_t quantization_tab[16] = {
  62.     0, 3, 5, 7, 11, 15,
  63.     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
  64. };
  65.  
  66. /** dynamic range table. converts codes to scale factors. */
  67. static float dynamic_range_tab[256];
  68. static float heavy_dynamic_range_tab[256];
  69.  
  70. /** Adjustments in dB gain */
  71. static const float gain_levels[9] = {
  72.     LEVEL_PLUS_3DB,
  73.     LEVEL_PLUS_1POINT5DB,
  74.     LEVEL_ONE,
  75.     LEVEL_MINUS_1POINT5DB,
  76.     LEVEL_MINUS_3DB,
  77.     LEVEL_MINUS_4POINT5DB,
  78.     LEVEL_MINUS_6DB,
  79.     LEVEL_ZERO,
  80.     LEVEL_MINUS_9DB
  81. };
  82.  
  83. /** Adjustments in dB gain (LFE, +10 to -21 dB) */
  84. static const float gain_levels_lfe[32] = {
  85.     3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
  86.     1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
  87.     0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
  88.     0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
  89.     0.125892, 0.112201, 0.100000, 0.089125
  90. };
  91.  
  92. /**
  93.  * Table for default stereo downmixing coefficients
  94.  * reference: Section 7.8.2 Downmixing Into Two Channels
  95.  */
  96. static const uint8_t ac3_default_coeffs[8][5][2] = {
  97.     { { 2, 7 }, { 7, 2 },                               },
  98.     { { 4, 4 },                                         },
  99.     { { 2, 7 }, { 7, 2 },                               },
  100.     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
  101.     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
  102.     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
  103.     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
  104.     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
  105. };
  106.  
  107. /**
  108.  * Symmetrical Dequantization
  109.  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
  110.  *            Tables 7.19 to 7.23
  111.  */
  112. static inline int
  113. symmetric_dequant(int code, int levels)
  114. {
  115.     return ((code - (levels >> 1)) * (1 << 24)) / levels;
  116. }
  117.  
  118. /*
  119.  * Initialize tables at runtime.
  120.  */
  121. static av_cold void ac3_tables_init(void)
  122. {
  123.     int i;
  124.  
  125.     /* generate table for ungrouping 3 values in 7 bits
  126.        reference: Section 7.1.3 Exponent Decoding */
  127.     for (i = 0; i < 128; i++) {
  128.         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
  129.         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
  130.         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
  131.     }
  132.  
  133.     /* generate grouped mantissa tables
  134.        reference: Section 7.3.5 Ungrouping of Mantissas */
  135.     for (i = 0; i < 32; i++) {
  136.         /* bap=1 mantissas */
  137.         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
  138.         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
  139.         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
  140.     }
  141.     for (i = 0; i < 128; i++) {
  142.         /* bap=2 mantissas */
  143.         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
  144.         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
  145.         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
  146.  
  147.         /* bap=4 mantissas */
  148.         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
  149.         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
  150.     }
  151.     /* generate ungrouped mantissa tables
  152.        reference: Tables 7.21 and 7.23 */
  153.     for (i = 0; i < 7; i++) {
  154.         /* bap=3 mantissas */
  155.         b3_mantissas[i] = symmetric_dequant(i, 7);
  156.     }
  157.     for (i = 0; i < 15; i++) {
  158.         /* bap=5 mantissas */
  159.         b5_mantissas[i] = symmetric_dequant(i, 15);
  160.     }
  161.  
  162.     /* generate dynamic range table
  163.        reference: Section 7.7.1 Dynamic Range Control */
  164.     for (i = 0; i < 256; i++) {
  165.         int v = (i >> 5) - ((i >> 7) << 3) - 5;
  166.         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
  167.     }
  168.  
  169.     /* generate compr dynamic range table
  170.        reference: Section 7.7.2 Heavy Compression */
  171.     for (i = 0; i < 256; i++) {
  172.         int v = (i >> 4) - ((i >> 7) << 4) - 4;
  173.         heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10);
  174.     }
  175.  
  176. }
  177.  
  178. /**
  179.  * AVCodec initialization
  180.  */
  181. static av_cold int ac3_decode_init(AVCodecContext *avctx)
  182. {
  183.     AC3DecodeContext *s = avctx->priv_data;
  184.     int i;
  185.  
  186.     s->avctx = avctx;
  187.  
  188.     ff_ac3_common_init();
  189.     ac3_tables_init();
  190.     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
  191.     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
  192.     AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256);
  193.     ff_bswapdsp_init(&s->bdsp);
  194.  
  195. #if (USE_FIXED)
  196.     s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT);
  197. #else
  198.     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
  199.     ff_fmt_convert_init(&s->fmt_conv, avctx);
  200. #endif
  201.  
  202.     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
  203.     av_lfg_init(&s->dith_state, 0);
  204.  
  205.     if (USE_FIXED)
  206.         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  207.     else
  208.         avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
  209.  
  210.     /* allow downmixing to stereo or mono */
  211. #if FF_API_REQUEST_CHANNELS
  212. FF_DISABLE_DEPRECATION_WARNINGS
  213.     if (avctx->request_channels == 1)
  214.         avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
  215.     else if (avctx->request_channels == 2)
  216.         avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
  217. FF_ENABLE_DEPRECATION_WARNINGS
  218. #endif
  219.     if (avctx->channels > 1 &&
  220.         avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
  221.         avctx->channels = 1;
  222.     else if (avctx->channels > 2 &&
  223.              avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
  224.         avctx->channels = 2;
  225.     s->downmixed = 1;
  226.  
  227.     for (i = 0; i < AC3_MAX_CHANNELS; i++) {
  228.         s->xcfptr[i] = s->transform_coeffs[i];
  229.         s->dlyptr[i] = s->delay[i];
  230.     }
  231.  
  232.     return 0;
  233. }
  234.  
  235. /**
  236.  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
  237.  * GetBitContext within AC3DecodeContext must point to
  238.  * the start of the synchronized AC-3 bitstream.
  239.  */
  240. static int ac3_parse_header(AC3DecodeContext *s)
  241. {
  242.     GetBitContext *gbc = &s->gbc;
  243.     int i;
  244.  
  245.     /* read the rest of the bsi. read twice for dual mono mode. */
  246.     i = !s->channel_mode;
  247.     do {
  248.         s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5);
  249.         if (s->dialog_normalization[(!s->channel_mode)-i] == 0) {
  250.             s->dialog_normalization[(!s->channel_mode)-i] = -31;
  251.         }
  252.         if (s->target_level != 0) {
  253.             s->level_gain[(!s->channel_mode)-i] = powf(2.0f,
  254.                 (float)(s->target_level -
  255.                 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
  256.         }
  257.         if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) {
  258.             s->heavy_dynamic_range[(!s->channel_mode)-i] =
  259.                 AC3_HEAVY_RANGE(get_bits(gbc, 8));
  260.         }
  261.         if (get_bits1(gbc))
  262.             skip_bits(gbc, 8); //skip language code
  263.         if (get_bits1(gbc))
  264.             skip_bits(gbc, 7); //skip audio production information
  265.     } while (i--);
  266.  
  267.     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
  268.  
  269.     /* skip the timecodes or parse the Alternate Bit Stream Syntax */
  270.     if (s->bitstream_id != 6) {
  271.         if (get_bits1(gbc))
  272.             skip_bits(gbc, 14); //skip timecode1
  273.         if (get_bits1(gbc))
  274.             skip_bits(gbc, 14); //skip timecode2
  275.     } else {
  276.         if (get_bits1(gbc)) {
  277.             s->preferred_downmix       = get_bits(gbc, 2);
  278.             s->center_mix_level_ltrt   = get_bits(gbc, 3);
  279.             s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
  280.             s->center_mix_level        = get_bits(gbc, 3);
  281.             s->surround_mix_level      = av_clip(get_bits(gbc, 3), 3, 7);
  282.         }
  283.         if (get_bits1(gbc)) {
  284.             s->dolby_surround_ex_mode = get_bits(gbc, 2);
  285.             s->dolby_headphone_mode   = get_bits(gbc, 2);
  286.             skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
  287.         }
  288.     }
  289.  
  290.     /* skip additional bitstream info */
  291.     if (get_bits1(gbc)) {
  292.         i = get_bits(gbc, 6);
  293.         do {
  294.             skip_bits(gbc, 8);
  295.         } while (i--);
  296.     }
  297.  
  298.     return 0;
  299. }
  300.  
  301. /**
  302.  * Common function to parse AC-3 or E-AC-3 frame header
  303.  */
  304. static int parse_frame_header(AC3DecodeContext *s)
  305. {
  306.     AC3HeaderInfo hdr, *phdr=&hdr;
  307.     int err;
  308.  
  309.     err = avpriv_ac3_parse_header2(&s->gbc, &phdr);
  310.     if (err)
  311.         return err;
  312.  
  313.     /* get decoding parameters from header info */
  314.     s->bit_alloc_params.sr_code     = hdr.sr_code;
  315.     s->bitstream_id                 = hdr.bitstream_id;
  316.     s->bitstream_mode               = hdr.bitstream_mode;
  317.     s->channel_mode                 = hdr.channel_mode;
  318.     s->lfe_on                       = hdr.lfe_on;
  319.     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
  320.     s->sample_rate                  = hdr.sample_rate;
  321.     s->bit_rate                     = hdr.bit_rate;
  322.     s->channels                     = hdr.channels;
  323.     s->fbw_channels                 = s->channels - s->lfe_on;
  324.     s->lfe_ch                       = s->fbw_channels + 1;
  325.     s->frame_size                   = hdr.frame_size;
  326.     s->preferred_downmix            = AC3_DMIXMOD_NOTINDICATED;
  327.     s->center_mix_level             = hdr.center_mix_level;
  328.     s->center_mix_level_ltrt        = 4; // -3.0dB
  329.     s->surround_mix_level           = hdr.surround_mix_level;
  330.     s->surround_mix_level_ltrt      = 4; // -3.0dB
  331.     s->lfe_mix_level_exists         = 0;
  332.     s->num_blocks                   = hdr.num_blocks;
  333.     s->frame_type                   = hdr.frame_type;
  334.     s->substreamid                  = hdr.substreamid;
  335.     s->dolby_surround_mode          = hdr.dolby_surround_mode;
  336.     s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
  337.     s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
  338.  
  339.     if (s->lfe_on) {
  340.         s->start_freq[s->lfe_ch]     = 0;
  341.         s->end_freq[s->lfe_ch]       = 7;
  342.         s->num_exp_groups[s->lfe_ch] = 2;
  343.         s->channel_in_cpl[s->lfe_ch] = 0;
  344.     }
  345.  
  346.     if (s->bitstream_id <= 10) {
  347.         s->eac3                  = 0;
  348.         s->snr_offset_strategy   = 2;
  349.         s->block_switch_syntax   = 1;
  350.         s->dither_flag_syntax    = 1;
  351.         s->bit_allocation_syntax = 1;
  352.         s->fast_gain_syntax      = 0;
  353.         s->first_cpl_leak        = 0;
  354.         s->dba_syntax            = 1;
  355.         s->skip_syntax           = 1;
  356.         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
  357.         return ac3_parse_header(s);
  358.     } else if (CONFIG_EAC3_DECODER) {
  359.         s->eac3 = 1;
  360.         return ff_eac3_parse_header(s);
  361.     } else {
  362.         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
  363.         return AVERROR(ENOSYS);
  364.     }
  365. }
  366.  
  367. /**
  368.  * Set stereo downmixing coefficients based on frame header info.
  369.  * reference: Section 7.8.2 Downmixing Into Two Channels
  370.  */
  371. static void set_downmix_coeffs(AC3DecodeContext *s)
  372. {
  373.     int i;
  374.     float cmix = gain_levels[s->  center_mix_level];
  375.     float smix = gain_levels[s->surround_mix_level];
  376.     float norm0, norm1;
  377.     float downmix_coeffs[AC3_MAX_CHANNELS][2];
  378.  
  379.     for (i = 0; i < s->fbw_channels; i++) {
  380.         downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
  381.         downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
  382.     }
  383.     if (s->channel_mode > 1 && s->channel_mode & 1) {
  384.         downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
  385.     }
  386.     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
  387.         int nf = s->channel_mode - 2;
  388.         downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
  389.     }
  390.     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
  391.         int nf = s->channel_mode - 4;
  392.         downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
  393.     }
  394.  
  395.     /* renormalize */
  396.     norm0 = norm1 = 0.0;
  397.     for (i = 0; i < s->fbw_channels; i++) {
  398.         norm0 += downmix_coeffs[i][0];
  399.         norm1 += downmix_coeffs[i][1];
  400.     }
  401.     norm0 = 1.0f / norm0;
  402.     norm1 = 1.0f / norm1;
  403.     for (i = 0; i < s->fbw_channels; i++) {
  404.         downmix_coeffs[i][0] *= norm0;
  405.         downmix_coeffs[i][1] *= norm1;
  406.     }
  407.  
  408.     if (s->output_mode == AC3_CHMODE_MONO) {
  409.         for (i = 0; i < s->fbw_channels; i++)
  410.             downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
  411.                                     downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
  412.     }
  413.     for (i = 0; i < s->fbw_channels; i++) {
  414.         s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
  415.         s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
  416.     }
  417. }
  418.  
  419. /**
  420.  * Decode the grouped exponents according to exponent strategy.
  421.  * reference: Section 7.1.3 Exponent Decoding
  422.  */
  423. static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
  424.                             uint8_t absexp, int8_t *dexps)
  425. {
  426.     int i, j, grp, group_size;
  427.     int dexp[256];
  428.     int expacc, prevexp;
  429.  
  430.     /* unpack groups */
  431.     group_size = exp_strategy + (exp_strategy == EXP_D45);
  432.     for (grp = 0, i = 0; grp < ngrps; grp++) {
  433.         expacc = get_bits(gbc, 7);
  434.         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
  435.         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
  436.         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
  437.     }
  438.  
  439.     /* convert to absolute exps and expand groups */
  440.     prevexp = absexp;
  441.     for (i = 0, j = 0; i < ngrps * 3; i++) {
  442.         prevexp += dexp[i] - 2;
  443.         if (prevexp > 24U)
  444.             return -1;
  445.         switch (group_size) {
  446.         case 4: dexps[j++] = prevexp;
  447.                 dexps[j++] = prevexp;
  448.         case 2: dexps[j++] = prevexp;
  449.         case 1: dexps[j++] = prevexp;
  450.         }
  451.     }
  452.     return 0;
  453. }
  454.  
  455. /**
  456.  * Generate transform coefficients for each coupled channel in the coupling
  457.  * range using the coupling coefficients and coupling coordinates.
  458.  * reference: Section 7.4.3 Coupling Coordinate Format
  459.  */
  460. static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
  461. {
  462.     int bin, band, ch;
  463.  
  464.     bin = s->start_freq[CPL_CH];
  465.     for (band = 0; band < s->num_cpl_bands; band++) {
  466.         int band_start = bin;
  467.         int band_end = bin + s->cpl_band_sizes[band];
  468.         for (ch = 1; ch <= s->fbw_channels; ch++) {
  469.             if (s->channel_in_cpl[ch]) {
  470.                 int cpl_coord = s->cpl_coords[ch][band] << 5;
  471.                 for (bin = band_start; bin < band_end; bin++) {
  472.                     s->fixed_coeffs[ch][bin] =
  473.                         MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord);
  474.                 }
  475.                 if (ch == 2 && s->phase_flags[band]) {
  476.                     for (bin = band_start; bin < band_end; bin++)
  477.                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
  478.                 }
  479.             }
  480.         }
  481.         bin = band_end;
  482.     }
  483. }
  484.  
  485. /**
  486.  * Grouped mantissas for 3-level 5-level and 11-level quantization
  487.  */
  488. typedef struct mant_groups {
  489.     int b1_mant[2];
  490.     int b2_mant[2];
  491.     int b4_mant;
  492.     int b1;
  493.     int b2;
  494.     int b4;
  495. } mant_groups;
  496.  
  497. /**
  498.  * Decode the transform coefficients for a particular channel
  499.  * reference: Section 7.3 Quantization and Decoding of Mantissas
  500.  */
  501. static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
  502. {
  503.     int start_freq = s->start_freq[ch_index];
  504.     int end_freq   = s->end_freq[ch_index];
  505.     uint8_t *baps  = s->bap[ch_index];
  506.     int8_t *exps   = s->dexps[ch_index];
  507.     int32_t *coeffs = s->fixed_coeffs[ch_index];
  508.     int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
  509.     GetBitContext *gbc = &s->gbc;
  510.     int freq;
  511.  
  512.     for (freq = start_freq; freq < end_freq; freq++) {
  513.         int bap = baps[freq];
  514.         int mantissa;
  515.         switch (bap) {
  516.         case 0:
  517.             /* random noise with approximate range of -0.707 to 0.707 */
  518.             if (dither)
  519.                 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
  520.             else
  521.                 mantissa = 0;
  522.             break;
  523.         case 1:
  524.             if (m->b1) {
  525.                 m->b1--;
  526.                 mantissa = m->b1_mant[m->b1];
  527.             } else {
  528.                 int bits      = get_bits(gbc, 5);
  529.                 mantissa      = b1_mantissas[bits][0];
  530.                 m->b1_mant[1] = b1_mantissas[bits][1];
  531.                 m->b1_mant[0] = b1_mantissas[bits][2];
  532.                 m->b1         = 2;
  533.             }
  534.             break;
  535.         case 2:
  536.             if (m->b2) {
  537.                 m->b2--;
  538.                 mantissa = m->b2_mant[m->b2];
  539.             } else {
  540.                 int bits      = get_bits(gbc, 7);
  541.                 mantissa      = b2_mantissas[bits][0];
  542.                 m->b2_mant[1] = b2_mantissas[bits][1];
  543.                 m->b2_mant[0] = b2_mantissas[bits][2];
  544.                 m->b2         = 2;
  545.             }
  546.             break;
  547.         case 3:
  548.             mantissa = b3_mantissas[get_bits(gbc, 3)];
  549.             break;
  550.         case 4:
  551.             if (m->b4) {
  552.                 m->b4 = 0;
  553.                 mantissa = m->b4_mant;
  554.             } else {
  555.                 int bits   = get_bits(gbc, 7);
  556.                 mantissa   = b4_mantissas[bits][0];
  557.                 m->b4_mant = b4_mantissas[bits][1];
  558.                 m->b4      = 1;
  559.             }
  560.             break;
  561.         case 5:
  562.             mantissa = b5_mantissas[get_bits(gbc, 4)];
  563.             break;
  564.         default: /* 6 to 15 */
  565.             /* Shift mantissa and sign-extend it. */
  566.             if (bap > 15) {
  567.                 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
  568.                 bap = 15;
  569.             }
  570.             mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]);
  571.             break;
  572.         }
  573.         coeffs[freq] = mantissa >> exps[freq];
  574.     }
  575. }
  576.  
  577. /**
  578.  * Remove random dithering from coupling range coefficients with zero-bit
  579.  * mantissas for coupled channels which do not use dithering.
  580.  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
  581.  */
  582. static void remove_dithering(AC3DecodeContext *s) {
  583.     int ch, i;
  584.  
  585.     for (ch = 1; ch <= s->fbw_channels; ch++) {
  586.         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
  587.             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
  588.                 if (!s->bap[CPL_CH][i])
  589.                     s->fixed_coeffs[ch][i] = 0;
  590.             }
  591.         }
  592.     }
  593. }
  594.  
  595. static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
  596.                                        mant_groups *m)
  597. {
  598.     if (!s->channel_uses_aht[ch]) {
  599.         ac3_decode_transform_coeffs_ch(s, ch, m);
  600.     } else {
  601.         /* if AHT is used, mantissas for all blocks are encoded in the first
  602.            block of the frame. */
  603.         int bin;
  604.         if (CONFIG_EAC3_DECODER && !blk)
  605.             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
  606.         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
  607.             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
  608.         }
  609.     }
  610. }
  611.  
  612. /**
  613.  * Decode the transform coefficients.
  614.  */
  615. static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
  616. {
  617.     int ch, end;
  618.     int got_cplchan = 0;
  619.     mant_groups m;
  620.  
  621.     m.b1 = m.b2 = m.b4 = 0;
  622.  
  623.     for (ch = 1; ch <= s->channels; ch++) {
  624.         /* transform coefficients for full-bandwidth channel */
  625.         decode_transform_coeffs_ch(s, blk, ch, &m);
  626.         /* transform coefficients for coupling channel come right after the
  627.            coefficients for the first coupled channel*/
  628.         if (s->channel_in_cpl[ch])  {
  629.             if (!got_cplchan) {
  630.                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
  631.                 calc_transform_coeffs_cpl(s);
  632.                 got_cplchan = 1;
  633.             }
  634.             end = s->end_freq[CPL_CH];
  635.         } else {
  636.             end = s->end_freq[ch];
  637.         }
  638.         do
  639.             s->fixed_coeffs[ch][end] = 0;
  640.         while (++end < 256);
  641.     }
  642.  
  643.     /* zero the dithered coefficients for appropriate channels */
  644.     remove_dithering(s);
  645. }
  646.  
  647. /**
  648.  * Stereo rematrixing.
  649.  * reference: Section 7.5.4 Rematrixing : Decoding Technique
  650.  */
  651. static void do_rematrixing(AC3DecodeContext *s)
  652. {
  653.     int bnd, i;
  654.     int end, bndend;
  655.  
  656.     end = FFMIN(s->end_freq[1], s->end_freq[2]);
  657.  
  658.     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
  659.         if (s->rematrixing_flags[bnd]) {
  660.             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
  661.             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
  662.                 int tmp0 = s->fixed_coeffs[1][i];
  663.                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
  664.                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
  665.             }
  666.         }
  667.     }
  668. }
  669.  
  670. /**
  671.  * Inverse MDCT Transform.
  672.  * Convert frequency domain coefficients to time-domain audio samples.
  673.  * reference: Section 7.9.4 Transformation Equations
  674.  */
  675. static inline void do_imdct(AC3DecodeContext *s, int channels)
  676. {
  677.     int ch;
  678.  
  679.     for (ch = 1; ch <= channels; ch++) {
  680.         if (s->block_switch[ch]) {
  681.             int i;
  682.             FFTSample *x = s->tmp_output + 128;
  683.             for (i = 0; i < 128; i++)
  684.                 x[i] = s->transform_coeffs[ch][2 * i];
  685.             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
  686. #if USE_FIXED
  687.             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
  688.                                        s->tmp_output, s->window, 128, 8);
  689. #else
  690.             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
  691.                                        s->tmp_output, s->window, 128);
  692. #endif
  693.             for (i = 0; i < 128; i++)
  694.                 x[i] = s->transform_coeffs[ch][2 * i + 1];
  695.             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
  696.         } else {
  697.             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
  698. #if USE_FIXED
  699.             s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1],
  700.                                        s->tmp_output, s->window, 128, 8);
  701. #else
  702.             s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
  703.                                        s->tmp_output, s->window, 128);
  704. #endif
  705.             memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(FFTSample));
  706.         }
  707.     }
  708. }
  709.  
  710. /**
  711.  * Upmix delay samples from stereo to original channel layout.
  712.  */
  713. static void ac3_upmix_delay(AC3DecodeContext *s)
  714. {
  715.     int channel_data_size = sizeof(s->delay[0]);
  716.     switch (s->channel_mode) {
  717.     case AC3_CHMODE_DUALMONO:
  718.     case AC3_CHMODE_STEREO:
  719.         /* upmix mono to stereo */
  720.         memcpy(s->delay[1], s->delay[0], channel_data_size);
  721.         break;
  722.     case AC3_CHMODE_2F2R:
  723.         memset(s->delay[3], 0, channel_data_size);
  724.     case AC3_CHMODE_2F1R:
  725.         memset(s->delay[2], 0, channel_data_size);
  726.         break;
  727.     case AC3_CHMODE_3F2R:
  728.         memset(s->delay[4], 0, channel_data_size);
  729.     case AC3_CHMODE_3F1R:
  730.         memset(s->delay[3], 0, channel_data_size);
  731.     case AC3_CHMODE_3F:
  732.         memcpy(s->delay[2], s->delay[1], channel_data_size);
  733.         memset(s->delay[1], 0, channel_data_size);
  734.         break;
  735.     }
  736. }
  737.  
  738. /**
  739.  * Decode band structure for coupling, spectral extension, or enhanced coupling.
  740.  * The band structure defines how many subbands are in each band.  For each
  741.  * subband in the range, 1 means it is combined with the previous band, and 0
  742.  * means that it starts a new band.
  743.  *
  744.  * @param[in] gbc bit reader context
  745.  * @param[in] blk block number
  746.  * @param[in] eac3 flag to indicate E-AC-3
  747.  * @param[in] ecpl flag to indicate enhanced coupling
  748.  * @param[in] start_subband subband number for start of range
  749.  * @param[in] end_subband subband number for end of range
  750.  * @param[in] default_band_struct default band structure table
  751.  * @param[out] num_bands number of bands (optionally NULL)
  752.  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
  753.  */
  754. static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
  755.                                   int ecpl, int start_subband, int end_subband,
  756.                                   const uint8_t *default_band_struct,
  757.                                   int *num_bands, uint8_t *band_sizes)
  758. {
  759.     int subbnd, bnd, n_subbands, n_bands=0;
  760.     uint8_t bnd_sz[22];
  761.     uint8_t coded_band_struct[22];
  762.     const uint8_t *band_struct;
  763.  
  764.     n_subbands = end_subband - start_subband;
  765.  
  766.     /* decode band structure from bitstream or use default */
  767.     if (!eac3 || get_bits1(gbc)) {
  768.         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
  769.             coded_band_struct[subbnd] = get_bits1(gbc);
  770.         }
  771.         band_struct = coded_band_struct;
  772.     } else if (!blk) {
  773.         band_struct = &default_band_struct[start_subband+1];
  774.     } else {
  775.         /* no change in band structure */
  776.         return;
  777.     }
  778.  
  779.     /* calculate number of bands and band sizes based on band structure.
  780.        note that the first 4 subbands in enhanced coupling span only 6 bins
  781.        instead of 12. */
  782.     if (num_bands || band_sizes ) {
  783.         n_bands = n_subbands;
  784.         bnd_sz[0] = ecpl ? 6 : 12;
  785.         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
  786.             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
  787.             if (band_struct[subbnd - 1]) {
  788.                 n_bands--;
  789.                 bnd_sz[bnd] += subbnd_size;
  790.             } else {
  791.                 bnd_sz[++bnd] = subbnd_size;
  792.             }
  793.         }
  794.     }
  795.  
  796.     /* set optional output params */
  797.     if (num_bands)
  798.         *num_bands = n_bands;
  799.     if (band_sizes)
  800.         memcpy(band_sizes, bnd_sz, n_bands);
  801. }
  802.  
  803. /**
  804.  * Decode a single audio block from the AC-3 bitstream.
  805.  */
  806. static int decode_audio_block(AC3DecodeContext *s, int blk)
  807. {
  808.     int fbw_channels = s->fbw_channels;
  809.     int channel_mode = s->channel_mode;
  810.     int i, bnd, seg, ch;
  811.     int different_transforms;
  812.     int downmix_output;
  813.     int cpl_in_use;
  814.     GetBitContext *gbc = &s->gbc;
  815.     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
  816.  
  817.     /* block switch flags */
  818.     different_transforms = 0;
  819.     if (s->block_switch_syntax) {
  820.         for (ch = 1; ch <= fbw_channels; ch++) {
  821.             s->block_switch[ch] = get_bits1(gbc);
  822.             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
  823.                 different_transforms = 1;
  824.         }
  825.     }
  826.  
  827.     /* dithering flags */
  828.     if (s->dither_flag_syntax) {
  829.         for (ch = 1; ch <= fbw_channels; ch++) {
  830.             s->dither_flag[ch] = get_bits1(gbc);
  831.         }
  832.     }
  833.  
  834.     /* dynamic range */
  835.     i = !s->channel_mode;
  836.     do {
  837.         if (get_bits1(gbc)) {
  838.             /* Allow asymmetric application of DRC when drc_scale > 1.
  839.                Amplification of quiet sounds is enhanced */
  840.             int range_bits = get_bits(gbc, 8);
  841.             INTFLOAT range = AC3_RANGE(range_bits);
  842.             if (range_bits <= 127 || s->drc_scale <= 1.0)
  843.                 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range);
  844.             else
  845.                 s->dynamic_range[i] = range;
  846.         } else if (blk == 0) {
  847.             s->dynamic_range[i] = AC3_DYNAMIC_RANGE1;
  848.         }
  849.     } while (i--);
  850.  
  851.     /* spectral extension strategy */
  852.     if (s->eac3 && (!blk || get_bits1(gbc))) {
  853.         s->spx_in_use = get_bits1(gbc);
  854.         if (s->spx_in_use) {
  855.             int dst_start_freq, dst_end_freq, src_start_freq,
  856.                 start_subband, end_subband;
  857.  
  858.             /* determine which channels use spx */
  859.             if (s->channel_mode == AC3_CHMODE_MONO) {
  860.                 s->channel_uses_spx[1] = 1;
  861.             } else {
  862.                 for (ch = 1; ch <= fbw_channels; ch++)
  863.                     s->channel_uses_spx[ch] = get_bits1(gbc);
  864.             }
  865.  
  866.             /* get the frequency bins of the spx copy region and the spx start
  867.                and end subbands */
  868.             dst_start_freq = get_bits(gbc, 2);
  869.             start_subband  = get_bits(gbc, 3) + 2;
  870.             if (start_subband > 7)
  871.                 start_subband += start_subband - 7;
  872.             end_subband    = get_bits(gbc, 3) + 5;
  873. #if USE_FIXED
  874.             s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
  875. #endif
  876.             if (end_subband   > 7)
  877.                 end_subband   += end_subband   - 7;
  878.             dst_start_freq = dst_start_freq * 12 + 25;
  879.             src_start_freq = start_subband  * 12 + 25;
  880.             dst_end_freq   = end_subband    * 12 + 25;
  881.  
  882.             /* check validity of spx ranges */
  883.             if (start_subband >= end_subband) {
  884.                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
  885.                        "range (%d >= %d)\n", start_subband, end_subband);
  886.                 return AVERROR_INVALIDDATA;
  887.             }
  888.             if (dst_start_freq >= src_start_freq) {
  889.                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
  890.                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
  891.                 return AVERROR_INVALIDDATA;
  892.             }
  893.  
  894.             s->spx_dst_start_freq = dst_start_freq;
  895.             s->spx_src_start_freq = src_start_freq;
  896.             if (!USE_FIXED)
  897.                 s->spx_dst_end_freq   = dst_end_freq;
  898.  
  899.             decode_band_structure(gbc, blk, s->eac3, 0,
  900.                                   start_subband, end_subband,
  901.                                   ff_eac3_default_spx_band_struct,
  902.                                   &s->num_spx_bands,
  903.                                   s->spx_band_sizes);
  904.         } else {
  905.             for (ch = 1; ch <= fbw_channels; ch++) {
  906.                 s->channel_uses_spx[ch] = 0;
  907.                 s->first_spx_coords[ch] = 1;
  908.             }
  909.         }
  910.     }
  911.  
  912.     /* spectral extension coordinates */
  913.     if (s->spx_in_use) {
  914.         for (ch = 1; ch <= fbw_channels; ch++) {
  915.             if (s->channel_uses_spx[ch]) {
  916.                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
  917.                     INTFLOAT spx_blend;
  918.                     int bin, master_spx_coord;
  919.  
  920.                     s->first_spx_coords[ch] = 0;
  921.                     spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
  922.                     master_spx_coord = get_bits(gbc, 2) * 3;
  923.  
  924.                     bin = s->spx_src_start_freq;
  925.                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
  926.                         int bandsize = s->spx_band_sizes[bnd];
  927.                         int spx_coord_exp, spx_coord_mant;
  928.                         INTFLOAT nratio, sblend, nblend;
  929. #if USE_FIXED
  930.                         /* calculate blending factors */
  931.                         int64_t accu = ((bin << 23) + (bandsize << 22))
  932.                                      * (int64_t)s->spx_dst_end_freq;
  933.                         nratio = (int)(accu >> 32);
  934.                         nratio -= spx_blend << 18;
  935.  
  936.                         if (nratio < 0) {
  937.                             nblend = 0;
  938.                             sblend = 0x800000;
  939.                         } else if (nratio > 0x7fffff) {
  940.                             nblend = 14529495; // sqrt(3) in FP.23
  941.                             sblend = 0;
  942.                         } else {
  943.                             nblend = fixed_sqrt(nratio, 23);
  944.                             accu = (int64_t)nblend * 1859775393;
  945.                             nblend = (int)((accu + (1<<29)) >> 30);
  946.                             sblend = fixed_sqrt(0x800000 - nratio, 23);
  947.                         }
  948. #else
  949.                         float spx_coord;
  950.  
  951.                         /* calculate blending factors */
  952.                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
  953.                         nratio = av_clipf(nratio, 0.0f, 1.0f);
  954.                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
  955.                                                        // to give unity variance
  956.                         sblend = sqrtf(1.0f - nratio);
  957. #endif
  958.                         bin += bandsize;
  959.  
  960.                         /* decode spx coordinates */
  961.                         spx_coord_exp  = get_bits(gbc, 4);
  962.                         spx_coord_mant = get_bits(gbc, 2);
  963.                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
  964.                         else                     spx_coord_mant += 4;
  965.                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
  966.  
  967.                         /* multiply noise and signal blending factors by spx coordinate */
  968. #if USE_FIXED
  969.                         accu = (int64_t)nblend * spx_coord_mant;
  970.                         s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
  971.                         accu = (int64_t)sblend * spx_coord_mant;
  972.                         s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
  973. #else
  974.                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
  975.                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
  976.                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
  977. #endif
  978.                     }
  979.                 }
  980.             } else {
  981.                 s->first_spx_coords[ch] = 1;
  982.             }
  983.         }
  984.     }
  985.  
  986.     /* coupling strategy */
  987.     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
  988.         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
  989.         if (!s->eac3)
  990.             s->cpl_in_use[blk] = get_bits1(gbc);
  991.         if (s->cpl_in_use[blk]) {
  992.             /* coupling in use */
  993.             int cpl_start_subband, cpl_end_subband;
  994.  
  995.             if (channel_mode < AC3_CHMODE_STEREO) {
  996.                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
  997.                 return AVERROR_INVALIDDATA;
  998.             }
  999.  
  1000.             /* check for enhanced coupling */
  1001.             if (s->eac3 && get_bits1(gbc)) {
  1002.                 /* TODO: parse enhanced coupling strategy info */
  1003.                 avpriv_request_sample(s->avctx, "Enhanced coupling");
  1004.                 return AVERROR_PATCHWELCOME;
  1005.             }
  1006.  
  1007.             /* determine which channels are coupled */
  1008.             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
  1009.                 s->channel_in_cpl[1] = 1;
  1010.                 s->channel_in_cpl[2] = 1;
  1011.             } else {
  1012.                 for (ch = 1; ch <= fbw_channels; ch++)
  1013.                     s->channel_in_cpl[ch] = get_bits1(gbc);
  1014.             }
  1015.  
  1016.             /* phase flags in use */
  1017.             if (channel_mode == AC3_CHMODE_STEREO)
  1018.                 s->phase_flags_in_use = get_bits1(gbc);
  1019.  
  1020.             /* coupling frequency range */
  1021.             cpl_start_subband = get_bits(gbc, 4);
  1022.             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
  1023.                                               get_bits(gbc, 4) + 3;
  1024.             if (cpl_start_subband >= cpl_end_subband) {
  1025.                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
  1026.                        cpl_start_subband, cpl_end_subband);
  1027.                 return AVERROR_INVALIDDATA;
  1028.             }
  1029.             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
  1030.             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
  1031.  
  1032.             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
  1033.                                   cpl_end_subband,
  1034.                                   ff_eac3_default_cpl_band_struct,
  1035.                                   &s->num_cpl_bands, s->cpl_band_sizes);
  1036.         } else {
  1037.             /* coupling not in use */
  1038.             for (ch = 1; ch <= fbw_channels; ch++) {
  1039.                 s->channel_in_cpl[ch] = 0;
  1040.                 s->first_cpl_coords[ch] = 1;
  1041.             }
  1042.             s->first_cpl_leak = s->eac3;
  1043.             s->phase_flags_in_use = 0;
  1044.         }
  1045.     } else if (!s->eac3) {
  1046.         if (!blk) {
  1047.             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
  1048.                    "be present in block 0\n");
  1049.             return AVERROR_INVALIDDATA;
  1050.         } else {
  1051.             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
  1052.         }
  1053.     }
  1054.     cpl_in_use = s->cpl_in_use[blk];
  1055.  
  1056.     /* coupling coordinates */
  1057.     if (cpl_in_use) {
  1058.         int cpl_coords_exist = 0;
  1059.  
  1060.         for (ch = 1; ch <= fbw_channels; ch++) {
  1061.             if (s->channel_in_cpl[ch]) {
  1062.                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
  1063.                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
  1064.                     s->first_cpl_coords[ch] = 0;
  1065.                     cpl_coords_exist = 1;
  1066.                     master_cpl_coord = 3 * get_bits(gbc, 2);
  1067.                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
  1068.                         cpl_coord_exp = get_bits(gbc, 4);
  1069.                         cpl_coord_mant = get_bits(gbc, 4);
  1070.                         if (cpl_coord_exp == 15)
  1071.                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
  1072.                         else
  1073.                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
  1074.                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
  1075.                     }
  1076.                 } else if (!blk) {
  1077.                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
  1078.                            "be present in block 0\n");
  1079.                     return AVERROR_INVALIDDATA;
  1080.                 }
  1081.             } else {
  1082.                 /* channel not in coupling */
  1083.                 s->first_cpl_coords[ch] = 1;
  1084.             }
  1085.         }
  1086.         /* phase flags */
  1087.         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
  1088.             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
  1089.                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
  1090.             }
  1091.         }
  1092.     }
  1093.  
  1094.     /* stereo rematrixing strategy and band structure */
  1095.     if (channel_mode == AC3_CHMODE_STEREO) {
  1096.         if ((s->eac3 && !blk) || get_bits1(gbc)) {
  1097.             s->num_rematrixing_bands = 4;
  1098.             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
  1099.                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
  1100.             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
  1101.                 s->num_rematrixing_bands--;
  1102.             }
  1103.             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
  1104.                 s->rematrixing_flags[bnd] = get_bits1(gbc);
  1105.         } else if (!blk) {
  1106.             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
  1107.                    "new rematrixing strategy not present in block 0\n");
  1108.             s->num_rematrixing_bands = 0;
  1109.         }
  1110.     }
  1111.  
  1112.     /* exponent strategies for each channel */
  1113.     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
  1114.         if (!s->eac3)
  1115.             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
  1116.         if (s->exp_strategy[blk][ch] != EXP_REUSE)
  1117.             bit_alloc_stages[ch] = 3;
  1118.     }
  1119.  
  1120.     /* channel bandwidth */
  1121.     for (ch = 1; ch <= fbw_channels; ch++) {
  1122.         s->start_freq[ch] = 0;
  1123.         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
  1124.             int group_size;
  1125.             int prev = s->end_freq[ch];
  1126.             if (s->channel_in_cpl[ch])
  1127.                 s->end_freq[ch] = s->start_freq[CPL_CH];
  1128.             else if (s->channel_uses_spx[ch])
  1129.                 s->end_freq[ch] = s->spx_src_start_freq;
  1130.             else {
  1131.                 int bandwidth_code = get_bits(gbc, 6);
  1132.                 if (bandwidth_code > 60) {
  1133.                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
  1134.                     return AVERROR_INVALIDDATA;
  1135.                 }
  1136.                 s->end_freq[ch] = bandwidth_code * 3 + 73;
  1137.             }
  1138.             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
  1139.             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
  1140.             if (blk > 0 && s->end_freq[ch] != prev)
  1141.                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
  1142.         }
  1143.     }
  1144.     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
  1145.         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
  1146.                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
  1147.     }
  1148.  
  1149.     /* decode exponents for each channel */
  1150.     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
  1151.         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
  1152.             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
  1153.             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
  1154.                                  s->num_exp_groups[ch], s->dexps[ch][0],
  1155.                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
  1156.                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
  1157.                 return AVERROR_INVALIDDATA;
  1158.             }
  1159.             if (ch != CPL_CH && ch != s->lfe_ch)
  1160.                 skip_bits(gbc, 2); /* skip gainrng */
  1161.         }
  1162.     }
  1163.  
  1164.     /* bit allocation information */
  1165.     if (s->bit_allocation_syntax) {
  1166.         if (get_bits1(gbc)) {
  1167.             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
  1168.             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
  1169.             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
  1170.             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
  1171.             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
  1172.             for (ch = !cpl_in_use; ch <= s->channels; ch++)
  1173.                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
  1174.         } else if (!blk) {
  1175.             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
  1176.                    "be present in block 0\n");
  1177.             return AVERROR_INVALIDDATA;
  1178.         }
  1179.     }
  1180.  
  1181.     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
  1182.     if (!s->eac3 || !blk) {
  1183.         if (s->snr_offset_strategy && get_bits1(gbc)) {
  1184.             int snr = 0;
  1185.             int csnr;
  1186.             csnr = (get_bits(gbc, 6) - 15) << 4;
  1187.             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
  1188.                 /* snr offset */
  1189.                 if (ch == i || s->snr_offset_strategy == 2)
  1190.                     snr = (csnr + get_bits(gbc, 4)) << 2;
  1191.                 /* run at least last bit allocation stage if snr offset changes */
  1192.                 if (blk && s->snr_offset[ch] != snr) {
  1193.                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
  1194.                 }
  1195.                 s->snr_offset[ch] = snr;
  1196.  
  1197.                 /* fast gain (normal AC-3 only) */
  1198.                 if (!s->eac3) {
  1199.                     int prev = s->fast_gain[ch];
  1200.                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
  1201.                     /* run last 2 bit allocation stages if fast gain changes */
  1202.                     if (blk && prev != s->fast_gain[ch])
  1203.                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
  1204.                 }
  1205.             }
  1206.         } else if (!s->eac3 && !blk) {
  1207.             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
  1208.             return AVERROR_INVALIDDATA;
  1209.         }
  1210.     }
  1211.  
  1212.     /* fast gain (E-AC-3 only) */
  1213.     if (s->fast_gain_syntax && get_bits1(gbc)) {
  1214.         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
  1215.             int prev = s->fast_gain[ch];
  1216.             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
  1217.             /* run last 2 bit allocation stages if fast gain changes */
  1218.             if (blk && prev != s->fast_gain[ch])
  1219.                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
  1220.         }
  1221.     } else if (s->eac3 && !blk) {
  1222.         for (ch = !cpl_in_use; ch <= s->channels; ch++)
  1223.             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
  1224.     }
  1225.  
  1226.     /* E-AC-3 to AC-3 converter SNR offset */
  1227.     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
  1228.         skip_bits(gbc, 10); // skip converter snr offset
  1229.     }
  1230.  
  1231.     /* coupling leak information */
  1232.     if (cpl_in_use) {
  1233.         if (s->first_cpl_leak || get_bits1(gbc)) {
  1234.             int fl = get_bits(gbc, 3);
  1235.             int sl = get_bits(gbc, 3);
  1236.             /* run last 2 bit allocation stages for coupling channel if
  1237.                coupling leak changes */
  1238.             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
  1239.                 sl != s->bit_alloc_params.cpl_slow_leak)) {
  1240.                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
  1241.             }
  1242.             s->bit_alloc_params.cpl_fast_leak = fl;
  1243.             s->bit_alloc_params.cpl_slow_leak = sl;
  1244.         } else if (!s->eac3 && !blk) {
  1245.             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
  1246.                    "be present in block 0\n");
  1247.             return AVERROR_INVALIDDATA;
  1248.         }
  1249.         s->first_cpl_leak = 0;
  1250.     }
  1251.  
  1252.     /* delta bit allocation information */
  1253.     if (s->dba_syntax && get_bits1(gbc)) {
  1254.         /* delta bit allocation exists (strategy) */
  1255.         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
  1256.             s->dba_mode[ch] = get_bits(gbc, 2);
  1257.             if (s->dba_mode[ch] == DBA_RESERVED) {
  1258.                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
  1259.                 return AVERROR_INVALIDDATA;
  1260.             }
  1261.             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
  1262.         }
  1263.         /* channel delta offset, len and bit allocation */
  1264.         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
  1265.             if (s->dba_mode[ch] == DBA_NEW) {
  1266.                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
  1267.                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
  1268.                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
  1269.                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
  1270.                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
  1271.                 }
  1272.                 /* run last 2 bit allocation stages if new dba values */
  1273.                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
  1274.             }
  1275.         }
  1276.     } else if (blk == 0) {
  1277.         for (ch = 0; ch <= s->channels; ch++) {
  1278.             s->dba_mode[ch] = DBA_NONE;
  1279.         }
  1280.     }
  1281.  
  1282.     /* Bit allocation */
  1283.     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
  1284.         if (bit_alloc_stages[ch] > 2) {
  1285.             /* Exponent mapping into PSD and PSD integration */
  1286.             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
  1287.                                       s->start_freq[ch], s->end_freq[ch],
  1288.                                       s->psd[ch], s->band_psd[ch]);
  1289.         }
  1290.         if (bit_alloc_stages[ch] > 1) {
  1291.             /* Compute excitation function, Compute masking curve, and
  1292.                Apply delta bit allocation */
  1293.             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
  1294.                                            s->start_freq[ch],  s->end_freq[ch],
  1295.                                            s->fast_gain[ch],   (ch == s->lfe_ch),
  1296.                                            s->dba_mode[ch],    s->dba_nsegs[ch],
  1297.                                            s->dba_offsets[ch], s->dba_lengths[ch],
  1298.                                            s->dba_values[ch],  s->mask[ch])) {
  1299.                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
  1300.                 return AVERROR_INVALIDDATA;
  1301.             }
  1302.         }
  1303.         if (bit_alloc_stages[ch] > 0) {
  1304.             /* Compute bit allocation */
  1305.             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
  1306.                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
  1307.             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
  1308.                                       s->start_freq[ch], s->end_freq[ch],
  1309.                                       s->snr_offset[ch],
  1310.                                       s->bit_alloc_params.floor,
  1311.                                       bap_tab, s->bap[ch]);
  1312.         }
  1313.     }
  1314.  
  1315.     /* unused dummy data */
  1316.     if (s->skip_syntax && get_bits1(gbc)) {
  1317.         int skipl = get_bits(gbc, 9);
  1318.         while (skipl--)
  1319.             skip_bits(gbc, 8);
  1320.     }
  1321.  
  1322.     /* unpack the transform coefficients
  1323.        this also uncouples channels if coupling is in use. */
  1324.     decode_transform_coeffs(s, blk);
  1325.  
  1326.     /* TODO: generate enhanced coupling coordinates and uncouple */
  1327.  
  1328.     /* recover coefficients if rematrixing is in use */
  1329.     if (s->channel_mode == AC3_CHMODE_STEREO)
  1330.         do_rematrixing(s);
  1331.  
  1332.     /* apply scaling to coefficients (headroom, dynrng) */
  1333.     for (ch = 1; ch <= s->channels; ch++) {
  1334.         int audio_channel = 0;
  1335.         INTFLOAT gain;
  1336.         if (s->channel_mode == AC3_CHMODE_DUALMONO)
  1337.             audio_channel = 2-ch;
  1338.         if (s->heavy_compression && s->compression_exists[audio_channel])
  1339.             gain = s->heavy_dynamic_range[audio_channel];
  1340.         else
  1341.             gain = s->dynamic_range[audio_channel];
  1342.  
  1343. #if USE_FIXED
  1344.         scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
  1345. #else
  1346.         if (s->target_level != 0)
  1347.           gain = gain * s->level_gain[audio_channel];
  1348.         gain *= 1.0 / 4194304.0f;
  1349.         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
  1350.                                                s->fixed_coeffs[ch], gain, 256);
  1351. #endif
  1352.     }
  1353.  
  1354.     /* apply spectral extension to high frequency bins */
  1355.     if (CONFIG_EAC3_DECODER && s->spx_in_use) {
  1356.         ff_eac3_apply_spectral_extension(s);
  1357.     }
  1358.  
  1359.     /* downmix and MDCT. order depends on whether block switching is used for
  1360.        any channel in this block. this is because coefficients for the long
  1361.        and short transforms cannot be mixed. */
  1362.     downmix_output = s->channels != s->out_channels &&
  1363.                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
  1364.                      s->fbw_channels == s->out_channels);
  1365.     if (different_transforms) {
  1366.         /* the delay samples have already been downmixed, so we upmix the delay
  1367.            samples in order to reconstruct all channels before downmixing. */
  1368.         if (s->downmixed) {
  1369.             s->downmixed = 0;
  1370.             ac3_upmix_delay(s);
  1371.         }
  1372.  
  1373.         do_imdct(s, s->channels);
  1374.  
  1375.         if (downmix_output) {
  1376. #if USE_FIXED
  1377.             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
  1378.                               s->out_channels, s->fbw_channels, 256);
  1379. #else
  1380.             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
  1381.                               s->out_channels, s->fbw_channels, 256);
  1382. #endif
  1383.         }
  1384.     } else {
  1385.         if (downmix_output) {
  1386.             s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
  1387.                                           s->out_channels, s->fbw_channels, 256);
  1388.         }
  1389.  
  1390.         if (downmix_output && !s->downmixed) {
  1391.             s->downmixed = 1;
  1392.             s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
  1393.                                           s->out_channels, s->fbw_channels, 128);
  1394.         }
  1395.  
  1396.         do_imdct(s, s->out_channels);
  1397.     }
  1398.  
  1399.     return 0;
  1400. }
  1401.  
  1402. /**
  1403.  * Decode a single AC-3 frame.
  1404.  */
  1405. static int ac3_decode_frame(AVCodecContext * avctx, void *data,
  1406.                             int *got_frame_ptr, AVPacket *avpkt)
  1407. {
  1408.     AVFrame *frame     = data;
  1409.     const uint8_t *buf = avpkt->data;
  1410.     int buf_size = avpkt->size;
  1411.     AC3DecodeContext *s = avctx->priv_data;
  1412.     int blk, ch, err, ret;
  1413.     const uint8_t *channel_map;
  1414.     const SHORTFLOAT *output[AC3_MAX_CHANNELS];
  1415.     enum AVMatrixEncoding matrix_encoding;
  1416.     AVDownmixInfo *downmix_info;
  1417.  
  1418.     /* copy input buffer to decoder context to avoid reading past the end
  1419.        of the buffer, which can be caused by a damaged input stream. */
  1420.     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
  1421.         // seems to be byte-swapped AC-3
  1422.         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
  1423.         s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
  1424.                             (const uint16_t *) buf, cnt);
  1425.     } else
  1426.         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
  1427.     buf = s->input_buffer;
  1428.     /* initialize the GetBitContext with the start of valid AC-3 Frame */
  1429.     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
  1430.         return ret;
  1431.  
  1432.     /* parse the syncinfo */
  1433.     err = parse_frame_header(s);
  1434.  
  1435.     if (err) {
  1436.         switch (err) {
  1437.         case AAC_AC3_PARSE_ERROR_SYNC:
  1438.             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
  1439.             return AVERROR_INVALIDDATA;
  1440.         case AAC_AC3_PARSE_ERROR_BSID:
  1441.             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
  1442.             break;
  1443.         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
  1444.             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
  1445.             break;
  1446.         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
  1447.             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
  1448.             break;
  1449.         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
  1450.             /* skip frame if CRC is ok. otherwise use error concealment. */
  1451.             /* TODO: add support for substreams and dependent frames */
  1452.             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
  1453.                 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
  1454.                        "skipping frame\n");
  1455.                 *got_frame_ptr = 0;
  1456.                 return buf_size;
  1457.             } else {
  1458.                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
  1459.             }
  1460.             break;
  1461.         case AAC_AC3_PARSE_ERROR_CRC:
  1462.         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
  1463.             break;
  1464.         default: // Normal AVERROR do not try to recover.
  1465.             *got_frame_ptr = 0;
  1466.             return err;
  1467.         }
  1468.     } else {
  1469.         /* check that reported frame size fits in input buffer */
  1470.         if (s->frame_size > buf_size) {
  1471.             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
  1472.             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
  1473.         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
  1474.             /* check for crc mismatch */
  1475.             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
  1476.                        s->frame_size - 2)) {
  1477.                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
  1478.                 if (avctx->err_recognition & AV_EF_EXPLODE)
  1479.                     return AVERROR_INVALIDDATA;
  1480.                 err = AAC_AC3_PARSE_ERROR_CRC;
  1481.             }
  1482.         }
  1483.     }
  1484.  
  1485.     /* if frame is ok, set audio parameters */
  1486.     if (!err) {
  1487.         avctx->sample_rate = s->sample_rate;
  1488.         avctx->bit_rate    = s->bit_rate;
  1489.     }
  1490.  
  1491.     /* channel config */
  1492.     if (!err || (s->channels && s->out_channels != s->channels)) {
  1493.         s->out_channels = s->channels;
  1494.         s->output_mode  = s->channel_mode;
  1495.         if (s->lfe_on)
  1496.             s->output_mode |= AC3_OUTPUT_LFEON;
  1497.         if (s->channels > 1 &&
  1498.             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
  1499.             s->out_channels = 1;
  1500.             s->output_mode  = AC3_CHMODE_MONO;
  1501.         } else if (s->channels > 2 &&
  1502.                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
  1503.             s->out_channels = 2;
  1504.             s->output_mode  = AC3_CHMODE_STEREO;
  1505.         }
  1506.  
  1507.         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
  1508.         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
  1509.         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
  1510.         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
  1511.         /* set downmixing coefficients if needed */
  1512.         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
  1513.                 s->fbw_channels == s->out_channels)) {
  1514.             set_downmix_coeffs(s);
  1515.         }
  1516.     } else if (!s->channels) {
  1517.         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
  1518.         return AVERROR_INVALIDDATA;
  1519.     }
  1520.     avctx->channels = s->out_channels;
  1521.     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
  1522.     if (s->output_mode & AC3_OUTPUT_LFEON)
  1523.         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
  1524.  
  1525.     /* set audio service type based on bitstream mode for AC-3 */
  1526.     avctx->audio_service_type = s->bitstream_mode;
  1527.     if (s->bitstream_mode == 0x7 && s->channels > 1)
  1528.         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
  1529.  
  1530.     /* get output buffer */
  1531.     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
  1532.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
  1533.         return ret;
  1534.  
  1535.     /* decode the audio blocks */
  1536.     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
  1537.     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
  1538.         output[ch] = s->output[ch];
  1539.         s->outptr[ch] = s->output[ch];
  1540.     }
  1541.     for (ch = 0; ch < s->channels; ch++) {
  1542.         if (ch < s->out_channels)
  1543.             s->outptr[channel_map[ch]] = (SHORTFLOAT *)frame->data[ch];
  1544.     }
  1545.     for (blk = 0; blk < s->num_blocks; blk++) {
  1546.         if (!err && decode_audio_block(s, blk)) {
  1547.             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
  1548.             err = 1;
  1549.         }
  1550.         if (err)
  1551.             for (ch = 0; ch < s->out_channels; ch++)
  1552.                 memcpy(((SHORTFLOAT*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
  1553.         for (ch = 0; ch < s->out_channels; ch++)
  1554.             output[ch] = s->outptr[channel_map[ch]];
  1555.         for (ch = 0; ch < s->out_channels; ch++) {
  1556.             if (!ch || channel_map[ch])
  1557.                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
  1558.         }
  1559.     }
  1560.  
  1561.     av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
  1562.  
  1563.     /* keep last block for error concealment in next frame */
  1564.     for (ch = 0; ch < s->out_channels; ch++)
  1565.         memcpy(s->output[ch], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT));
  1566.  
  1567.     /*
  1568.      * AVMatrixEncoding
  1569.      *
  1570.      * Check whether the input layout is compatible, and make sure we're not
  1571.      * downmixing (else the matrix encoding is no longer applicable).
  1572.      */
  1573.     matrix_encoding = AV_MATRIX_ENCODING_NONE;
  1574.     if (s->channel_mode == AC3_CHMODE_STEREO &&
  1575.         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
  1576.         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
  1577.             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
  1578.         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
  1579.             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
  1580.     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
  1581.                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
  1582.         switch (s->dolby_surround_ex_mode) {
  1583.         case AC3_DSUREXMOD_ON: // EX or PLIIx
  1584.             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
  1585.             break;
  1586.         case AC3_DSUREXMOD_PLIIZ:
  1587.             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
  1588.             break;
  1589.         default: // not indicated or off
  1590.             break;
  1591.         }
  1592.     }
  1593.     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
  1594.         return ret;
  1595.  
  1596.     /* AVDownmixInfo */
  1597.     if ((downmix_info = av_downmix_info_update_side_data(frame))) {
  1598.         switch (s->preferred_downmix) {
  1599.         case AC3_DMIXMOD_LTRT:
  1600.             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT;
  1601.             break;
  1602.         case AC3_DMIXMOD_LORO:
  1603.             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO;
  1604.             break;
  1605.         case AC3_DMIXMOD_DPLII:
  1606.             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII;
  1607.             break;
  1608.         default:
  1609.             downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN;
  1610.             break;
  1611.         }
  1612.         downmix_info->center_mix_level        = gain_levels[s->       center_mix_level];
  1613.         downmix_info->center_mix_level_ltrt   = gain_levels[s->  center_mix_level_ltrt];
  1614.         downmix_info->surround_mix_level      = gain_levels[s->     surround_mix_level];
  1615.         downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt];
  1616.         if (s->lfe_mix_level_exists)
  1617.             downmix_info->lfe_mix_level       = gain_levels_lfe[s->lfe_mix_level];
  1618.         else
  1619.             downmix_info->lfe_mix_level       = 0.0; // -inf dB
  1620.     } else
  1621.         return AVERROR(ENOMEM);
  1622.  
  1623.     *got_frame_ptr = 1;
  1624.  
  1625.     return FFMIN(buf_size, s->frame_size);
  1626. }
  1627.  
  1628. /**
  1629.  * Uninitialize the AC-3 decoder.
  1630.  */
  1631. static av_cold int ac3_decode_end(AVCodecContext *avctx)
  1632. {
  1633.     AC3DecodeContext *s = avctx->priv_data;
  1634.     ff_mdct_end(&s->imdct_512);
  1635.     ff_mdct_end(&s->imdct_256);
  1636.     av_freep(&s->fdsp);
  1637.  
  1638.     return 0;
  1639. }
  1640.  
  1641. #define OFFSET(x) offsetof(AC3DecodeContext, x)
  1642. #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
  1643.