• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

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

Generated on Wed Apr 11 2012 07:31:32 for FFmpeg by  doxygen 1.7.1