falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
12784 Commits
32 Branches
303MB
Tree: 8541cc274c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8541cc274c'
${ noResults }
FFmpeg/libavcodec/ac3dec.c

1166 lines
40KB
Raw Blame History 

  1. /*

  2.  * AC-3 Audio Decoder

  3.  * This code is developed as part of Google Summer of Code 2006 Program.

  4.  *

  5.  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).

  6.  * Copyright (c) 2007 Justin Ruggles

  7.  *

  8.  * Portions of this code are derived from liba52

  9.  * http://liba52.sourceforge.net

  10.  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>

  11.  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>

  12.  *

  13.  * This file is part of FFmpeg.

  14.  *

  15.  * FFmpeg is free software; you can redistribute it and/or

  16.  * modify it under the terms of the GNU General Public

  17.  * License as published by the Free Software Foundation; either

  18.  * version 2 of the License, or (at your option) any later version.

  19.  *

  20.  * FFmpeg is distributed in the hope that it will be useful,

  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  23.  * General Public License for more details.

  24.  *

  25.  * You should have received a copy of the GNU General Public

  26.  * License along with FFmpeg; if not, write to the Free Software

  27.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  28.  */

  29. 

  30. #include <stdio.h>

  31. #include <stddef.h>

  32. #include <math.h>

  33. #include <string.h>

  34. 

  35. #include "avcodec.h"

  36. #include "ac3_parser.h"

  37. #include "bitstream.h"

  38. #include "crc.h"

  39. #include "dsputil.h"

  40. #include "random.h"

  41. 

  42. /**

  43.  * Table of bin locations for rematrixing bands

  44.  * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions

  45.  */

  46. static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 };

  47. 

  48. /** table for grouping exponents */

  49. static uint8_t exp_ungroup_tab[128][3];

  50. 

  51. 

  52. /** tables for ungrouping mantissas */

  53. static int b1_mantissas[32][3];

  54. static int b2_mantissas[128][3];

  55. static int b3_mantissas[8];

  56. static int b4_mantissas[128][2];

  57. static int b5_mantissas[16];

  58. 

  59. /**

  60.  * Quantization table: levels for symmetric. bits for asymmetric.

  61.  * reference: Table 7.18 Mapping of bap to Quantizer

  62.  */

  63. static const uint8_t quantization_tab[16] = {

  64.     0, 3, 5, 7, 11, 15,

  65.     5, 6, 7, 8, 9, 10, 11, 12, 14, 16

  66. };

  67. 

  68. /** dynamic range table. converts codes to scale factors. */

  69. static float dynamic_range_tab[256];

  70. 

  71. /** Adjustments in dB gain */

  72. #define LEVEL_MINUS_3DB         0.7071067811865476

  73. #define LEVEL_MINUS_4POINT5DB   0.5946035575013605

  74. #define LEVEL_MINUS_6DB         0.5000000000000000

  75. #define LEVEL_MINUS_9DB         0.3535533905932738

  76. #define LEVEL_ZERO              0.0000000000000000

  77. #define LEVEL_ONE               1.0000000000000000

  78. 

  79. static const float gain_levels[6] = {

  80.     LEVEL_ZERO,

  81.     LEVEL_ONE,

  82.     LEVEL_MINUS_3DB,

  83.     LEVEL_MINUS_4POINT5DB,

  84.     LEVEL_MINUS_6DB,

  85.     LEVEL_MINUS_9DB

  86. };

  87. 

  88. /**

  89.  * Table for center mix levels

  90.  * reference: Section 5.4.2.4 cmixlev

  91.  */

  92. static const uint8_t center_levels[4] = { 2, 3, 4, 3 };

  93. 

  94. /**

  95.  * Table for surround mix levels

  96.  * reference: Section 5.4.2.5 surmixlev

  97.  */

  98. static const uint8_t surround_levels[4] = { 2, 4, 0, 4 };

  99. 

  100. /**

  101.  * Table for default stereo downmixing coefficients

  102.  * reference: Section 7.8.2 Downmixing Into Two Channels

  103.  */

  104. static const uint8_t ac3_default_coeffs[8][5][2] = {

  105.     { { 1, 0 }, { 0, 1 },                               },

  106.     { { 2, 2 },                                         },

  107.     { { 1, 0 }, { 0, 1 },                               },

  108.     { { 1, 0 }, { 3, 3 }, { 0, 1 },                     },

  109.     { { 1, 0 }, { 0, 1 }, { 4, 4 },                     },

  110.     { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 },           },

  111.     { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 },           },

  112.     { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },

  113. };

  114. 

  115. /* override ac3.h to include coupling channel */

  116. #undef AC3_MAX_CHANNELS

  117. #define AC3_MAX_CHANNELS 7

  118. #define CPL_CH 0

  119. 

  120. #define AC3_OUTPUT_LFEON  8

  121. 

  122. typedef struct {

  123.     int channel_mode;                       ///< channel mode (acmod)

  124.     int block_switch[AC3_MAX_CHANNELS];     ///< block switch flags

  125.     int dither_flag[AC3_MAX_CHANNELS];      ///< dither flags

  126.     int dither_all;                         ///< true if all channels are dithered

  127.     int cpl_in_use;                         ///< coupling in use

  128.     int channel_in_cpl[AC3_MAX_CHANNELS];   ///< channel in coupling

  129.     int phase_flags_in_use;                 ///< phase flags in use

  130.     int phase_flags[18];                    ///< phase flags

  131.     int cpl_band_struct[18];                ///< coupling band structure

  132.     int num_rematrixing_bands;              ///< number of rematrixing bands

  133.     int rematrixing_flags[4];               ///< rematrixing flags

  134.     int exp_strategy[AC3_MAX_CHANNELS];     ///< exponent strategies

  135.     int snr_offset[AC3_MAX_CHANNELS];       ///< signal-to-noise ratio offsets

  136.     int fast_gain[AC3_MAX_CHANNELS];        ///< fast gain values (signal-to-mask ratio)

  137.     int dba_mode[AC3_MAX_CHANNELS];         ///< delta bit allocation mode

  138.     int dba_nsegs[AC3_MAX_CHANNELS];        ///< number of delta segments

  139.     uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets

  140.     uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths

  141.     uint8_t dba_values[AC3_MAX_CHANNELS][8];  ///< delta values for each segment

  142. 

  143.     int sample_rate;                        ///< sample frequency, in Hz

  144.     int bit_rate;                           ///< stream bit rate, in bits-per-second

  145.     int frame_size;                         ///< current frame size, in bytes

  146. 

  147.     int channels;                           ///< number of total channels

  148.     int fbw_channels;                       ///< number of full-bandwidth channels

  149.     int lfe_on;                             ///< lfe channel in use

  150.     int lfe_ch;                             ///< index of LFE channel

  151.     int output_mode;                        ///< output channel configuration

  152.     int out_channels;                       ///< number of output channels

  153. 

  154.     int center_mix_level;                   ///< Center mix level index

  155.     int surround_mix_level;                 ///< Surround mix level index

  156.     float downmix_coeffs[AC3_MAX_CHANNELS][2];  ///< stereo downmix coefficients

  157.     float dynamic_range[2];                 ///< dynamic range

  158.     int   cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates

  159.     int   num_cpl_bands;                    ///< number of coupling bands

  160.     int   num_cpl_subbands;                 ///< number of coupling sub bands

  161.     int   start_freq[AC3_MAX_CHANNELS];     ///< start frequency bin

  162.     int   end_freq[AC3_MAX_CHANNELS];       ///< end frequency bin

  163.     AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters

  164. 

  165.     int8_t  dexps[AC3_MAX_CHANNELS][256];   ///< decoded exponents

  166.     uint8_t bap[AC3_MAX_CHANNELS][256];     ///< bit allocation pointers

  167.     int16_t psd[AC3_MAX_CHANNELS][256];     ///< scaled exponents

  168.     int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents

  169.     int16_t mask[AC3_MAX_CHANNELS][50];     ///< masking curve values

  170. 

  171.     int fixed_coeffs[AC3_MAX_CHANNELS][256];    ///> fixed-point transform coefficients

  172.     DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]);  ///< transform coefficients

  173. 

  174.     /* For IMDCT. */

  175.     MDCTContext imdct_512;                  ///< for 512 sample IMDCT

  176.     MDCTContext imdct_256;                  ///< for 256 sample IMDCT

  177.     DSPContext  dsp;                        ///< for optimization

  178.     float       add_bias;                   ///< offset for float_to_int16 conversion

  179.     float       mul_bias;                   ///< scaling for float_to_int16 conversion

  180. 

  181.     DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS-1][256]);     ///< output after imdct transform and windowing

  182.     DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output

  183.     DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS-1][256]);      ///< delay - added to the next block

  184.     DECLARE_ALIGNED_16(float, tmp_imdct[256]);                      ///< temporary storage for imdct transform

  185.     DECLARE_ALIGNED_16(float, tmp_output[512]);                     ///< temporary storage for output before windowing

  186.     DECLARE_ALIGNED_16(float, window[256]);                         ///< window coefficients

  187. 

  188.     /* Miscellaneous. */

  189.     GetBitContext gbc;                      ///< bitstream reader

  190.     AVRandomState dith_state;               ///< for dither generation

  191.     AVCodecContext *avctx;                  ///< parent context

  192. } AC3DecodeContext;

  193. 

  194. /**

  195.  * Symmetrical Dequantization

  196.  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization

  197.  *            Tables 7.19 to 7.23

  198.  */

  199. static inline int

  200. symmetric_dequant(int code, int levels)

  201. {

  202.     return ((code - (levels >> 1)) << 24) / levels;

  203. }

  204. 

  205. /*

  206.  * Initialize tables at runtime.

  207.  */

  208. static void ac3_tables_init(void)

  209. {

  210.     int i;

  211. 

  212.     /* generate grouped mantissa tables

  213.        reference: Section 7.3.5 Ungrouping of Mantissas */

  214.     for(i=0; i<32; i++) {

  215.         /* bap=1 mantissas */

  216.         b1_mantissas[i][0] = symmetric_dequant( i / 9     , 3);

  217.         b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);

  218.         b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);

  219.     }

  220.     for(i=0; i<128; i++) {

  221.         /* bap=2 mantissas */

  222.         b2_mantissas[i][0] = symmetric_dequant( i / 25     , 5);

  223.         b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);

  224.         b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);

  225. 

  226.         /* bap=4 mantissas */

  227.         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);

  228.         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);

  229.     }

  230.     /* generate ungrouped mantissa tables

  231.        reference: Tables 7.21 and 7.23 */

  232.     for(i=0; i<7; i++) {

  233.         /* bap=3 mantissas */

  234.         b3_mantissas[i] = symmetric_dequant(i, 7);

  235.     }

  236.     for(i=0; i<15; i++) {

  237.         /* bap=5 mantissas */

  238.         b5_mantissas[i] = symmetric_dequant(i, 15);

  239.     }

  240. 

  241.     /* generate dynamic range table

  242.        reference: Section 7.7.1 Dynamic Range Control */

  243.     for(i=0; i<256; i++) {

  244.         int v = (i >> 5) - ((i >> 7) << 3) - 5;

  245.         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);

  246.     }

  247. 

  248.     /* generate exponent tables

  249.        reference: Section 7.1.3 Exponent Decoding */

  250.     for(i=0; i<128; i++) {

  251.         exp_ungroup_tab[i][0] =  i / 25;

  252.         exp_ungroup_tab[i][1] = (i % 25) / 5;

  253.         exp_ungroup_tab[i][2] = (i % 25) % 5;

  254.     }

  255. }

  256. 

  257. 

  258. /**

  259.  * AVCodec initialization

  260.  */

  261. static int ac3_decode_init(AVCodecContext *avctx)

  262. {

  263.     AC3DecodeContext *s = avctx->priv_data;

  264.     s->avctx = avctx;

  265. 

  266.     ac3_common_init();

  267.     ac3_tables_init();

  268.     ff_mdct_init(&s->imdct_256, 8, 1);

  269.     ff_mdct_init(&s->imdct_512, 9, 1);

  270.     ff_kbd_window_init(s->window, 5.0, 256);

  271.     dsputil_init(&s->dsp, avctx);

  272.     av_init_random(0, &s->dith_state);

  273. 

  274.     /* set bias values for float to int16 conversion */

  275.     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {

  276.         s->add_bias = 385.0f;

  277.         s->mul_bias = 1.0f;

  278.     } else {

  279.         s->add_bias = 0.0f;

  280.         s->mul_bias = 32767.0f;

  281.     }

  282. 

  283.     /* allow downmixing to stereo or mono */

  284.     if (avctx->channels > 0 && avctx->request_channels > 0 &&

  285.             avctx->request_channels < avctx->channels &&

  286.             avctx->request_channels <= 2) {

  287.         avctx->channels = avctx->request_channels;

  288.     }

  289. 

  290.     return 0;

  291. }

  292. 

  293. /**

  294.  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.

  295.  * GetBitContext within AC3DecodeContext must point to

  296.  * start of the synchronized ac3 bitstream.

  297.  */

  298. static int ac3_parse_header(AC3DecodeContext *s)

  299. {

  300.     AC3HeaderInfo hdr;

  301.     GetBitContext *gbc = &s->gbc;

  302.     int err, i;

  303. 

  304.     err = ff_ac3_parse_header(gbc->buffer, &hdr);

  305.     if(err)

  306.         return err;

  307. 

  308.     if(hdr.bitstream_id > 10)

  309.         return AC3_PARSE_ERROR_BSID;

  310. 

  311.     /* get decoding parameters from header info */

  312.     s->bit_alloc_params.sr_code     = hdr.sr_code;

  313.     s->channel_mode                 = hdr.channel_mode;

  314.     s->lfe_on                       = hdr.lfe_on;

  315.     s->bit_alloc_params.sr_shift    = hdr.sr_shift;

  316.     s->sample_rate                  = hdr.sample_rate;

  317.     s->bit_rate                     = hdr.bit_rate;

  318.     s->channels                     = hdr.channels;

  319.     s->fbw_channels                 = s->channels - s->lfe_on;

  320.     s->lfe_ch                       = s->fbw_channels + 1;

  321.     s->frame_size                   = hdr.frame_size;

  322. 

  323.     /* set default output to all source channels */

  324.     s->out_channels = s->channels;

  325.     s->output_mode = s->channel_mode;

  326.     if(s->lfe_on)

  327.         s->output_mode |= AC3_OUTPUT_LFEON;

  328. 

  329.     /* set default mix levels */

  330.     s->center_mix_level   = 3;  // -4.5dB

  331.     s->surround_mix_level = 4;  // -6.0dB

  332. 

  333.     /* skip over portion of header which has already been read */

  334.     skip_bits(gbc, 16); // skip the sync_word

  335.     skip_bits(gbc, 16); // skip crc1

  336.     skip_bits(gbc, 8);  // skip fscod and frmsizecod

  337.     skip_bits(gbc, 11); // skip bsid, bsmod, and acmod

  338.     if(s->channel_mode == AC3_CHMODE_STEREO) {

  339.         skip_bits(gbc, 2); // skip dsurmod

  340.     } else {

  341.         if((s->channel_mode & 1) && s->channel_mode != AC3_CHMODE_MONO)

  342.             s->center_mix_level = center_levels[get_bits(gbc, 2)];

  343.         if(s->channel_mode & 4)

  344.             s->surround_mix_level = surround_levels[get_bits(gbc, 2)];

  345.     }

  346.     skip_bits1(gbc); // skip lfeon

  347. 

  348.     /* read the rest of the bsi. read twice for dual mono mode. */

  349.     i = !(s->channel_mode);

  350.     do {

  351.         skip_bits(gbc, 5); // skip dialog normalization

  352.         if (get_bits1(gbc))

  353.             skip_bits(gbc, 8); //skip compression

  354.         if (get_bits1(gbc))

  355.             skip_bits(gbc, 8); //skip language code

  356.         if (get_bits1(gbc))

  357.             skip_bits(gbc, 7); //skip audio production information

  358.     } while (i--);

  359. 

  360.     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit

  361. 

  362.     /* skip the timecodes (or extra bitstream information for Alternate Syntax)

  363.        TODO: read & use the xbsi1 downmix levels */

  364.     if (get_bits1(gbc))

  365.         skip_bits(gbc, 14); //skip timecode1 / xbsi1

  366.     if (get_bits1(gbc))

  367.         skip_bits(gbc, 14); //skip timecode2 / xbsi2

  368. 

  369.     /* skip additional bitstream info */

  370.     if (get_bits1(gbc)) {

  371.         i = get_bits(gbc, 6);

  372.         do {

  373.             skip_bits(gbc, 8);

  374.         } while(i--);

  375.     }

  376. 

  377.     return 0;

  378. }

  379. 

  380. /**

  381.  * Set stereo downmixing coefficients based on frame header info.

  382.  * reference: Section 7.8.2 Downmixing Into Two Channels

  383.  */

  384. static void set_downmix_coeffs(AC3DecodeContext *s)

  385. {

  386.     int i;

  387.     float cmix = gain_levels[s->center_mix_level];

  388.     float smix = gain_levels[s->surround_mix_level];

  389. 

  390.     for(i=0; i<s->fbw_channels; i++) {

  391.         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];

  392.         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];

  393.     }

  394.     if(s->channel_mode > 1 && s->channel_mode & 1) {

  395.         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;

  396.     }

  397.     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {

  398.         int nf = s->channel_mode - 2;

  399.         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;

  400.     }

  401.     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {

  402.         int nf = s->channel_mode - 4;

  403.         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;

  404.     }

  405. }

  406. 

  407. /**

  408.  * Decode the grouped exponents according to exponent strategy.

  409.  * reference: Section 7.1.3 Exponent Decoding

  410.  */

  411. static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,

  412.                              uint8_t absexp, int8_t *dexps)

  413. {

  414.     int i, j, grp, group_size;

  415.     int dexp[256];

  416.     int expacc, prevexp;

  417. 

  418.     /* unpack groups */

  419.     group_size = exp_strategy + (exp_strategy == EXP_D45);

  420.     for(grp=0,i=0; grp<ngrps; grp++) {

  421.         expacc = get_bits(gbc, 7);

  422.         dexp[i++] = exp_ungroup_tab[expacc][0];

  423.         dexp[i++] = exp_ungroup_tab[expacc][1];

  424.         dexp[i++] = exp_ungroup_tab[expacc][2];

  425.     }

  426. 

  427.     /* convert to absolute exps and expand groups */

  428.     prevexp = absexp;

  429.     for(i=0; i<ngrps*3; i++) {

  430.         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);

  431.         for(j=0; j<group_size; j++) {

  432.             dexps[(i*group_size)+j] = prevexp;

  433.         }

  434.     }

  435. }

  436. 

  437. /**

  438.  * Generate transform coefficients for each coupled channel in the coupling

  439.  * range using the coupling coefficients and coupling coordinates.

  440.  * reference: Section 7.4.3 Coupling Coordinate Format

  441.  */

  442. static void uncouple_channels(AC3DecodeContext *s)

  443. {

  444.     int i, j, ch, bnd, subbnd;

  445. 

  446.     subbnd = -1;

  447.     i = s->start_freq[CPL_CH];

  448.     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {

  449.         do {

  450.             subbnd++;

  451.             for(j=0; j<12; j++) {

  452.                 for(ch=1; ch<=s->fbw_channels; ch++) {

  453.                     if(s->channel_in_cpl[ch]) {

  454.                         s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;

  455.                         if (ch == 2 && s->phase_flags[bnd])

  456.                             s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];

  457.                     }

  458.                 }

  459.                 i++;

  460.             }

  461.         } while(s->cpl_band_struct[subbnd]);

  462.     }

  463. }

  464. 

  465. /**

  466.  * Grouped mantissas for 3-level 5-level and 11-level quantization

  467.  */

  468. typedef struct {

  469.     int b1_mant[3];

  470.     int b2_mant[3];

  471.     int b4_mant[2];

  472.     int b1ptr;

  473.     int b2ptr;

  474.     int b4ptr;

  475. } mant_groups;

  476. 

  477. /**

  478.  * Get the transform coefficients for a particular channel

  479.  * reference: Section 7.3 Quantization and Decoding of Mantissas

  480.  */

  481. static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)

  482. {

  483.     GetBitContext *gbc = &s->gbc;

  484.     int i, gcode, tbap, start, end;

  485.     uint8_t *exps;

  486.     uint8_t *bap;

  487.     int *coeffs;

  488. 

  489.     exps = s->dexps[ch_index];

  490.     bap = s->bap[ch_index];

  491.     coeffs = s->fixed_coeffs[ch_index];

  492.     start = s->start_freq[ch_index];

  493.     end = s->end_freq[ch_index];

  494. 

  495.     for (i = start; i < end; i++) {

  496.         tbap = bap[i];

  497.         switch (tbap) {

  498.             case 0:

  499.                 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 4194304;

  500.                 break;

  501. 

  502.             case 1:

  503.                 if(m->b1ptr > 2) {

  504.                     gcode = get_bits(gbc, 5);

  505.                     m->b1_mant[0] = b1_mantissas[gcode][0];

  506.                     m->b1_mant[1] = b1_mantissas[gcode][1];

  507.                     m->b1_mant[2] = b1_mantissas[gcode][2];

  508.                     m->b1ptr = 0;

  509.                 }

  510.                 coeffs[i] = m->b1_mant[m->b1ptr++];

  511.                 break;

  512. 

  513.             case 2:

  514.                 if(m->b2ptr > 2) {

  515.                     gcode = get_bits(gbc, 7);

  516.                     m->b2_mant[0] = b2_mantissas[gcode][0];

  517.                     m->b2_mant[1] = b2_mantissas[gcode][1];

  518.                     m->b2_mant[2] = b2_mantissas[gcode][2];

  519.                     m->b2ptr = 0;

  520.                 }

  521.                 coeffs[i] = m->b2_mant[m->b2ptr++];

  522.                 break;

  523. 

  524.             case 3:

  525.                 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];

  526.                 break;

  527. 

  528.             case 4:

  529.                 if(m->b4ptr > 1) {

  530.                     gcode = get_bits(gbc, 7);

  531.                     m->b4_mant[0] = b4_mantissas[gcode][0];

  532.                     m->b4_mant[1] = b4_mantissas[gcode][1];

  533.                     m->b4ptr = 0;

  534.                 }

  535.                 coeffs[i] = m->b4_mant[m->b4ptr++];

  536.                 break;

  537. 

  538.             case 5:

  539.                 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];

  540.                 break;

  541. 

  542.             default: {

  543.                 /* asymmetric dequantization */

  544.                 int qlevel = quantization_tab[tbap];

  545.                 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);

  546.                 break;

  547.             }

  548.         }

  549.         coeffs[i] >>= exps[i];

  550.     }

  551. 

  552.     return 0;

  553. }

  554. 

  555. /**

  556.  * Remove random dithering from coefficients with zero-bit mantissas

  557.  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)

  558.  */

  559. static void remove_dithering(AC3DecodeContext *s) {

  560.     int ch, i;

  561.     int end=0;

  562.     int *coeffs;

  563.     uint8_t *bap;

  564. 

  565.     for(ch=1; ch<=s->fbw_channels; ch++) {

  566.         if(!s->dither_flag[ch]) {

  567.             coeffs = s->fixed_coeffs[ch];

  568.             bap = s->bap[ch];

  569.             if(s->channel_in_cpl[ch])

  570.                 end = s->start_freq[CPL_CH];

  571.             else

  572.                 end = s->end_freq[ch];

  573.             for(i=0; i<end; i++) {

  574.                 if(!bap[i])

  575.                     coeffs[i] = 0;

  576.             }

  577.             if(s->channel_in_cpl[ch]) {

  578.                 bap = s->bap[CPL_CH];

  579.                 for(; i<s->end_freq[CPL_CH]; i++) {

  580.                     if(!bap[i])

  581.                         coeffs[i] = 0;

  582.                 }

  583.             }

  584.         }

  585.     }

  586. }

  587. 

  588. /**

  589.  * Get the transform coefficients.

  590.  */

  591. static int get_transform_coeffs(AC3DecodeContext *s)

  592. {

  593.     int ch, end;

  594.     int got_cplchan = 0;

  595.     mant_groups m;

  596. 

  597.     m.b1ptr = m.b2ptr = m.b4ptr = 3;

  598. 

  599.     for (ch = 1; ch <= s->channels; ch++) {

  600.         /* transform coefficients for full-bandwidth channel */

  601.         if (get_transform_coeffs_ch(s, ch, &m))

  602.             return -1;

  603.         /* tranform coefficients for coupling channel come right after the

  604.            coefficients for the first coupled channel*/

  605.         if (s->channel_in_cpl[ch])  {

  606.             if (!got_cplchan) {

  607.                 if (get_transform_coeffs_ch(s, CPL_CH, &m)) {

  608.                     av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n");

  609.                     return -1;

  610.                 }

  611.                 uncouple_channels(s);

  612.                 got_cplchan = 1;

  613.             }

  614.             end = s->end_freq[CPL_CH];

  615.         } else {

  616.             end = s->end_freq[ch];

  617.         }

  618.         do

  619.             s->transform_coeffs[ch][end] = 0;

  620.         while(++end < 256);

  621.     }

  622. 

  623.     /* if any channel doesn't use dithering, zero appropriate coefficients */

  624.     if(!s->dither_all)

  625.         remove_dithering(s);

  626. 

  627.     return 0;

  628. }

  629. 

  630. /**

  631.  * Stereo rematrixing.

  632.  * reference: Section 7.5.4 Rematrixing : Decoding Technique

  633.  */

  634. static void do_rematrixing(AC3DecodeContext *s)

  635. {

  636.     int bnd, i;

  637.     int end, bndend;

  638.     int tmp0, tmp1;

  639. 

  640.     end = FFMIN(s->end_freq[1], s->end_freq[2]);

  641. 

  642.     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {

  643.         if(s->rematrixing_flags[bnd]) {

  644.             bndend = FFMIN(end, rematrix_band_tab[bnd+1]);

  645.             for(i=rematrix_band_tab[bnd]; i<bndend; i++) {

  646.                 tmp0 = s->fixed_coeffs[1][i];

  647.                 tmp1 = s->fixed_coeffs[2][i];

  648.                 s->fixed_coeffs[1][i] = tmp0 + tmp1;

  649.                 s->fixed_coeffs[2][i] = tmp0 - tmp1;

  650.             }

  651.         }

  652.     }

  653. }

  654. 

  655. /**

  656.  * Perform the 256-point IMDCT

  657.  */

  658. static void do_imdct_256(AC3DecodeContext *s, int chindex)

  659. {

  660.     int i, k;

  661.     DECLARE_ALIGNED_16(float, x[128]);

  662.     FFTComplex z[2][64];

  663.     float *o_ptr = s->tmp_output;

  664. 

  665.     for(i=0; i<2; i++) {

  666.         /* de-interleave coefficients */

  667.         for(k=0; k<128; k++) {

  668.             x[k] = s->transform_coeffs[chindex][2*k+i];

  669.         }

  670. 

  671.         /* run standard IMDCT */

  672.         s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);

  673. 

  674.         /* reverse the post-rotation & reordering from standard IMDCT */

  675.         for(k=0; k<32; k++) {

  676.             z[i][32+k].re = -o_ptr[128+2*k];

  677.             z[i][32+k].im = -o_ptr[2*k];

  678.             z[i][31-k].re =  o_ptr[2*k+1];

  679.             z[i][31-k].im =  o_ptr[128+2*k+1];

  680.         }

  681.     }

  682. 

  683.     /* apply AC-3 post-rotation & reordering */

  684.     for(k=0; k<64; k++) {

  685.         o_ptr[    2*k  ] = -z[0][   k].im;

  686.         o_ptr[    2*k+1] =  z[0][63-k].re;

  687.         o_ptr[128+2*k  ] = -z[0][   k].re;

  688.         o_ptr[128+2*k+1] =  z[0][63-k].im;

  689.         o_ptr[256+2*k  ] = -z[1][   k].re;

  690.         o_ptr[256+2*k+1] =  z[1][63-k].im;

  691.         o_ptr[384+2*k  ] =  z[1][   k].im;

  692.         o_ptr[384+2*k+1] = -z[1][63-k].re;

  693.     }

  694. }

  695. 

  696. /**

  697.  * Inverse MDCT Transform.

  698.  * Convert frequency domain coefficients to time-domain audio samples.

  699.  * reference: Section 7.9.4 Transformation Equations

  700.  */

  701. static inline void do_imdct(AC3DecodeContext *s)

  702. {

  703.     int ch;

  704.     int channels;

  705. 

  706.     /* Don't perform the IMDCT on the LFE channel unless it's used in the output */

  707.     channels = s->fbw_channels;

  708.     if(s->output_mode & AC3_OUTPUT_LFEON)

  709.         channels++;

  710. 

  711.     for (ch=1; ch<=channels; ch++) {

  712.         if (s->block_switch[ch]) {

  713.             do_imdct_256(s, ch);

  714.         } else {

  715.             s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,

  716.                                         s->transform_coeffs[ch], s->tmp_imdct);

  717.         }

  718.         /* For the first half of the block, apply the window, add the delay

  719.            from the previous block, and send to output */

  720.         s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,

  721.                                      s->window, s->delay[ch-1], 0, 256, 1);

  722.         /* For the second half of the block, apply the window and store the

  723.            samples to delay, to be combined with the next block */

  724.         s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,

  725.                                    s->window, 256);

  726.     }

  727. }

  728. 

  729. /**

  730.  * Downmix the output to mono or stereo.

  731.  */

  732. static void ac3_downmix(AC3DecodeContext *s)

  733. {

  734.     int i, j;

  735.     float v0, v1, s0, s1;

  736. 

  737.     for(i=0; i<256; i++) {

  738.         v0 = v1 = s0 = s1 = 0.0f;

  739.         for(j=0; j<s->fbw_channels; j++) {

  740.             v0 += s->output[j][i] * s->downmix_coeffs[j][0];

  741.             v1 += s->output[j][i] * s->downmix_coeffs[j][1];

  742.             s0 += s->downmix_coeffs[j][0];

  743.             s1 += s->downmix_coeffs[j][1];

  744.         }

  745.         v0 /= s0;

  746.         v1 /= s1;

  747.         if(s->output_mode == AC3_CHMODE_MONO) {

  748.             s->output[0][i] = (v0 + v1) * LEVEL_MINUS_3DB;

  749.         } else if(s->output_mode == AC3_CHMODE_STEREO) {

  750.             s->output[0][i] = v0;

  751.             s->output[1][i] = v1;

  752.         }

  753.     }

  754. }

  755. 

  756. /**

  757.  * Parse an audio block from AC-3 bitstream.

  758.  */

  759. static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)

  760. {

  761.     int fbw_channels = s->fbw_channels;

  762.     int channel_mode = s->channel_mode;

  763.     int i, bnd, seg, ch;

  764.     GetBitContext *gbc = &s->gbc;

  765.     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];

  766. 

  767.     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

  768. 

  769.     /* block switch flags */

  770.     for (ch = 1; ch <= fbw_channels; ch++)

  771.         s->block_switch[ch] = get_bits1(gbc);

  772. 

  773.     /* dithering flags */

  774.     s->dither_all = 1;

  775.     for (ch = 1; ch <= fbw_channels; ch++) {

  776.         s->dither_flag[ch] = get_bits1(gbc);

  777.         if(!s->dither_flag[ch])

  778.             s->dither_all = 0;

  779.     }

  780. 

  781.     /* dynamic range */

  782.     i = !(s->channel_mode);

  783.     do {

  784.         if(get_bits1(gbc)) {

  785.             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *

  786.                                   s->avctx->drc_scale)+1.0;

  787.         } else if(blk == 0) {

  788.             s->dynamic_range[i] = 1.0f;

  789.         }

  790.     } while(i--);

  791. 

  792.     /* coupling strategy */

  793.     if (get_bits1(gbc)) {

  794.         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

  795.         s->cpl_in_use = get_bits1(gbc);

  796.         if (s->cpl_in_use) {

  797.             /* coupling in use */

  798.             int cpl_begin_freq, cpl_end_freq;

  799. 

  800.             /* determine which channels are coupled */

  801.             for (ch = 1; ch <= fbw_channels; ch++)

  802.                 s->channel_in_cpl[ch] = get_bits1(gbc);

  803. 

  804.             /* phase flags in use */

  805.             if (channel_mode == AC3_CHMODE_STEREO)

  806.                 s->phase_flags_in_use = get_bits1(gbc);

  807. 

  808.             /* coupling frequency range and band structure */

  809.             cpl_begin_freq = get_bits(gbc, 4);

  810.             cpl_end_freq = get_bits(gbc, 4);

  811.             if (3 + cpl_end_freq - cpl_begin_freq < 0) {

  812.                 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);

  813.                 return -1;

  814.             }

  815.             s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;

  816.             s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;

  817.             s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;

  818.             for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {

  819.                 if (get_bits1(gbc)) {

  820.                     s->cpl_band_struct[bnd] = 1;

  821.                     s->num_cpl_bands--;

  822.                 }

  823.             }

  824.             s->cpl_band_struct[s->num_cpl_subbands-1] = 0;

  825.         } else {

  826.             /* coupling not in use */

  827.             for (ch = 1; ch <= fbw_channels; ch++)

  828.                 s->channel_in_cpl[ch] = 0;

  829.         }

  830.     }

  831. 

  832.     /* coupling coordinates */

  833.     if (s->cpl_in_use) {

  834.         int cpl_coords_exist = 0;

  835. 

  836.         for (ch = 1; ch <= fbw_channels; ch++) {

  837.             if (s->channel_in_cpl[ch]) {

  838.                 if (get_bits1(gbc)) {

  839.                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;

  840.                     cpl_coords_exist = 1;

  841.                     master_cpl_coord = 3 * get_bits(gbc, 2);

  842.                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

  843.                         cpl_coord_exp = get_bits(gbc, 4);

  844.                         cpl_coord_mant = get_bits(gbc, 4);

  845.                         if (cpl_coord_exp == 15)

  846.                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;

  847.                         else

  848.                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;

  849.                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);

  850.                     }

  851.                 }

  852.             }

  853.         }

  854.         /* phase flags */

  855.         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {

  856.             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

  857.                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;

  858.             }

  859.         }

  860.     }

  861. 

  862.     /* stereo rematrixing strategy and band structure */

  863.     if (channel_mode == AC3_CHMODE_STEREO) {

  864.         if (get_bits1(gbc)) {

  865.             s->num_rematrixing_bands = 4;

  866.             if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)

  867.                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);

  868.             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)

  869.                 s->rematrixing_flags[bnd] = get_bits1(gbc);

  870.         }

  871.     }

  872. 

  873.     /* exponent strategies for each channel */

  874.     s->exp_strategy[CPL_CH] = EXP_REUSE;

  875.     s->exp_strategy[s->lfe_ch] = EXP_REUSE;

  876.     for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {

  877.         if(ch == s->lfe_ch)

  878.             s->exp_strategy[ch] = get_bits(gbc, 1);

  879.         else

  880.             s->exp_strategy[ch] = get_bits(gbc, 2);

  881.         if(s->exp_strategy[ch] != EXP_REUSE)

  882.             bit_alloc_stages[ch] = 3;

  883.     }

  884. 

  885.     /* channel bandwidth */

  886.     for (ch = 1; ch <= fbw_channels; ch++) {

  887.         s->start_freq[ch] = 0;

  888.         if (s->exp_strategy[ch] != EXP_REUSE) {

  889.             int prev = s->end_freq[ch];

  890.             if (s->channel_in_cpl[ch])

  891.                 s->end_freq[ch] = s->start_freq[CPL_CH];

  892.             else {

  893.                 int bandwidth_code = get_bits(gbc, 6);

  894.                 if (bandwidth_code > 60) {

  895.                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);

  896.                     return -1;

  897.                 }

  898.                 s->end_freq[ch] = bandwidth_code * 3 + 73;

  899.             }

  900.             if(blk > 0 && s->end_freq[ch] != prev)

  901.                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

  902.         }

  903.     }

  904.     s->start_freq[s->lfe_ch] = 0;

  905.     s->end_freq[s->lfe_ch] = 7;

  906. 

  907.     /* decode exponents for each channel */

  908.     for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {

  909.         if (s->exp_strategy[ch] != EXP_REUSE) {

  910.             int group_size, num_groups;

  911.             group_size = 3 << (s->exp_strategy[ch] - 1);

  912.             if(ch == CPL_CH)

  913.                 num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;

  914.             else if(ch == s->lfe_ch)

  915.                 num_groups = 2;

  916.             else

  917.                 num_groups = (s->end_freq[ch] + group_size - 4) / group_size;

  918.             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;

  919.             decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],

  920.                              &s->dexps[ch][s->start_freq[ch]+!!ch]);

  921.             if(ch != CPL_CH && ch != s->lfe_ch)

  922.                 skip_bits(gbc, 2); /* skip gainrng */

  923.         }

  924.     }

  925. 

  926.     /* bit allocation information */

  927.     if (get_bits1(gbc)) {

  928.         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;

  929.         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;

  930.         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];

  931.         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];

  932.         s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];

  933.         for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {

  934.             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

  935.         }

  936.     }

  937. 

  938.     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */

  939.     if (get_bits1(gbc)) {

  940.         int csnr;

  941.         csnr = (get_bits(gbc, 6) - 15) << 4;

  942.         for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */

  943.             s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;

  944.             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];

  945.         }

  946.         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

  947.     }

  948. 

  949.     /* coupling leak information */

  950.     if (s->cpl_in_use && get_bits1(gbc)) {

  951.         s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);

  952.         s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);

  953.         bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);

  954.     }

  955. 

  956.     /* delta bit allocation information */

  957.     if (get_bits1(gbc)) {

  958.         /* delta bit allocation exists (strategy) */

  959.         for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {

  960.             s->dba_mode[ch] = get_bits(gbc, 2);

  961.             if (s->dba_mode[ch] == DBA_RESERVED) {

  962.                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");

  963.                 return -1;

  964.             }

  965.             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

  966.         }

  967.         /* channel delta offset, len and bit allocation */

  968.         for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {

  969.             if (s->dba_mode[ch] == DBA_NEW) {

  970.                 s->dba_nsegs[ch] = get_bits(gbc, 3);

  971.                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {

  972.                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);

  973.                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);

  974.                     s->dba_values[ch][seg] = get_bits(gbc, 3);

  975.                 }

  976.             }

  977.         }

  978.     } else if(blk == 0) {

  979.         for(ch=0; ch<=s->channels; ch++) {

  980.             s->dba_mode[ch] = DBA_NONE;

  981.         }

  982.     }

  983. 

  984.     /* Bit allocation */

  985.     for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {

  986.         if(bit_alloc_stages[ch] > 2) {

  987.             /* Exponent mapping into PSD and PSD integration */

  988.             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],

  989.                                       s->start_freq[ch], s->end_freq[ch],

  990.                                       s->psd[ch], s->band_psd[ch]);

  991.         }

  992.         if(bit_alloc_stages[ch] > 1) {

  993.             /* Compute excitation function, Compute masking curve, and

  994.                Apply delta bit allocation */

  995.             ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],

  996.                                        s->start_freq[ch], s->end_freq[ch],

  997.                                        s->fast_gain[ch], (ch == s->lfe_ch),

  998.                                        s->dba_mode[ch], s->dba_nsegs[ch],

  999.                                        s->dba_offsets[ch], s->dba_lengths[ch],

  1000.                                        s->dba_values[ch], s->mask[ch]);

  1001.         }

  1002.         if(bit_alloc_stages[ch] > 0) {

  1003.             /* Compute bit allocation */

  1004.             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],

  1005.                                       s->start_freq[ch], s->end_freq[ch],

  1006.                                       s->snr_offset[ch],

  1007.                                       s->bit_alloc_params.floor,

  1008.                                       s->bap[ch]);

  1009.         }

  1010.     }

  1011. 

  1012.     /* unused dummy data */

  1013.     if (get_bits1(gbc)) {

  1014.         int skipl = get_bits(gbc, 9);

  1015.         while(skipl--)

  1016.             skip_bits(gbc, 8);

  1017.     }

  1018. 

  1019.     /* unpack the transform coefficients

  1020.        this also uncouples channels if coupling is in use. */

  1021.     if (get_transform_coeffs(s)) {

  1022.         av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");

  1023.         return -1;

  1024.     }

  1025. 

  1026.     /* recover coefficients if rematrixing is in use */

  1027.     if(s->channel_mode == AC3_CHMODE_STEREO)

  1028.         do_rematrixing(s);

  1029. 

  1030.     /* apply scaling to coefficients (headroom, dynrng) */

  1031.     for(ch=1; ch<=s->channels; ch++) {

  1032.         float gain = s->mul_bias / 4194304.0f;

  1033.         if(s->channel_mode == AC3_CHMODE_DUALMONO) {

  1034.             gain *= s->dynamic_range[ch-1];

  1035.         } else {

  1036.             gain *= s->dynamic_range[0];

  1037.         }

  1038.         for(i=0; i<256; i++) {

  1039.             s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;

  1040.         }

  1041.     }

  1042. 

  1043.     do_imdct(s);

  1044. 

  1045.     /* downmix output if needed */

  1046.     if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&

  1047.             s->fbw_channels == s->out_channels)) {

  1048.         ac3_downmix(s);

  1049.     }

  1050. 

  1051.     /* convert float to 16-bit integer */

  1052.     for(ch=0; ch<s->out_channels; ch++) {

  1053.         for(i=0; i<256; i++) {

  1054.             s->output[ch][i] += s->add_bias;

  1055.         }

  1056.         s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);

  1057.     }

  1058. 

  1059.     return 0;

  1060. }

  1061. 

  1062. /**

  1063.  * Decode a single AC-3 frame.

  1064.  */

  1065. static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size)

  1066. {

  1067.     AC3DecodeContext *s = avctx->priv_data;

  1068.     int16_t *out_samples = (int16_t *)data;

  1069.     int i, blk, ch, err;

  1070. 

  1071.     /* initialize the GetBitContext with the start of valid AC-3 Frame */

  1072.     init_get_bits(&s->gbc, buf, buf_size * 8);

  1073. 

  1074.     /* parse the syncinfo */

  1075.     err = ac3_parse_header(s);

  1076.     if(err) {

  1077.         switch(err) {

  1078.             case AC3_PARSE_ERROR_SYNC:

  1079.                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");

  1080.                 break;

  1081.             case AC3_PARSE_ERROR_BSID:

  1082.                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");

  1083.                 break;

  1084.             case AC3_PARSE_ERROR_SAMPLE_RATE:

  1085.                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");

  1086.                 break;

  1087.             case AC3_PARSE_ERROR_FRAME_SIZE:

  1088.                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");

  1089.                 break;

  1090.             default:

  1091.                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");

  1092.                 break;

  1093.         }

  1094.         return -1;

  1095.     }

  1096. 

  1097.     /* check that reported frame size fits in input buffer */

  1098.     if(s->frame_size > buf_size) {

  1099.         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");

  1100.         return -1;

  1101.     }

  1102. 

  1103.     /* check for crc mismatch */

  1104.     if(avctx->error_resilience >= FF_ER_CAREFUL) {

  1105.         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {

  1106.             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");

  1107.             return -1;

  1108.         }

  1109.         /* TODO: error concealment */

  1110.     }

  1111. 

  1112.     avctx->sample_rate = s->sample_rate;

  1113.     avctx->bit_rate = s->bit_rate;

  1114. 

  1115.     /* channel config */

  1116.     s->out_channels = s->channels;

  1117.     if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&

  1118.             avctx->request_channels < s->channels) {

  1119.         s->out_channels = avctx->request_channels;

  1120.         s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;

  1121.     }

  1122.     avctx->channels = s->out_channels;

  1123. 

  1124.     /* set downmixing coefficients if needed */

  1125.     if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&

  1126.             s->fbw_channels == s->out_channels)) {

  1127.         set_downmix_coeffs(s);

  1128.     }

  1129. 

  1130.     /* parse the audio blocks */

  1131.     for (blk = 0; blk < NB_BLOCKS; blk++) {

  1132.         if (ac3_parse_audio_block(s, blk)) {

  1133.             av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");

  1134.             *data_size = 0;

  1135.             return s->frame_size;

  1136.         }

  1137.         for (i = 0; i < 256; i++)

  1138.             for (ch = 0; ch < s->out_channels; ch++)

  1139.                 *(out_samples++) = s->int_output[ch][i];

  1140.     }

  1141.     *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t);

  1142.     return s->frame_size;

  1143. }

  1144. 

  1145. /**

  1146.  * Uninitialize the AC-3 decoder.

  1147.  */

  1148. static int ac3_decode_end(AVCodecContext *avctx)

  1149. {

  1150.     AC3DecodeContext *s = avctx->priv_data;

  1151.     ff_mdct_end(&s->imdct_512);

  1152.     ff_mdct_end(&s->imdct_256);

  1153. 

  1154.     return 0;

  1155. }

  1156. 

  1157. AVCodec ac3_decoder = {

  1158.     .name = "ac3",

  1159.     .type = CODEC_TYPE_AUDIO,

  1160.     .id = CODEC_ID_AC3,

  1161.     .priv_data_size = sizeof (AC3DecodeContext),

  1162.     .init = ac3_decode_init,

  1163.     .close = ac3_decode_end,

  1164.     .decode = ac3_decode_frame,

  1165. };