libavcodec/ac3dec.c
Go to the documentation of this file.
00001 /*
00002  * AC-3 Audio Decoder
00003  * This code was developed as part of Google Summer of Code 2006.
00004  * E-AC-3 support was added as part of Google Summer of Code 2007.
00005  *
00006  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com)
00007  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
00008  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
00009  *
00010  * This file is part of FFmpeg.
00011  *
00012  * FFmpeg is free software; you can redistribute it and/or
00013  * modify it under the terms of the GNU Lesser General Public
00014  * License as published by the Free Software Foundation; either
00015  * version 2.1 of the License, or (at your option) any later version.
00016  *
00017  * FFmpeg is distributed in the hope that it will be useful,
00018  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00019  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020  * Lesser General Public License for more details.
00021  *
00022  * You should have received a copy of the GNU Lesser General Public
00023  * License along with FFmpeg; if not, write to the Free Software
00024  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00025  */
00026 
00027 #include <stdio.h>
00028 #include <stddef.h>
00029 #include <math.h>
00030 #include <string.h>
00031 
00032 #include "libavutil/crc.h"
00033 #include "libavutil/opt.h"
00034 #include "internal.h"
00035 #include "aac_ac3_parser.h"
00036 #include "ac3_parser.h"
00037 #include "ac3dec.h"
00038 #include "ac3dec_data.h"
00039 #include "kbdwin.h"
00040 
00045 static uint8_t ungroup_3_in_7_bits_tab[128][3];
00046 
00048 static int b1_mantissas[32][3];
00049 static int b2_mantissas[128][3];
00050 static int b3_mantissas[8];
00051 static int b4_mantissas[128][2];
00052 static int b5_mantissas[16];
00053 
00058 static const uint8_t quantization_tab[16] = {
00059     0, 3, 5, 7, 11, 15,
00060     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
00061 };
00062 
00064 static float dynamic_range_tab[256];
00065 
00067 static const float gain_levels[9] = {
00068     LEVEL_PLUS_3DB,
00069     LEVEL_PLUS_1POINT5DB,
00070     LEVEL_ONE,
00071     LEVEL_MINUS_1POINT5DB,
00072     LEVEL_MINUS_3DB,
00073     LEVEL_MINUS_4POINT5DB,
00074     LEVEL_MINUS_6DB,
00075     LEVEL_ZERO,
00076     LEVEL_MINUS_9DB
00077 };
00078 
00083 static const uint8_t ac3_default_coeffs[8][5][2] = {
00084     { { 2, 7 }, { 7, 2 },                               },
00085     { { 4, 4 },                                         },
00086     { { 2, 7 }, { 7, 2 },                               },
00087     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
00088     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
00089     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
00090     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
00091     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
00092 };
00093 
00099 static inline int
00100 symmetric_dequant(int code, int levels)
00101 {
00102     return ((code - (levels >> 1)) << 24) / levels;
00103 }
00104 
00105 /*
00106  * Initialize tables at runtime.
00107  */
00108 static av_cold void ac3_tables_init(void)
00109 {
00110     int i;
00111 
00112     /* generate table for ungrouping 3 values in 7 bits
00113        reference: Section 7.1.3 Exponent Decoding */
00114     for (i = 0; i < 128; i++) {
00115         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
00116         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
00117         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
00118     }
00119 
00120     /* generate grouped mantissa tables
00121        reference: Section 7.3.5 Ungrouping of Mantissas */
00122     for (i = 0; i < 32; i++) {
00123         /* bap=1 mantissas */
00124         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
00125         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
00126         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
00127     }
00128     for (i = 0; i < 128; i++) {
00129         /* bap=2 mantissas */
00130         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
00131         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
00132         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
00133 
00134         /* bap=4 mantissas */
00135         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
00136         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
00137     }
00138     /* generate ungrouped mantissa tables
00139        reference: Tables 7.21 and 7.23 */
00140     for (i = 0; i < 7; i++) {
00141         /* bap=3 mantissas */
00142         b3_mantissas[i] = symmetric_dequant(i, 7);
00143     }
00144     for (i = 0; i < 15; i++) {
00145         /* bap=5 mantissas */
00146         b5_mantissas[i] = symmetric_dequant(i, 15);
00147     }
00148 
00149     /* generate dynamic range table
00150        reference: Section 7.7.1 Dynamic Range Control */
00151     for (i = 0; i < 256; i++) {
00152         int v = (i >> 5) - ((i >> 7) << 3) - 5;
00153         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
00154     }
00155 }
00156 
00160 static av_cold int ac3_decode_init(AVCodecContext *avctx)
00161 {
00162     AC3DecodeContext *s = avctx->priv_data;
00163     s->avctx = avctx;
00164 
00165 #if FF_API_DRC_SCALE
00166     if (avctx->drc_scale)
00167         s->drc_scale = avctx->drc_scale;
00168 #endif
00169 
00170     ff_ac3_common_init();
00171     ac3_tables_init();
00172     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
00173     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
00174     ff_kbd_window_init(s->window, 5.0, 256);
00175     dsputil_init(&s->dsp, avctx);
00176     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
00177     ff_fmt_convert_init(&s->fmt_conv, avctx);
00178     av_lfg_init(&s->dith_state, 0);
00179 
00180     /* set scale value for float to int16 conversion */
00181     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
00182         s->mul_bias = 1.0f;
00183         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00184     } else {
00185         s->mul_bias = 32767.0f;
00186         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00187     }
00188 
00189     /* allow downmixing to stereo or mono */
00190     if (avctx->channels > 0 && avctx->request_channels > 0 &&
00191             avctx->request_channels < avctx->channels &&
00192             avctx->request_channels <= 2) {
00193         avctx->channels = avctx->request_channels;
00194     }
00195     s->downmixed = 1;
00196 
00197     avcodec_get_frame_defaults(&s->frame);
00198     avctx->coded_frame = &s->frame;
00199 
00200     return 0;
00201 }
00202 
00208 static int ac3_parse_header(AC3DecodeContext *s)
00209 {
00210     GetBitContext *gbc = &s->gbc;
00211     int i;
00212 
00213     /* read the rest of the bsi. read twice for dual mono mode. */
00214     i = !s->channel_mode;
00215     do {
00216         skip_bits(gbc, 5); // skip dialog normalization
00217         if (get_bits1(gbc))
00218             skip_bits(gbc, 8); //skip compression
00219         if (get_bits1(gbc))
00220             skip_bits(gbc, 8); //skip language code
00221         if (get_bits1(gbc))
00222             skip_bits(gbc, 7); //skip audio production information
00223     } while (i--);
00224 
00225     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
00226 
00227     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
00228        TODO: read & use the xbsi1 downmix levels */
00229     if (get_bits1(gbc))
00230         skip_bits(gbc, 14); //skip timecode1 / xbsi1
00231     if (get_bits1(gbc))
00232         skip_bits(gbc, 14); //skip timecode2 / xbsi2
00233 
00234     /* skip additional bitstream info */
00235     if (get_bits1(gbc)) {
00236         i = get_bits(gbc, 6);
00237         do {
00238             skip_bits(gbc, 8);
00239         } while (i--);
00240     }
00241 
00242     return 0;
00243 }
00244 
00248 static int parse_frame_header(AC3DecodeContext *s)
00249 {
00250     AC3HeaderInfo hdr;
00251     int err;
00252 
00253     err = avpriv_ac3_parse_header(&s->gbc, &hdr);
00254     if (err)
00255         return err;
00256 
00257     /* get decoding parameters from header info */
00258     s->bit_alloc_params.sr_code     = hdr.sr_code;
00259     s->bitstream_mode               = hdr.bitstream_mode;
00260     s->channel_mode                 = hdr.channel_mode;
00261     s->channel_layout               = hdr.channel_layout;
00262     s->lfe_on                       = hdr.lfe_on;
00263     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
00264     s->sample_rate                  = hdr.sample_rate;
00265     s->bit_rate                     = hdr.bit_rate;
00266     s->channels                     = hdr.channels;
00267     s->fbw_channels                 = s->channels - s->lfe_on;
00268     s->lfe_ch                       = s->fbw_channels + 1;
00269     s->frame_size                   = hdr.frame_size;
00270     s->center_mix_level             = hdr.center_mix_level;
00271     s->surround_mix_level           = hdr.surround_mix_level;
00272     s->num_blocks                   = hdr.num_blocks;
00273     s->frame_type                   = hdr.frame_type;
00274     s->substreamid                  = hdr.substreamid;
00275 
00276     if (s->lfe_on) {
00277         s->start_freq[s->lfe_ch]     = 0;
00278         s->end_freq[s->lfe_ch]       = 7;
00279         s->num_exp_groups[s->lfe_ch] = 2;
00280         s->channel_in_cpl[s->lfe_ch] = 0;
00281     }
00282 
00283     if (hdr.bitstream_id <= 10) {
00284         s->eac3                  = 0;
00285         s->snr_offset_strategy   = 2;
00286         s->block_switch_syntax   = 1;
00287         s->dither_flag_syntax    = 1;
00288         s->bit_allocation_syntax = 1;
00289         s->fast_gain_syntax      = 0;
00290         s->first_cpl_leak        = 0;
00291         s->dba_syntax            = 1;
00292         s->skip_syntax           = 1;
00293         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
00294         return ac3_parse_header(s);
00295     } else if (CONFIG_EAC3_DECODER) {
00296         s->eac3 = 1;
00297         return ff_eac3_parse_header(s);
00298     } else {
00299         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
00300         return -1;
00301     }
00302 }
00303 
00308 static void set_downmix_coeffs(AC3DecodeContext *s)
00309 {
00310     int i;
00311     float cmix = gain_levels[s->  center_mix_level];
00312     float smix = gain_levels[s->surround_mix_level];
00313     float norm0, norm1;
00314 
00315     for (i = 0; i < s->fbw_channels; i++) {
00316         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
00317         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
00318     }
00319     if (s->channel_mode > 1 && s->channel_mode & 1) {
00320         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
00321     }
00322     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
00323         int nf = s->channel_mode - 2;
00324         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
00325     }
00326     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
00327         int nf = s->channel_mode - 4;
00328         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
00329     }
00330 
00331     /* renormalize */
00332     norm0 = norm1 = 0.0;
00333     for (i = 0; i < s->fbw_channels; i++) {
00334         norm0 += s->downmix_coeffs[i][0];
00335         norm1 += s->downmix_coeffs[i][1];
00336     }
00337     norm0 = 1.0f / norm0;
00338     norm1 = 1.0f / norm1;
00339     for (i = 0; i < s->fbw_channels; i++) {
00340         s->downmix_coeffs[i][0] *= norm0;
00341         s->downmix_coeffs[i][1] *= norm1;
00342     }
00343 
00344     if (s->output_mode == AC3_CHMODE_MONO) {
00345         for (i = 0; i < s->fbw_channels; i++)
00346             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
00347                                        s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
00348     }
00349 }
00350 
00355 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
00356                             uint8_t absexp, int8_t *dexps)
00357 {
00358     int i, j, grp, group_size;
00359     int dexp[256];
00360     int expacc, prevexp;
00361 
00362     /* unpack groups */
00363     group_size = exp_strategy + (exp_strategy == EXP_D45);
00364     for (grp = 0, i = 0; grp < ngrps; grp++) {
00365         expacc = get_bits(gbc, 7);
00366         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
00367         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
00368         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
00369     }
00370 
00371     /* convert to absolute exps and expand groups */
00372     prevexp = absexp;
00373     for (i = 0, j = 0; i < ngrps * 3; i++) {
00374         prevexp += dexp[i] - 2;
00375         if (prevexp > 24U)
00376             return -1;
00377         switch (group_size) {
00378         case 4: dexps[j++] = prevexp;
00379                 dexps[j++] = prevexp;
00380         case 2: dexps[j++] = prevexp;
00381         case 1: dexps[j++] = prevexp;
00382         }
00383     }
00384     return 0;
00385 }
00386 
00392 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
00393 {
00394     int bin, band, ch;
00395 
00396     bin = s->start_freq[CPL_CH];
00397     for (band = 0; band < s->num_cpl_bands; band++) {
00398         int band_start = bin;
00399         int band_end = bin + s->cpl_band_sizes[band];
00400         for (ch = 1; ch <= s->fbw_channels; ch++) {
00401             if (s->channel_in_cpl[ch]) {
00402                 int cpl_coord = s->cpl_coords[ch][band] << 5;
00403                 for (bin = band_start; bin < band_end; bin++) {
00404                     s->fixed_coeffs[ch][bin] =
00405                         MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
00406                 }
00407                 if (ch == 2 && s->phase_flags[band]) {
00408                     for (bin = band_start; bin < band_end; bin++)
00409                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
00410                 }
00411             }
00412         }
00413         bin = band_end;
00414     }
00415 }
00416 
00420 typedef struct {
00421     int b1_mant[2];
00422     int b2_mant[2];
00423     int b4_mant;
00424     int b1;
00425     int b2;
00426     int b4;
00427 } mant_groups;
00428 
00433 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
00434 {
00435     int start_freq = s->start_freq[ch_index];
00436     int end_freq   = s->end_freq[ch_index];
00437     uint8_t *baps  = s->bap[ch_index];
00438     int8_t *exps   = s->dexps[ch_index];
00439     int *coeffs    = s->fixed_coeffs[ch_index];
00440     int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
00441     GetBitContext *gbc = &s->gbc;
00442     int freq;
00443 
00444     for (freq = start_freq; freq < end_freq; freq++) {
00445         int bap = baps[freq];
00446         int mantissa;
00447         switch (bap) {
00448         case 0:
00449             if (dither)
00450                 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
00451             else
00452                 mantissa = 0;
00453             break;
00454         case 1:
00455             if (m->b1) {
00456                 m->b1--;
00457                 mantissa = m->b1_mant[m->b1];
00458             } else {
00459                 int bits      = get_bits(gbc, 5);
00460                 mantissa      = b1_mantissas[bits][0];
00461                 m->b1_mant[1] = b1_mantissas[bits][1];
00462                 m->b1_mant[0] = b1_mantissas[bits][2];
00463                 m->b1         = 2;
00464             }
00465             break;
00466         case 2:
00467             if (m->b2) {
00468                 m->b2--;
00469                 mantissa = m->b2_mant[m->b2];
00470             } else {
00471                 int bits      = get_bits(gbc, 7);
00472                 mantissa      = b2_mantissas[bits][0];
00473                 m->b2_mant[1] = b2_mantissas[bits][1];
00474                 m->b2_mant[0] = b2_mantissas[bits][2];
00475                 m->b2         = 2;
00476             }
00477             break;
00478         case 3:
00479             mantissa = b3_mantissas[get_bits(gbc, 3)];
00480             break;
00481         case 4:
00482             if (m->b4) {
00483                 m->b4 = 0;
00484                 mantissa = m->b4_mant;
00485             } else {
00486                 int bits   = get_bits(gbc, 7);
00487                 mantissa   = b4_mantissas[bits][0];
00488                 m->b4_mant = b4_mantissas[bits][1];
00489                 m->b4      = 1;
00490             }
00491             break;
00492         case 5:
00493             mantissa = b5_mantissas[get_bits(gbc, 4)];
00494             break;
00495         default: /* 6 to 15 */
00496             /* Shift mantissa and sign-extend it. */
00497             mantissa = get_sbits(gbc, quantization_tab[bap]);
00498             mantissa <<= 24 - quantization_tab[bap];
00499             break;
00500         }
00501         coeffs[freq] = mantissa >> exps[freq];
00502     }
00503 }
00504 
00510 static void remove_dithering(AC3DecodeContext *s) {
00511     int ch, i;
00512 
00513     for (ch = 1; ch <= s->fbw_channels; ch++) {
00514         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
00515             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
00516                 if (!s->bap[CPL_CH][i])
00517                     s->fixed_coeffs[ch][i] = 0;
00518             }
00519         }
00520     }
00521 }
00522 
00523 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
00524                                        mant_groups *m)
00525 {
00526     if (!s->channel_uses_aht[ch]) {
00527         ac3_decode_transform_coeffs_ch(s, ch, m);
00528     } else {
00529         /* if AHT is used, mantissas for all blocks are encoded in the first
00530            block of the frame. */
00531         int bin;
00532         if (!blk && CONFIG_EAC3_DECODER)
00533             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
00534         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
00535             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
00536         }
00537     }
00538 }
00539 
00543 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
00544 {
00545     int ch, end;
00546     int got_cplchan = 0;
00547     mant_groups m;
00548 
00549     m.b1 = m.b2 = m.b4 = 0;
00550 
00551     for (ch = 1; ch <= s->channels; ch++) {
00552         /* transform coefficients for full-bandwidth channel */
00553         decode_transform_coeffs_ch(s, blk, ch, &m);
00554         /* tranform coefficients for coupling channel come right after the
00555            coefficients for the first coupled channel*/
00556         if (s->channel_in_cpl[ch])  {
00557             if (!got_cplchan) {
00558                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
00559                 calc_transform_coeffs_cpl(s);
00560                 got_cplchan = 1;
00561             }
00562             end = s->end_freq[CPL_CH];
00563         } else {
00564             end = s->end_freq[ch];
00565         }
00566         do
00567             s->fixed_coeffs[ch][end] = 0;
00568         while (++end < 256);
00569     }
00570 
00571     /* zero the dithered coefficients for appropriate channels */
00572     remove_dithering(s);
00573 }
00574 
00579 static void do_rematrixing(AC3DecodeContext *s)
00580 {
00581     int bnd, i;
00582     int end, bndend;
00583 
00584     end = FFMIN(s->end_freq[1], s->end_freq[2]);
00585 
00586     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
00587         if (s->rematrixing_flags[bnd]) {
00588             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
00589             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
00590                 int tmp0 = s->fixed_coeffs[1][i];
00591                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
00592                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
00593             }
00594         }
00595     }
00596 }
00597 
00603 static inline void do_imdct(AC3DecodeContext *s, int channels)
00604 {
00605     int ch;
00606 
00607     for (ch = 1; ch <= channels; ch++) {
00608         if (s->block_switch[ch]) {
00609             int i;
00610             float *x = s->tmp_output + 128;
00611             for (i = 0; i < 128; i++)
00612                 x[i] = s->transform_coeffs[ch][2 * i];
00613             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
00614             s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
00615                                       s->tmp_output, s->window, 128);
00616             for (i = 0; i < 128; i++)
00617                 x[i] = s->transform_coeffs[ch][2 * i + 1];
00618             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
00619         } else {
00620             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
00621             s->dsp.vector_fmul_window(s->output[ch - 1], s->delay[ch - 1],
00622                                       s->tmp_output, s->window, 128);
00623             memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
00624         }
00625     }
00626 }
00627 
00631 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
00632                       int out_ch, int in_ch, int len)
00633 {
00634     int i, j;
00635     float v0, v1;
00636     if (out_ch == 2) {
00637         for (i = 0; i < len; i++) {
00638             v0 = v1 = 0.0f;
00639             for (j = 0; j < in_ch; j++) {
00640                 v0 += samples[j][i] * matrix[j][0];
00641                 v1 += samples[j][i] * matrix[j][1];
00642             }
00643             samples[0][i] = v0;
00644             samples[1][i] = v1;
00645         }
00646     } else if (out_ch == 1) {
00647         for (i = 0; i < len; i++) {
00648             v0 = 0.0f;
00649             for (j = 0; j < in_ch; j++)
00650                 v0 += samples[j][i] * matrix[j][0];
00651             samples[0][i] = v0;
00652         }
00653     }
00654 }
00655 
00659 static void ac3_upmix_delay(AC3DecodeContext *s)
00660 {
00661     int channel_data_size = sizeof(s->delay[0]);
00662     switch (s->channel_mode) {
00663     case AC3_CHMODE_DUALMONO:
00664     case AC3_CHMODE_STEREO:
00665         /* upmix mono to stereo */
00666         memcpy(s->delay[1], s->delay[0], channel_data_size);
00667         break;
00668     case AC3_CHMODE_2F2R:
00669         memset(s->delay[3], 0, channel_data_size);
00670     case AC3_CHMODE_2F1R:
00671         memset(s->delay[2], 0, channel_data_size);
00672         break;
00673     case AC3_CHMODE_3F2R:
00674         memset(s->delay[4], 0, channel_data_size);
00675     case AC3_CHMODE_3F1R:
00676         memset(s->delay[3], 0, channel_data_size);
00677     case AC3_CHMODE_3F:
00678         memcpy(s->delay[2], s->delay[1], channel_data_size);
00679         memset(s->delay[1], 0, channel_data_size);
00680         break;
00681     }
00682 }
00683 
00700 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
00701                                   int ecpl, int start_subband, int end_subband,
00702                                   const uint8_t *default_band_struct,
00703                                   int *num_bands, uint8_t *band_sizes)
00704 {
00705     int subbnd, bnd, n_subbands, n_bands=0;
00706     uint8_t bnd_sz[22];
00707     uint8_t coded_band_struct[22];
00708     const uint8_t *band_struct;
00709 
00710     n_subbands = end_subband - start_subband;
00711 
00712     /* decode band structure from bitstream or use default */
00713     if (!eac3 || get_bits1(gbc)) {
00714         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
00715             coded_band_struct[subbnd] = get_bits1(gbc);
00716         }
00717         band_struct = coded_band_struct;
00718     } else if (!blk) {
00719         band_struct = &default_band_struct[start_subband+1];
00720     } else {
00721         /* no change in band structure */
00722         return;
00723     }
00724 
00725     /* calculate number of bands and band sizes based on band structure.
00726        note that the first 4 subbands in enhanced coupling span only 6 bins
00727        instead of 12. */
00728     if (num_bands || band_sizes ) {
00729         n_bands = n_subbands;
00730         bnd_sz[0] = ecpl ? 6 : 12;
00731         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
00732             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
00733             if (band_struct[subbnd - 1]) {
00734                 n_bands--;
00735                 bnd_sz[bnd] += subbnd_size;
00736             } else {
00737                 bnd_sz[++bnd] = subbnd_size;
00738             }
00739         }
00740     }
00741 
00742     /* set optional output params */
00743     if (num_bands)
00744         *num_bands = n_bands;
00745     if (band_sizes)
00746         memcpy(band_sizes, bnd_sz, n_bands);
00747 }
00748 
00752 static int decode_audio_block(AC3DecodeContext *s, int blk)
00753 {
00754     int fbw_channels = s->fbw_channels;
00755     int channel_mode = s->channel_mode;
00756     int i, bnd, seg, ch;
00757     int different_transforms;
00758     int downmix_output;
00759     int cpl_in_use;
00760     GetBitContext *gbc = &s->gbc;
00761     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
00762 
00763     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
00764 
00765     /* block switch flags */
00766     different_transforms = 0;
00767     if (s->block_switch_syntax) {
00768         for (ch = 1; ch <= fbw_channels; ch++) {
00769             s->block_switch[ch] = get_bits1(gbc);
00770             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
00771                 different_transforms = 1;
00772         }
00773     }
00774 
00775     /* dithering flags */
00776     if (s->dither_flag_syntax) {
00777         for (ch = 1; ch <= fbw_channels; ch++) {
00778             s->dither_flag[ch] = get_bits1(gbc);
00779         }
00780     }
00781 
00782     /* dynamic range */
00783     i = !s->channel_mode;
00784     do {
00785         if (get_bits1(gbc)) {
00786             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *
00787                                   s->drc_scale) + 1.0;
00788         } else if (blk == 0) {
00789             s->dynamic_range[i] = 1.0f;
00790         }
00791     } while (i--);
00792 
00793     /* spectral extension strategy */
00794     if (s->eac3 && (!blk || get_bits1(gbc))) {
00795         s->spx_in_use = get_bits1(gbc);
00796         if (s->spx_in_use) {
00797             int dst_start_freq, dst_end_freq, src_start_freq,
00798                 start_subband, end_subband;
00799 
00800             /* determine which channels use spx */
00801             if (s->channel_mode == AC3_CHMODE_MONO) {
00802                 s->channel_uses_spx[1] = 1;
00803             } else {
00804                 for (ch = 1; ch <= fbw_channels; ch++)
00805                     s->channel_uses_spx[ch] = get_bits1(gbc);
00806             }
00807 
00808             /* get the frequency bins of the spx copy region and the spx start
00809                and end subbands */
00810             dst_start_freq = get_bits(gbc, 2);
00811             start_subband  = get_bits(gbc, 3) + 2;
00812             if (start_subband > 7)
00813                 start_subband += start_subband - 7;
00814             end_subband    = get_bits(gbc, 3) + 5;
00815             if (end_subband   > 7)
00816                 end_subband   += end_subband   - 7;
00817             dst_start_freq = dst_start_freq * 12 + 25;
00818             src_start_freq = start_subband  * 12 + 25;
00819             dst_end_freq   = end_subband    * 12 + 25;
00820 
00821             /* check validity of spx ranges */
00822             if (start_subband >= end_subband) {
00823                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
00824                        "range (%d >= %d)\n", start_subband, end_subband);
00825                 return -1;
00826             }
00827             if (dst_start_freq >= src_start_freq) {
00828                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
00829                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
00830                 return -1;
00831             }
00832 
00833             s->spx_dst_start_freq = dst_start_freq;
00834             s->spx_src_start_freq = src_start_freq;
00835             s->spx_dst_end_freq   = dst_end_freq;
00836 
00837             decode_band_structure(gbc, blk, s->eac3, 0,
00838                                   start_subband, end_subband,
00839                                   ff_eac3_default_spx_band_struct,
00840                                   &s->num_spx_bands,
00841                                   s->spx_band_sizes);
00842         } else {
00843             for (ch = 1; ch <= fbw_channels; ch++) {
00844                 s->channel_uses_spx[ch] = 0;
00845                 s->first_spx_coords[ch] = 1;
00846             }
00847         }
00848     }
00849 
00850     /* spectral extension coordinates */
00851     if (s->spx_in_use) {
00852         for (ch = 1; ch <= fbw_channels; ch++) {
00853             if (s->channel_uses_spx[ch]) {
00854                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
00855                     float spx_blend;
00856                     int bin, master_spx_coord;
00857 
00858                     s->first_spx_coords[ch] = 0;
00859                     spx_blend = get_bits(gbc, 5) * (1.0f/32);
00860                     master_spx_coord = get_bits(gbc, 2) * 3;
00861 
00862                     bin = s->spx_src_start_freq;
00863                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
00864                         int bandsize;
00865                         int spx_coord_exp, spx_coord_mant;
00866                         float nratio, sblend, nblend, spx_coord;
00867 
00868                         /* calculate blending factors */
00869                         bandsize = s->spx_band_sizes[bnd];
00870                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
00871                         nratio = av_clipf(nratio, 0.0f, 1.0f);
00872                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
00873                                                        // to give unity variance
00874                         sblend = sqrtf(1.0f - nratio);
00875                         bin += bandsize;
00876 
00877                         /* decode spx coordinates */
00878                         spx_coord_exp  = get_bits(gbc, 4);
00879                         spx_coord_mant = get_bits(gbc, 2);
00880                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
00881                         else                     spx_coord_mant += 4;
00882                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
00883                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
00884 
00885                         /* multiply noise and signal blending factors by spx coordinate */
00886                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
00887                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
00888                     }
00889                 }
00890             } else {
00891                 s->first_spx_coords[ch] = 1;
00892             }
00893         }
00894     }
00895 
00896     /* coupling strategy */
00897     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
00898         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00899         if (!s->eac3)
00900             s->cpl_in_use[blk] = get_bits1(gbc);
00901         if (s->cpl_in_use[blk]) {
00902             /* coupling in use */
00903             int cpl_start_subband, cpl_end_subband;
00904 
00905             if (channel_mode < AC3_CHMODE_STEREO) {
00906                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
00907                 return -1;
00908             }
00909 
00910             /* check for enhanced coupling */
00911             if (s->eac3 && get_bits1(gbc)) {
00912                 /* TODO: parse enhanced coupling strategy info */
00913                 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
00914                 return -1;
00915             }
00916 
00917             /* determine which channels are coupled */
00918             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
00919                 s->channel_in_cpl[1] = 1;
00920                 s->channel_in_cpl[2] = 1;
00921             } else {
00922                 for (ch = 1; ch <= fbw_channels; ch++)
00923                     s->channel_in_cpl[ch] = get_bits1(gbc);
00924             }
00925 
00926             /* phase flags in use */
00927             if (channel_mode == AC3_CHMODE_STEREO)
00928                 s->phase_flags_in_use = get_bits1(gbc);
00929 
00930             /* coupling frequency range */
00931             cpl_start_subband = get_bits(gbc, 4);
00932             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
00933                                               get_bits(gbc, 4) + 3;
00934             if (cpl_start_subband >= cpl_end_subband) {
00935                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
00936                        cpl_start_subband, cpl_end_subband);
00937                 return -1;
00938             }
00939             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
00940             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
00941 
00942             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
00943                                   cpl_end_subband,
00944                                   ff_eac3_default_cpl_band_struct,
00945                                   &s->num_cpl_bands, s->cpl_band_sizes);
00946         } else {
00947             /* coupling not in use */
00948             for (ch = 1; ch <= fbw_channels; ch++) {
00949                 s->channel_in_cpl[ch] = 0;
00950                 s->first_cpl_coords[ch] = 1;
00951             }
00952             s->first_cpl_leak = s->eac3;
00953             s->phase_flags_in_use = 0;
00954         }
00955     } else if (!s->eac3) {
00956         if (!blk) {
00957             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
00958                    "be present in block 0\n");
00959             return -1;
00960         } else {
00961             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
00962         }
00963     }
00964     cpl_in_use = s->cpl_in_use[blk];
00965 
00966     /* coupling coordinates */
00967     if (cpl_in_use) {
00968         int cpl_coords_exist = 0;
00969 
00970         for (ch = 1; ch <= fbw_channels; ch++) {
00971             if (s->channel_in_cpl[ch]) {
00972                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
00973                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
00974                     s->first_cpl_coords[ch] = 0;
00975                     cpl_coords_exist = 1;
00976                     master_cpl_coord = 3 * get_bits(gbc, 2);
00977                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
00978                         cpl_coord_exp = get_bits(gbc, 4);
00979                         cpl_coord_mant = get_bits(gbc, 4);
00980                         if (cpl_coord_exp == 15)
00981                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
00982                         else
00983                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
00984                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
00985                     }
00986                 } else if (!blk) {
00987                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
00988                            "be present in block 0\n");
00989                     return -1;
00990                 }
00991             } else {
00992                 /* channel not in coupling */
00993                 s->first_cpl_coords[ch] = 1;
00994             }
00995         }
00996         /* phase flags */
00997         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
00998             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
00999                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
01000             }
01001         }
01002     }
01003 
01004     /* stereo rematrixing strategy and band structure */
01005     if (channel_mode == AC3_CHMODE_STEREO) {
01006         if ((s->eac3 && !blk) || get_bits1(gbc)) {
01007             s->num_rematrixing_bands = 4;
01008             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
01009                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
01010             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
01011                 s->num_rematrixing_bands--;
01012             }
01013             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
01014                 s->rematrixing_flags[bnd] = get_bits1(gbc);
01015         } else if (!blk) {
01016             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
01017                    "new rematrixing strategy not present in block 0\n");
01018             s->num_rematrixing_bands = 0;
01019         }
01020     }
01021 
01022     /* exponent strategies for each channel */
01023     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01024         if (!s->eac3)
01025             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
01026         if (s->exp_strategy[blk][ch] != EXP_REUSE)
01027             bit_alloc_stages[ch] = 3;
01028     }
01029 
01030     /* channel bandwidth */
01031     for (ch = 1; ch <= fbw_channels; ch++) {
01032         s->start_freq[ch] = 0;
01033         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
01034             int group_size;
01035             int prev = s->end_freq[ch];
01036             if (s->channel_in_cpl[ch])
01037                 s->end_freq[ch] = s->start_freq[CPL_CH];
01038             else if (s->channel_uses_spx[ch])
01039                 s->end_freq[ch] = s->spx_src_start_freq;
01040             else {
01041                 int bandwidth_code = get_bits(gbc, 6);
01042                 if (bandwidth_code > 60) {
01043                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
01044                     return -1;
01045                 }
01046                 s->end_freq[ch] = bandwidth_code * 3 + 73;
01047             }
01048             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
01049             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
01050             if (blk > 0 && s->end_freq[ch] != prev)
01051                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
01052         }
01053     }
01054     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
01055         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
01056                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
01057     }
01058 
01059     /* decode exponents for each channel */
01060     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01061         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
01062             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
01063             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
01064                                  s->num_exp_groups[ch], s->dexps[ch][0],
01065                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
01066                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
01067                 return -1;
01068             }
01069             if (ch != CPL_CH && ch != s->lfe_ch)
01070                 skip_bits(gbc, 2); /* skip gainrng */
01071         }
01072     }
01073 
01074     /* bit allocation information */
01075     if (s->bit_allocation_syntax) {
01076         if (get_bits1(gbc)) {
01077             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01078             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01079             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
01080             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
01081             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
01082             for (ch = !cpl_in_use; ch <= s->channels; ch++)
01083                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01084         } else if (!blk) {
01085             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
01086                    "be present in block 0\n");
01087             return -1;
01088         }
01089     }
01090 
01091     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
01092     if (!s->eac3 || !blk) {
01093         if (s->snr_offset_strategy && get_bits1(gbc)) {
01094             int snr = 0;
01095             int csnr;
01096             csnr = (get_bits(gbc, 6) - 15) << 4;
01097             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
01098                 /* snr offset */
01099                 if (ch == i || s->snr_offset_strategy == 2)
01100                     snr = (csnr + get_bits(gbc, 4)) << 2;
01101                 /* run at least last bit allocation stage if snr offset changes */
01102                 if (blk && s->snr_offset[ch] != snr) {
01103                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
01104                 }
01105                 s->snr_offset[ch] = snr;
01106 
01107                 /* fast gain (normal AC-3 only) */
01108                 if (!s->eac3) {
01109                     int prev = s->fast_gain[ch];
01110                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01111                     /* run last 2 bit allocation stages if fast gain changes */
01112                     if (blk && prev != s->fast_gain[ch])
01113                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01114                 }
01115             }
01116         } else if (!s->eac3 && !blk) {
01117             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
01118             return -1;
01119         }
01120     }
01121 
01122     /* fast gain (E-AC-3 only) */
01123     if (s->fast_gain_syntax && get_bits1(gbc)) {
01124         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01125             int prev = s->fast_gain[ch];
01126             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01127             /* run last 2 bit allocation stages if fast gain changes */
01128             if (blk && prev != s->fast_gain[ch])
01129                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01130         }
01131     } else if (s->eac3 && !blk) {
01132         for (ch = !cpl_in_use; ch <= s->channels; ch++)
01133             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
01134     }
01135 
01136     /* E-AC-3 to AC-3 converter SNR offset */
01137     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
01138         skip_bits(gbc, 10); // skip converter snr offset
01139     }
01140 
01141     /* coupling leak information */
01142     if (cpl_in_use) {
01143         if (s->first_cpl_leak || get_bits1(gbc)) {
01144             int fl = get_bits(gbc, 3);
01145             int sl = get_bits(gbc, 3);
01146             /* run last 2 bit allocation stages for coupling channel if
01147                coupling leak changes */
01148             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
01149                 sl != s->bit_alloc_params.cpl_slow_leak)) {
01150                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
01151             }
01152             s->bit_alloc_params.cpl_fast_leak = fl;
01153             s->bit_alloc_params.cpl_slow_leak = sl;
01154         } else if (!s->eac3 && !blk) {
01155             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
01156                    "be present in block 0\n");
01157             return -1;
01158         }
01159         s->first_cpl_leak = 0;
01160     }
01161 
01162     /* delta bit allocation information */
01163     if (s->dba_syntax && get_bits1(gbc)) {
01164         /* delta bit allocation exists (strategy) */
01165         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01166             s->dba_mode[ch] = get_bits(gbc, 2);
01167             if (s->dba_mode[ch] == DBA_RESERVED) {
01168                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
01169                 return -1;
01170             }
01171             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01172         }
01173         /* channel delta offset, len and bit allocation */
01174         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01175             if (s->dba_mode[ch] == DBA_NEW) {
01176                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
01177                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
01178                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
01179                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
01180                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
01181                 }
01182                 /* run last 2 bit allocation stages if new dba values */
01183                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01184             }
01185         }
01186     } else if (blk == 0) {
01187         for (ch = 0; ch <= s->channels; ch++) {
01188             s->dba_mode[ch] = DBA_NONE;
01189         }
01190     }
01191 
01192     /* Bit allocation */
01193     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01194         if (bit_alloc_stages[ch] > 2) {
01195             /* Exponent mapping into PSD and PSD integration */
01196             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
01197                                       s->start_freq[ch], s->end_freq[ch],
01198                                       s->psd[ch], s->band_psd[ch]);
01199         }
01200         if (bit_alloc_stages[ch] > 1) {
01201             /* Compute excitation function, Compute masking curve, and
01202                Apply delta bit allocation */
01203             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
01204                                            s->start_freq[ch],  s->end_freq[ch],
01205                                            s->fast_gain[ch],   (ch == s->lfe_ch),
01206                                            s->dba_mode[ch],    s->dba_nsegs[ch],
01207                                            s->dba_offsets[ch], s->dba_lengths[ch],
01208                                            s->dba_values[ch],  s->mask[ch])) {
01209                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
01210                 return -1;
01211             }
01212         }
01213         if (bit_alloc_stages[ch] > 0) {
01214             /* Compute bit allocation */
01215             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
01216                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
01217             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
01218                                       s->start_freq[ch], s->end_freq[ch],
01219                                       s->snr_offset[ch],
01220                                       s->bit_alloc_params.floor,
01221                                       bap_tab, s->bap[ch]);
01222         }
01223     }
01224 
01225     /* unused dummy data */
01226     if (s->skip_syntax && get_bits1(gbc)) {
01227         int skipl = get_bits(gbc, 9);
01228         while (skipl--)
01229             skip_bits(gbc, 8);
01230     }
01231 
01232     /* unpack the transform coefficients
01233        this also uncouples channels if coupling is in use. */
01234     decode_transform_coeffs(s, blk);
01235 
01236     /* TODO: generate enhanced coupling coordinates and uncouple */
01237 
01238     /* recover coefficients if rematrixing is in use */
01239     if (s->channel_mode == AC3_CHMODE_STEREO)
01240         do_rematrixing(s);
01241 
01242     /* apply scaling to coefficients (headroom, dynrng) */
01243     for (ch = 1; ch <= s->channels; ch++) {
01244         float gain = s->mul_bias / 4194304.0f;
01245         if (s->channel_mode == AC3_CHMODE_DUALMONO) {
01246             gain *= s->dynamic_range[2 - ch];
01247         } else {
01248             gain *= s->dynamic_range[0];
01249         }
01250         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
01251                                                s->fixed_coeffs[ch], gain, 256);
01252     }
01253 
01254     /* apply spectral extension to high frequency bins */
01255     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
01256         ff_eac3_apply_spectral_extension(s);
01257     }
01258 
01259     /* downmix and MDCT. order depends on whether block switching is used for
01260        any channel in this block. this is because coefficients for the long
01261        and short transforms cannot be mixed. */
01262     downmix_output = s->channels != s->out_channels &&
01263                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
01264                      s->fbw_channels == s->out_channels);
01265     if (different_transforms) {
01266         /* the delay samples have already been downmixed, so we upmix the delay
01267            samples in order to reconstruct all channels before downmixing. */
01268         if (s->downmixed) {
01269             s->downmixed = 0;
01270             ac3_upmix_delay(s);
01271         }
01272 
01273         do_imdct(s, s->channels);
01274 
01275         if (downmix_output) {
01276             s->dsp.ac3_downmix(s->output, s->downmix_coeffs,
01277                                s->out_channels, s->fbw_channels, 256);
01278         }
01279     } else {
01280         if (downmix_output) {
01281             s->dsp.ac3_downmix(s->transform_coeffs + 1, s->downmix_coeffs,
01282                                s->out_channels, s->fbw_channels, 256);
01283         }
01284 
01285         if (downmix_output && !s->downmixed) {
01286             s->downmixed = 1;
01287             s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels,
01288                                s->fbw_channels, 128);
01289         }
01290 
01291         do_imdct(s, s->out_channels);
01292     }
01293 
01294     return 0;
01295 }
01296 
01300 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
01301                             int *got_frame_ptr, AVPacket *avpkt)
01302 {
01303     const uint8_t *buf = avpkt->data;
01304     int buf_size = avpkt->size;
01305     AC3DecodeContext *s = avctx->priv_data;
01306     float   *out_samples_flt;
01307     int16_t *out_samples_s16;
01308     int blk, ch, err, ret;
01309     const uint8_t *channel_map;
01310     const float *output[AC3_MAX_CHANNELS];
01311 
01312     /* copy input buffer to decoder context to avoid reading past the end
01313        of the buffer, which can be caused by a damaged input stream. */
01314     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
01315         // seems to be byte-swapped AC-3
01316         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
01317         s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
01318     } else
01319         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
01320     buf = s->input_buffer;
01321     /* initialize the GetBitContext with the start of valid AC-3 Frame */
01322     init_get_bits(&s->gbc, buf, buf_size * 8);
01323 
01324     /* parse the syncinfo */
01325     err = parse_frame_header(s);
01326 
01327     if (err) {
01328         switch (err) {
01329         case AAC_AC3_PARSE_ERROR_SYNC:
01330             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
01331             return -1;
01332         case AAC_AC3_PARSE_ERROR_BSID:
01333             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
01334             break;
01335         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
01336             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
01337             break;
01338         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
01339             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
01340             break;
01341         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
01342             /* skip frame if CRC is ok. otherwise use error concealment. */
01343             /* TODO: add support for substreams and dependent frames */
01344             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
01345                 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "
01346                        "skipping frame\n");
01347                 *got_frame_ptr = 0;
01348                 return s->frame_size;
01349             } else {
01350                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
01351             }
01352             break;
01353         default:
01354             av_log(avctx, AV_LOG_ERROR, "invalid header\n");
01355             break;
01356         }
01357     } else {
01358         /* check that reported frame size fits in input buffer */
01359         if (s->frame_size > buf_size) {
01360             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
01361             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
01362         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
01363             /* check for crc mismatch */
01364             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
01365                        s->frame_size - 2)) {
01366                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
01367                 err = AAC_AC3_PARSE_ERROR_CRC;
01368             }
01369         }
01370     }
01371 
01372     /* if frame is ok, set audio parameters */
01373     if (!err) {
01374         avctx->sample_rate = s->sample_rate;
01375         avctx->bit_rate    = s->bit_rate;
01376 
01377         /* channel config */
01378         s->out_channels = s->channels;
01379         s->output_mode  = s->channel_mode;
01380         if (s->lfe_on)
01381             s->output_mode |= AC3_OUTPUT_LFEON;
01382         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
01383                 avctx->request_channels < s->channels) {
01384             s->out_channels = avctx->request_channels;
01385             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01386             s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];
01387         }
01388         avctx->channels       = s->out_channels;
01389         avctx->channel_layout = s->channel_layout;
01390 
01391         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
01392         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
01393         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
01394         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
01395         /* set downmixing coefficients if needed */
01396         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
01397                 s->fbw_channels == s->out_channels)) {
01398             set_downmix_coeffs(s);
01399         }
01400     } else if (!s->out_channels) {
01401         s->out_channels = avctx->channels;
01402         if (s->out_channels < s->channels)
01403             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01404     }
01405     /* set audio service type based on bitstream mode for AC-3 */
01406     avctx->audio_service_type = s->bitstream_mode;
01407     if (s->bitstream_mode == 0x7 && s->channels > 1)
01408         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
01409 
01410     /* get output buffer */
01411     avctx->channels = s->out_channels;
01412     s->frame.nb_samples = s->num_blocks * 256;
01413     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
01414         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01415         return ret;
01416     }
01417     out_samples_flt = (float   *)s->frame.data[0];
01418     out_samples_s16 = (int16_t *)s->frame.data[0];
01419 
01420     /* decode the audio blocks */
01421     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
01422     for (ch = 0; ch < s->out_channels; ch++)
01423         output[ch] = s->output[channel_map[ch]];
01424     for (blk = 0; blk < s->num_blocks; blk++) {
01425         if (!err && decode_audio_block(s, blk)) {
01426             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
01427             err = 1;
01428         }
01429         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
01430             s->fmt_conv.float_interleave(out_samples_flt, output, 256,
01431                                          s->out_channels);
01432             out_samples_flt += 256 * s->out_channels;
01433         } else {
01434             s->fmt_conv.float_to_int16_interleave(out_samples_s16, output, 256,
01435                                                   s->out_channels);
01436             out_samples_s16 += 256 * s->out_channels;
01437         }
01438     }
01439 
01440     *got_frame_ptr   = 1;
01441     *(AVFrame *)data = s->frame;
01442 
01443     return FFMIN(buf_size, s->frame_size);
01444 }
01445 
01449 static av_cold int ac3_decode_end(AVCodecContext *avctx)
01450 {
01451     AC3DecodeContext *s = avctx->priv_data;
01452     ff_mdct_end(&s->imdct_512);
01453     ff_mdct_end(&s->imdct_256);
01454 
01455     return 0;
01456 }
01457 
01458 #define OFFSET(x) offsetof(AC3DecodeContext, x)
01459 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
01460 static const AVOption options[] = {
01461     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {1.0}, 0.0, 1.0, PAR },
01462 
01463 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.dbl = -1 }, -1, 2, 0, "dmix_mode"},
01464 {"ltrt_cmixlev",   "Lt/Rt Center Mix Level",   OFFSET(ltrt_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
01465 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
01466 {"loro_cmixlev",   "Lo/Ro Center Mix Level",   OFFSET(loro_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
01467 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
01468 
01469     { NULL},
01470 };
01471 
01472 static const AVClass ac3_decoder_class = {
01473     .class_name = "AC3 decoder",
01474     .item_name  = av_default_item_name,
01475     .option     = options,
01476     .version    = LIBAVUTIL_VERSION_INT,
01477 };
01478 
01479 AVCodec ff_ac3_decoder = {
01480     .name           = "ac3",
01481     .type           = AVMEDIA_TYPE_AUDIO,
01482     .id             = CODEC_ID_AC3,
01483     .priv_data_size = sizeof (AC3DecodeContext),
01484     .init           = ac3_decode_init,
01485     .close          = ac3_decode_end,
01486     .decode         = ac3_decode_frame,
01487     .capabilities   = CODEC_CAP_DR1,
01488     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
01489     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
01490                                                       AV_SAMPLE_FMT_S16,
01491                                                       AV_SAMPLE_FMT_NONE },
01492     .priv_class     = &ac3_decoder_class,
01493 };
01494 
01495 #if CONFIG_EAC3_DECODER
01496 static const AVClass eac3_decoder_class = {
01497     .class_name = "E-AC3 decoder",
01498     .item_name  = av_default_item_name,
01499     .option     = options,
01500     .version    = LIBAVUTIL_VERSION_INT,
01501 };
01502 
01503 AVCodec ff_eac3_decoder = {
01504     .name           = "eac3",
01505     .type           = AVMEDIA_TYPE_AUDIO,
01506     .id             = CODEC_ID_EAC3,
01507     .priv_data_size = sizeof (AC3DecodeContext),
01508     .init           = ac3_decode_init,
01509     .close          = ac3_decode_end,
01510     .decode         = ac3_decode_frame,
01511     .capabilities   = CODEC_CAP_DR1,
01512     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
01513     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
01514                                                       AV_SAMPLE_FMT_S16,
01515                                                       AV_SAMPLE_FMT_NONE },
01516     .priv_class     = &eac3_decoder_class,
01517 };
01518 #endif