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