• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • 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 
00040 #define AC3_FRAME_BUFFER_SIZE 32768
00041 
00046 static uint8_t ungroup_3_in_7_bits_tab[128][3];
00047 
00048 
00050 static int b1_mantissas[32][3];
00051 static int b2_mantissas[128][3];
00052 static int b3_mantissas[8];
00053 static int b4_mantissas[128][2];
00054 static int b5_mantissas[16];
00055 
00060 static const uint8_t quantization_tab[16] = {
00061     0, 3, 5, 7, 11, 15,
00062     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
00063 };
00064 
00066 static float dynamic_range_tab[256];
00067 
00069 #define LEVEL_PLUS_3DB          1.4142135623730950
00070 #define LEVEL_PLUS_1POINT5DB    1.1892071150027209
00071 #define LEVEL_MINUS_1POINT5DB   0.8408964152537145
00072 #define LEVEL_MINUS_3DB         0.7071067811865476
00073 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
00074 #define LEVEL_MINUS_6DB         0.5000000000000000
00075 #define LEVEL_MINUS_9DB         0.3535533905932738
00076 #define LEVEL_ZERO              0.0000000000000000
00077 #define LEVEL_ONE               1.0000000000000000
00078 
00079 static const float gain_levels[9] = {
00080     LEVEL_PLUS_3DB,
00081     LEVEL_PLUS_1POINT5DB,
00082     LEVEL_ONE,
00083     LEVEL_MINUS_1POINT5DB,
00084     LEVEL_MINUS_3DB,
00085     LEVEL_MINUS_4POINT5DB,
00086     LEVEL_MINUS_6DB,
00087     LEVEL_ZERO,
00088     LEVEL_MINUS_9DB
00089 };
00090 
00095 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
00096 
00101 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
00102 
00107 static const uint8_t ac3_default_coeffs[8][5][2] = {
00108     { { 2, 7 }, { 7, 2 },                               },
00109     { { 4, 4 },                                         },
00110     { { 2, 7 }, { 7, 2 },                               },
00111     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
00112     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
00113     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
00114     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
00115     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
00116 };
00117 
00123 static inline int
00124 symmetric_dequant(int code, int levels)
00125 {
00126     return ((code - (levels >> 1)) << 24) / levels;
00127 }
00128 
00129 /*
00130  * Initialize tables at runtime.
00131  */
00132 static av_cold void ac3_tables_init(void)
00133 {
00134     int i;
00135 
00136     /* generate table for ungrouping 3 values in 7 bits
00137        reference: Section 7.1.3 Exponent Decoding */
00138     for(i=0; i<128; i++) {
00139         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
00140         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
00141         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
00142     }
00143 
00144     /* generate grouped mantissa tables
00145        reference: Section 7.3.5 Ungrouping of Mantissas */
00146     for(i=0; i<32; i++) {
00147         /* bap=1 mantissas */
00148         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
00149         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
00150         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
00151     }
00152     for(i=0; i<128; i++) {
00153         /* bap=2 mantissas */
00154         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
00155         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
00156         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
00157 
00158         /* bap=4 mantissas */
00159         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
00160         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
00161     }
00162     /* generate ungrouped mantissa tables
00163        reference: Tables 7.21 and 7.23 */
00164     for(i=0; i<7; i++) {
00165         /* bap=3 mantissas */
00166         b3_mantissas[i] = symmetric_dequant(i, 7);
00167     }
00168     for(i=0; i<15; i++) {
00169         /* bap=5 mantissas */
00170         b5_mantissas[i] = symmetric_dequant(i, 15);
00171     }
00172 
00173     /* generate dynamic range table
00174        reference: Section 7.7.1 Dynamic Range Control */
00175     for(i=0; i<256; i++) {
00176         int v = (i >> 5) - ((i >> 7) << 3) - 5;
00177         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
00178     }
00179 }
00180 
00181 
00185 static av_cold int ac3_decode_init(AVCodecContext *avctx)
00186 {
00187     AC3DecodeContext *s = avctx->priv_data;
00188     s->avctx = avctx;
00189 
00190     ac3_common_init();
00191     ac3_tables_init();
00192     ff_mdct_init(&s->imdct_256, 8, 1);
00193     ff_mdct_init(&s->imdct_512, 9, 1);
00194     ff_kbd_window_init(s->window, 5.0, 256);
00195     dsputil_init(&s->dsp, avctx);
00196     av_lfg_init(&s->dith_state, 0);
00197 
00198     /* set bias values for float to int16 conversion */
00199     if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
00200         s->add_bias = 385.0f;
00201         s->mul_bias = 1.0f;
00202     } else {
00203         s->add_bias = 0.0f;
00204         s->mul_bias = 32767.0f;
00205     }
00206 
00207     /* allow downmixing to stereo or mono */
00208     if (avctx->channels > 0 && avctx->request_channels > 0 &&
00209             avctx->request_channels < avctx->channels &&
00210             avctx->request_channels <= 2) {
00211         avctx->channels = avctx->request_channels;
00212     }
00213     s->downmixed = 1;
00214 
00215     /* allocate context input buffer */
00216     if (avctx->error_recognition >= FF_ER_CAREFUL) {
00217         s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
00218         if (!s->input_buffer)
00219             return AVERROR_NOMEM;
00220     }
00221 
00222     avctx->sample_fmt = SAMPLE_FMT_S16;
00223     return 0;
00224 }
00225 
00231 static int ac3_parse_header(AC3DecodeContext *s)
00232 {
00233     GetBitContext *gbc = &s->gbc;
00234     int i;
00235 
00236     /* read the rest of the bsi. read twice for dual mono mode. */
00237     i = !(s->channel_mode);
00238     do {
00239         skip_bits(gbc, 5); // skip dialog normalization
00240         if (get_bits1(gbc))
00241             skip_bits(gbc, 8); //skip compression
00242         if (get_bits1(gbc))
00243             skip_bits(gbc, 8); //skip language code
00244         if (get_bits1(gbc))
00245             skip_bits(gbc, 7); //skip audio production information
00246     } while (i--);
00247 
00248     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
00249 
00250     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
00251        TODO: read & use the xbsi1 downmix levels */
00252     if (get_bits1(gbc))
00253         skip_bits(gbc, 14); //skip timecode1 / xbsi1
00254     if (get_bits1(gbc))
00255         skip_bits(gbc, 14); //skip timecode2 / xbsi2
00256 
00257     /* skip additional bitstream info */
00258     if (get_bits1(gbc)) {
00259         i = get_bits(gbc, 6);
00260         do {
00261             skip_bits(gbc, 8);
00262         } while(i--);
00263     }
00264 
00265     return 0;
00266 }
00267 
00271 static int parse_frame_header(AC3DecodeContext *s)
00272 {
00273     AC3HeaderInfo hdr;
00274     int err;
00275 
00276     err = ff_ac3_parse_header(&s->gbc, &hdr);
00277     if(err)
00278         return err;
00279 
00280     /* get decoding parameters from header info */
00281     s->bit_alloc_params.sr_code     = hdr.sr_code;
00282     s->channel_mode                 = hdr.channel_mode;
00283     s->lfe_on                       = hdr.lfe_on;
00284     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
00285     s->sample_rate                  = hdr.sample_rate;
00286     s->bit_rate                     = hdr.bit_rate;
00287     s->channels                     = hdr.channels;
00288     s->fbw_channels                 = s->channels - s->lfe_on;
00289     s->lfe_ch                       = s->fbw_channels + 1;
00290     s->frame_size                   = hdr.frame_size;
00291     s->center_mix_level             = hdr.center_mix_level;
00292     s->surround_mix_level           = hdr.surround_mix_level;
00293     s->num_blocks                   = hdr.num_blocks;
00294     s->frame_type                   = hdr.frame_type;
00295     s->substreamid                  = hdr.substreamid;
00296 
00297     if(s->lfe_on) {
00298         s->start_freq[s->lfe_ch] = 0;
00299         s->end_freq[s->lfe_ch] = 7;
00300         s->num_exp_groups[s->lfe_ch] = 2;
00301         s->channel_in_cpl[s->lfe_ch] = 0;
00302     }
00303 
00304     if (hdr.bitstream_id <= 10) {
00305         s->eac3                  = 0;
00306         s->snr_offset_strategy   = 2;
00307         s->block_switch_syntax   = 1;
00308         s->dither_flag_syntax    = 1;
00309         s->bit_allocation_syntax = 1;
00310         s->fast_gain_syntax      = 0;
00311         s->first_cpl_leak        = 0;
00312         s->dba_syntax            = 1;
00313         s->skip_syntax           = 1;
00314         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
00315         return ac3_parse_header(s);
00316     } else {
00317         s->eac3 = 1;
00318         return ff_eac3_parse_header(s);
00319     }
00320 }
00321 
00326 static void set_downmix_coeffs(AC3DecodeContext *s)
00327 {
00328     int i;
00329     float cmix = gain_levels[center_levels[s->center_mix_level]];
00330     float smix = gain_levels[surround_levels[s->surround_mix_level]];
00331     float norm0, norm1;
00332 
00333     for(i=0; i<s->fbw_channels; i++) {
00334         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
00335         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
00336     }
00337     if(s->channel_mode > 1 && s->channel_mode & 1) {
00338         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
00339     }
00340     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
00341         int nf = s->channel_mode - 2;
00342         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
00343     }
00344     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
00345         int nf = s->channel_mode - 4;
00346         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
00347     }
00348 
00349     /* renormalize */
00350     norm0 = norm1 = 0.0;
00351     for(i=0; i<s->fbw_channels; i++) {
00352         norm0 += s->downmix_coeffs[i][0];
00353         norm1 += s->downmix_coeffs[i][1];
00354     }
00355     norm0 = 1.0f / norm0;
00356     norm1 = 1.0f / norm1;
00357     for(i=0; i<s->fbw_channels; i++) {
00358         s->downmix_coeffs[i][0] *= norm0;
00359         s->downmix_coeffs[i][1] *= norm1;
00360     }
00361 
00362     if(s->output_mode == AC3_CHMODE_MONO) {
00363         for(i=0; i<s->fbw_channels; i++)
00364             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
00365     }
00366 }
00367 
00372 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
00373                             uint8_t absexp, int8_t *dexps)
00374 {
00375     int i, j, grp, group_size;
00376     int dexp[256];
00377     int expacc, prevexp;
00378 
00379     /* unpack groups */
00380     group_size = exp_strategy + (exp_strategy == EXP_D45);
00381     for(grp=0,i=0; grp<ngrps; grp++) {
00382         expacc = get_bits(gbc, 7);
00383         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
00384         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
00385         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
00386     }
00387 
00388     /* convert to absolute exps and expand groups */
00389     prevexp = absexp;
00390     for(i=0,j=0; i<ngrps*3; i++) {
00391         prevexp += dexp[i] - 2;
00392         if (prevexp > 24U)
00393             return -1;
00394         switch (group_size) {
00395             case 4: dexps[j++] = prevexp;
00396                     dexps[j++] = prevexp;
00397             case 2: dexps[j++] = prevexp;
00398             case 1: dexps[j++] = prevexp;
00399         }
00400     }
00401     return 0;
00402 }
00403 
00409 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
00410 {
00411     int i, j, ch, bnd, subbnd;
00412 
00413     subbnd = -1;
00414     i = s->start_freq[CPL_CH];
00415     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
00416         do {
00417             subbnd++;
00418             for(j=0; j<12; j++) {
00419                 for(ch=1; ch<=s->fbw_channels; ch++) {
00420                     if(s->channel_in_cpl[ch]) {
00421                         s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
00422                         if (ch == 2 && s->phase_flags[bnd])
00423                             s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
00424                     }
00425                 }
00426                 i++;
00427             }
00428         } while(s->cpl_band_struct[subbnd]);
00429     }
00430 }
00431 
00435 typedef struct {
00436     int b1_mant[2];
00437     int b2_mant[2];
00438     int b4_mant;
00439     int b1;
00440     int b2;
00441     int b4;
00442 } mant_groups;
00443 
00448 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
00449 {
00450     int start_freq = s->start_freq[ch_index];
00451     int end_freq = s->end_freq[ch_index];
00452     uint8_t *baps = s->bap[ch_index];
00453     int8_t *exps = s->dexps[ch_index];
00454     int *coeffs = s->fixed_coeffs[ch_index];
00455     GetBitContext *gbc = &s->gbc;
00456     int freq;
00457 
00458     for(freq = start_freq; freq < end_freq; freq++){
00459         int bap = baps[freq];
00460         int mantissa;
00461         switch(bap){
00462             case 0:
00463                 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
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 
00523 static void remove_dithering(AC3DecodeContext *s) {
00524     int ch, i;
00525     int end=0;
00526     int *coeffs;
00527     uint8_t *bap;
00528 
00529     for(ch=1; ch<=s->fbw_channels; ch++) {
00530         if(!s->dither_flag[ch]) {
00531             coeffs = s->fixed_coeffs[ch];
00532             bap = s->bap[ch];
00533             if(s->channel_in_cpl[ch])
00534                 end = s->start_freq[CPL_CH];
00535             else
00536                 end = s->end_freq[ch];
00537             for(i=0; i<end; i++) {
00538                 if(!bap[i])
00539                     coeffs[i] = 0;
00540             }
00541             if(s->channel_in_cpl[ch]) {
00542                 bap = s->bap[CPL_CH];
00543                 for(; i<s->end_freq[CPL_CH]; i++) {
00544                     if(!bap[i])
00545                         coeffs[i] = 0;
00546                 }
00547             }
00548         }
00549     }
00550 }
00551 
00552 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
00553                                     mant_groups *m)
00554 {
00555     if (!s->channel_uses_aht[ch]) {
00556         ac3_decode_transform_coeffs_ch(s, ch, m);
00557     } else {
00558         /* if AHT is used, mantissas for all blocks are encoded in the first
00559            block of the frame. */
00560         int bin;
00561         if (!blk)
00562             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
00563         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
00564             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
00565         }
00566     }
00567 }
00568 
00572 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
00573 {
00574     int ch, end;
00575     int got_cplchan = 0;
00576     mant_groups m;
00577 
00578     m.b1 = m.b2 = m.b4 = 0;
00579 
00580     for (ch = 1; ch <= s->channels; ch++) {
00581         /* transform coefficients for full-bandwidth channel */
00582         decode_transform_coeffs_ch(s, blk, ch, &m);
00583         /* tranform coefficients for coupling channel come right after the
00584            coefficients for the first coupled channel*/
00585         if (s->channel_in_cpl[ch])  {
00586             if (!got_cplchan) {
00587                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
00588                 calc_transform_coeffs_cpl(s);
00589                 got_cplchan = 1;
00590             }
00591             end = s->end_freq[CPL_CH];
00592         } else {
00593             end = s->end_freq[ch];
00594         }
00595         do
00596             s->fixed_coeffs[ch][end] = 0;
00597         while(++end < 256);
00598     }
00599 
00600     /* zero the dithered coefficients for appropriate channels */
00601     remove_dithering(s);
00602 }
00603 
00608 static void do_rematrixing(AC3DecodeContext *s)
00609 {
00610     int bnd, i;
00611     int end, bndend;
00612     int tmp0, tmp1;
00613 
00614     end = FFMIN(s->end_freq[1], s->end_freq[2]);
00615 
00616     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
00617         if(s->rematrixing_flags[bnd]) {
00618             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
00619             for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
00620                 tmp0 = s->fixed_coeffs[1][i];
00621                 tmp1 = s->fixed_coeffs[2][i];
00622                 s->fixed_coeffs[1][i] = tmp0 + tmp1;
00623                 s->fixed_coeffs[2][i] = tmp0 - tmp1;
00624             }
00625         }
00626     }
00627 }
00628 
00634 static inline void do_imdct(AC3DecodeContext *s, int channels)
00635 {
00636     int ch;
00637     float add_bias = s->add_bias;
00638     if(s->out_channels==1 && channels>1)
00639         add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
00640 
00641     for (ch=1; ch<=channels; ch++) {
00642         if (s->block_switch[ch]) {
00643             int i;
00644             float *x = s->tmp_output+128;
00645             for(i=0; i<128; i++)
00646                 x[i] = s->transform_coeffs[ch][2*i];
00647             ff_imdct_half(&s->imdct_256, s->tmp_output, x);
00648             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
00649             for(i=0; i<128; i++)
00650                 x[i] = s->transform_coeffs[ch][2*i+1];
00651             ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
00652         } else {
00653             ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
00654             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
00655             memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
00656         }
00657     }
00658 }
00659 
00663 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
00664 {
00665     int i, j;
00666     float v0, v1;
00667     if(out_ch == 2) {
00668         for(i=0; i<len; i++) {
00669             v0 = v1 = 0.0f;
00670             for(j=0; j<in_ch; j++) {
00671                 v0 += samples[j][i] * matrix[j][0];
00672                 v1 += samples[j][i] * matrix[j][1];
00673             }
00674             samples[0][i] = v0;
00675             samples[1][i] = v1;
00676         }
00677     } else if(out_ch == 1) {
00678         for(i=0; i<len; i++) {
00679             v0 = 0.0f;
00680             for(j=0; j<in_ch; j++)
00681                 v0 += samples[j][i] * matrix[j][0];
00682             samples[0][i] = v0;
00683         }
00684     }
00685 }
00686 
00690 static void ac3_upmix_delay(AC3DecodeContext *s)
00691 {
00692     int channel_data_size = sizeof(s->delay[0]);
00693     switch(s->channel_mode) {
00694         case AC3_CHMODE_DUALMONO:
00695         case AC3_CHMODE_STEREO:
00696             /* upmix mono to stereo */
00697             memcpy(s->delay[1], s->delay[0], channel_data_size);
00698             break;
00699         case AC3_CHMODE_2F2R:
00700             memset(s->delay[3], 0, channel_data_size);
00701         case AC3_CHMODE_2F1R:
00702             memset(s->delay[2], 0, channel_data_size);
00703             break;
00704         case AC3_CHMODE_3F2R:
00705             memset(s->delay[4], 0, channel_data_size);
00706         case AC3_CHMODE_3F1R:
00707             memset(s->delay[3], 0, channel_data_size);
00708         case AC3_CHMODE_3F:
00709             memcpy(s->delay[2], s->delay[1], channel_data_size);
00710             memset(s->delay[1], 0, channel_data_size);
00711             break;
00712     }
00713 }
00714 
00729 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
00730                                   int ecpl, int start_subband, int end_subband,
00731                                   const uint8_t *default_band_struct,
00732                                   uint8_t *band_struct, int *num_subbands,
00733                                   int *num_bands, uint8_t *band_sizes)
00734 {
00735     int subbnd, bnd, n_subbands, n_bands=0;
00736     uint8_t bnd_sz[22];
00737 
00738     n_subbands = end_subband - start_subband;
00739 
00740     /* decode band structure from bitstream or use default */
00741     if (!eac3 || get_bits1(gbc)) {
00742         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
00743             band_struct[subbnd] = get_bits1(gbc);
00744         }
00745     } else if (!blk) {
00746         memcpy(band_struct,
00747                &default_band_struct[start_subband+1],
00748                n_subbands-1);
00749     }
00750     band_struct[n_subbands-1] = 0;
00751 
00752     /* calculate number of bands and band sizes based on band structure.
00753        note that the first 4 subbands in enhanced coupling span only 6 bins
00754        instead of 12. */
00755     if (num_bands || band_sizes ) {
00756         n_bands = n_subbands;
00757         bnd_sz[0] = ecpl ? 6 : 12;
00758         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
00759             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
00760             if (band_struct[subbnd-1]) {
00761                 n_bands--;
00762                 bnd_sz[bnd] += subbnd_size;
00763             } else {
00764                 bnd_sz[++bnd] = subbnd_size;
00765             }
00766         }
00767     }
00768 
00769     /* set optional output params */
00770     if (num_subbands)
00771         *num_subbands = n_subbands;
00772     if (num_bands)
00773         *num_bands = n_bands;
00774     if (band_sizes)
00775         memcpy(band_sizes, bnd_sz, n_bands);
00776 }
00777 
00781 static int decode_audio_block(AC3DecodeContext *s, int blk)
00782 {
00783     int fbw_channels = s->fbw_channels;
00784     int channel_mode = s->channel_mode;
00785     int i, bnd, seg, ch;
00786     int different_transforms;
00787     int downmix_output;
00788     int cpl_in_use;
00789     GetBitContext *gbc = &s->gbc;
00790     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
00791 
00792     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
00793 
00794     /* block switch flags */
00795     different_transforms = 0;
00796     if (s->block_switch_syntax) {
00797         for (ch = 1; ch <= fbw_channels; ch++) {
00798             s->block_switch[ch] = get_bits1(gbc);
00799             if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
00800                 different_transforms = 1;
00801         }
00802     }
00803 
00804     /* dithering flags */
00805     if (s->dither_flag_syntax) {
00806         for (ch = 1; ch <= fbw_channels; ch++) {
00807             s->dither_flag[ch] = get_bits1(gbc);
00808         }
00809     }
00810 
00811     /* dynamic range */
00812     i = !(s->channel_mode);
00813     do {
00814         if(get_bits1(gbc)) {
00815             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
00816                                   s->avctx->drc_scale)+1.0;
00817         } else if(blk == 0) {
00818             s->dynamic_range[i] = 1.0f;
00819         }
00820     } while(i--);
00821 
00822     /* spectral extension strategy */
00823     if (s->eac3 && (!blk || get_bits1(gbc))) {
00824         if (get_bits1(gbc)) {
00825             ff_log_missing_feature(s->avctx, "Spectral extension", 1);
00826             return -1;
00827         }
00828         /* TODO: parse spectral extension strategy info */
00829     }
00830 
00831     /* TODO: spectral extension coordinates */
00832 
00833     /* coupling strategy */
00834     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
00835         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00836         if (!s->eac3)
00837             s->cpl_in_use[blk] = get_bits1(gbc);
00838         if (s->cpl_in_use[blk]) {
00839             /* coupling in use */
00840             int cpl_start_subband, cpl_end_subband;
00841 
00842             if (channel_mode < AC3_CHMODE_STEREO) {
00843                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
00844                 return -1;
00845             }
00846 
00847             /* check for enhanced coupling */
00848             if (s->eac3 && get_bits1(gbc)) {
00849                 /* TODO: parse enhanced coupling strategy info */
00850                 ff_log_missing_feature(s->avctx, "Enhanced coupling", 1);
00851                 return -1;
00852             }
00853 
00854             /* determine which channels are coupled */
00855             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
00856                 s->channel_in_cpl[1] = 1;
00857                 s->channel_in_cpl[2] = 1;
00858             } else {
00859                 for (ch = 1; ch <= fbw_channels; ch++)
00860                     s->channel_in_cpl[ch] = get_bits1(gbc);
00861             }
00862 
00863             /* phase flags in use */
00864             if (channel_mode == AC3_CHMODE_STEREO)
00865                 s->phase_flags_in_use = get_bits1(gbc);
00866 
00867             /* coupling frequency range */
00868             /* TODO: modify coupling end freq if spectral extension is used */
00869             cpl_start_subband = get_bits(gbc, 4);
00870             cpl_end_subband   = get_bits(gbc, 4) + 3;
00871             s->num_cpl_subbands = cpl_end_subband - cpl_start_subband;
00872             if (s->num_cpl_subbands < 0) {
00873                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d > %d)\n",
00874                        cpl_start_subband, cpl_end_subband);
00875                 return -1;
00876             }
00877             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
00878             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
00879 
00880            decode_band_structure(gbc, blk, s->eac3, 0,
00881                                  cpl_start_subband, cpl_end_subband,
00882                                  ff_eac3_default_cpl_band_struct,
00883                                  s->cpl_band_struct, &s->num_cpl_subbands,
00884                                  &s->num_cpl_bands, NULL);
00885         } else {
00886             /* coupling not in use */
00887             for (ch = 1; ch <= fbw_channels; ch++) {
00888                 s->channel_in_cpl[ch] = 0;
00889                 s->first_cpl_coords[ch] = 1;
00890             }
00891             s->first_cpl_leak = s->eac3;
00892             s->phase_flags_in_use = 0;
00893         }
00894     } else if (!s->eac3) {
00895         if(!blk) {
00896             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
00897             return -1;
00898         } else {
00899             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
00900         }
00901     }
00902     cpl_in_use = s->cpl_in_use[blk];
00903 
00904     /* coupling coordinates */
00905     if (cpl_in_use) {
00906         int cpl_coords_exist = 0;
00907 
00908         for (ch = 1; ch <= fbw_channels; ch++) {
00909             if (s->channel_in_cpl[ch]) {
00910                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
00911                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
00912                     s->first_cpl_coords[ch] = 0;
00913                     cpl_coords_exist = 1;
00914                     master_cpl_coord = 3 * get_bits(gbc, 2);
00915                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
00916                         cpl_coord_exp = get_bits(gbc, 4);
00917                         cpl_coord_mant = get_bits(gbc, 4);
00918                         if (cpl_coord_exp == 15)
00919                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
00920                         else
00921                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
00922                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
00923                     }
00924                 } else if (!blk) {
00925                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
00926                     return -1;
00927                 }
00928             } else {
00929                 /* channel not in coupling */
00930                 s->first_cpl_coords[ch] = 1;
00931             }
00932         }
00933         /* phase flags */
00934         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
00935             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
00936                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
00937             }
00938         }
00939     }
00940 
00941     /* stereo rematrixing strategy and band structure */
00942     if (channel_mode == AC3_CHMODE_STEREO) {
00943         if ((s->eac3 && !blk) || get_bits1(gbc)) {
00944             s->num_rematrixing_bands = 4;
00945             if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
00946                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
00947             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
00948                 s->rematrixing_flags[bnd] = get_bits1(gbc);
00949         } else if (!blk) {
00950             av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
00951             return -1;
00952         }
00953     }
00954 
00955     /* exponent strategies for each channel */
00956     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
00957         if (!s->eac3)
00958             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
00959         if(s->exp_strategy[blk][ch] != EXP_REUSE)
00960             bit_alloc_stages[ch] = 3;
00961     }
00962 
00963     /* channel bandwidth */
00964     for (ch = 1; ch <= fbw_channels; ch++) {
00965         s->start_freq[ch] = 0;
00966         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
00967             int group_size;
00968             int prev = s->end_freq[ch];
00969             if (s->channel_in_cpl[ch])
00970                 s->end_freq[ch] = s->start_freq[CPL_CH];
00971             else {
00972                 int bandwidth_code = get_bits(gbc, 6);
00973                 if (bandwidth_code > 60) {
00974                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
00975                     return -1;
00976                 }
00977                 s->end_freq[ch] = bandwidth_code * 3 + 73;
00978             }
00979             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
00980             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
00981             if(blk > 0 && s->end_freq[ch] != prev)
00982                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00983         }
00984     }
00985     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
00986         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
00987                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
00988     }
00989 
00990     /* decode exponents for each channel */
00991     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
00992         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
00993             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
00994             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
00995                                  s->num_exp_groups[ch], s->dexps[ch][0],
00996                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
00997                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
00998                 return -1;
00999             }
01000             if(ch != CPL_CH && ch != s->lfe_ch)
01001                 skip_bits(gbc, 2); /* skip gainrng */
01002         }
01003     }
01004 
01005     /* bit allocation information */
01006     if (s->bit_allocation_syntax) {
01007         if (get_bits1(gbc)) {
01008             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01009             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01010             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
01011             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
01012             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
01013             for(ch=!cpl_in_use; ch<=s->channels; ch++)
01014                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01015         } else if (!blk) {
01016             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
01017             return -1;
01018         }
01019     }
01020 
01021     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
01022     if(!s->eac3 || !blk){
01023         if(s->snr_offset_strategy && get_bits1(gbc)) {
01024             int snr = 0;
01025             int csnr;
01026             csnr = (get_bits(gbc, 6) - 15) << 4;
01027             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
01028                 /* snr offset */
01029                 if (ch == i || s->snr_offset_strategy == 2)
01030                     snr = (csnr + get_bits(gbc, 4)) << 2;
01031                 /* run at least last bit allocation stage if snr offset changes */
01032                 if(blk && s->snr_offset[ch] != snr) {
01033                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
01034                 }
01035                 s->snr_offset[ch] = snr;
01036 
01037                 /* fast gain (normal AC-3 only) */
01038                 if (!s->eac3) {
01039                     int prev = s->fast_gain[ch];
01040                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01041                     /* run last 2 bit allocation stages if fast gain changes */
01042                     if(blk && prev != s->fast_gain[ch])
01043                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01044                 }
01045             }
01046         } else if (!s->eac3 && !blk) {
01047             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
01048             return -1;
01049         }
01050     }
01051 
01052     /* fast gain (E-AC-3 only) */
01053     if (s->fast_gain_syntax && get_bits1(gbc)) {
01054         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01055             int prev = s->fast_gain[ch];
01056             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01057             /* run last 2 bit allocation stages if fast gain changes */
01058             if(blk && prev != s->fast_gain[ch])
01059                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01060         }
01061     } else if (s->eac3 && !blk) {
01062         for (ch = !cpl_in_use; ch <= s->channels; ch++)
01063             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
01064     }
01065 
01066     /* E-AC-3 to AC-3 converter SNR offset */
01067     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
01068         skip_bits(gbc, 10); // skip converter snr offset
01069     }
01070 
01071     /* coupling leak information */
01072     if (cpl_in_use) {
01073         if (s->first_cpl_leak || get_bits1(gbc)) {
01074             int fl = get_bits(gbc, 3);
01075             int sl = get_bits(gbc, 3);
01076             /* run last 2 bit allocation stages for coupling channel if
01077                coupling leak changes */
01078             if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
01079                        sl != s->bit_alloc_params.cpl_slow_leak)) {
01080                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
01081             }
01082             s->bit_alloc_params.cpl_fast_leak = fl;
01083             s->bit_alloc_params.cpl_slow_leak = sl;
01084         } else if (!s->eac3 && !blk) {
01085             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
01086             return -1;
01087         }
01088         s->first_cpl_leak = 0;
01089     }
01090 
01091     /* delta bit allocation information */
01092     if (s->dba_syntax && get_bits1(gbc)) {
01093         /* delta bit allocation exists (strategy) */
01094         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01095             s->dba_mode[ch] = get_bits(gbc, 2);
01096             if (s->dba_mode[ch] == DBA_RESERVED) {
01097                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
01098                 return -1;
01099             }
01100             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01101         }
01102         /* channel delta offset, len and bit allocation */
01103         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01104             if (s->dba_mode[ch] == DBA_NEW) {
01105                 s->dba_nsegs[ch] = get_bits(gbc, 3);
01106                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
01107                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
01108                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
01109                     s->dba_values[ch][seg] = get_bits(gbc, 3);
01110                 }
01111                 /* run last 2 bit allocation stages if new dba values */
01112                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01113             }
01114         }
01115     } else if(blk == 0) {
01116         for(ch=0; ch<=s->channels; ch++) {
01117             s->dba_mode[ch] = DBA_NONE;
01118         }
01119     }
01120 
01121     /* Bit allocation */
01122     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
01123         if(bit_alloc_stages[ch] > 2) {
01124             /* Exponent mapping into PSD and PSD integration */
01125             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
01126                                       s->start_freq[ch], s->end_freq[ch],
01127                                       s->psd[ch], s->band_psd[ch]);
01128         }
01129         if(bit_alloc_stages[ch] > 1) {
01130             /* Compute excitation function, Compute masking curve, and
01131                Apply delta bit allocation */
01132             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
01133                                            s->start_freq[ch], s->end_freq[ch],
01134                                            s->fast_gain[ch], (ch == s->lfe_ch),
01135                                            s->dba_mode[ch], s->dba_nsegs[ch],
01136                                            s->dba_offsets[ch], s->dba_lengths[ch],
01137                                            s->dba_values[ch], s->mask[ch])) {
01138                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
01139                 return -1;
01140             }
01141         }
01142         if(bit_alloc_stages[ch] > 0) {
01143             /* Compute bit allocation */
01144             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
01145                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
01146             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
01147                                       s->start_freq[ch], s->end_freq[ch],
01148                                       s->snr_offset[ch],
01149                                       s->bit_alloc_params.floor,
01150                                       bap_tab, s->bap[ch]);
01151         }
01152     }
01153 
01154     /* unused dummy data */
01155     if (s->skip_syntax && get_bits1(gbc)) {
01156         int skipl = get_bits(gbc, 9);
01157         while(skipl--)
01158             skip_bits(gbc, 8);
01159     }
01160 
01161     /* unpack the transform coefficients
01162        this also uncouples channels if coupling is in use. */
01163     decode_transform_coeffs(s, blk);
01164 
01165     /* TODO: generate enhanced coupling coordinates and uncouple */
01166 
01167     /* TODO: apply spectral extension */
01168 
01169     /* recover coefficients if rematrixing is in use */
01170     if(s->channel_mode == AC3_CHMODE_STEREO)
01171         do_rematrixing(s);
01172 
01173     /* apply scaling to coefficients (headroom, dynrng) */
01174     for(ch=1; ch<=s->channels; ch++) {
01175         float gain = s->mul_bias / 4194304.0f;
01176         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
01177             gain *= s->dynamic_range[ch-1];
01178         } else {
01179             gain *= s->dynamic_range[0];
01180         }
01181         s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
01182     }
01183 
01184     /* downmix and MDCT. order depends on whether block switching is used for
01185        any channel in this block. this is because coefficients for the long
01186        and short transforms cannot be mixed. */
01187     downmix_output = s->channels != s->out_channels &&
01188                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
01189                      s->fbw_channels == s->out_channels);
01190     if(different_transforms) {
01191         /* the delay samples have already been downmixed, so we upmix the delay
01192            samples in order to reconstruct all channels before downmixing. */
01193         if(s->downmixed) {
01194             s->downmixed = 0;
01195             ac3_upmix_delay(s);
01196         }
01197 
01198         do_imdct(s, s->channels);
01199 
01200         if(downmix_output) {
01201             s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
01202         }
01203     } else {
01204         if(downmix_output) {
01205             s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
01206         }
01207 
01208         if(downmix_output && !s->downmixed) {
01209             s->downmixed = 1;
01210             s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
01211         }
01212 
01213         do_imdct(s, s->out_channels);
01214     }
01215 
01216     return 0;
01217 }
01218 
01222 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
01223                             const uint8_t *buf, int buf_size)
01224 {
01225     AC3DecodeContext *s = avctx->priv_data;
01226     int16_t *out_samples = (int16_t *)data;
01227     int blk, ch, err;
01228 
01229     /* initialize the GetBitContext with the start of valid AC-3 Frame */
01230     if (s->input_buffer) {
01231         /* copy input buffer to decoder context to avoid reading past the end
01232            of the buffer, which can be caused by a damaged input stream. */
01233         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
01234         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
01235     } else {
01236         init_get_bits(&s->gbc, buf, buf_size * 8);
01237     }
01238 
01239     /* parse the syncinfo */
01240     *data_size = 0;
01241     err = parse_frame_header(s);
01242 
01243     /* check that reported frame size fits in input buffer */
01244     if(s->frame_size > buf_size) {
01245         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
01246         err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
01247     }
01248 
01249     /* check for crc mismatch */
01250     if(err != AAC_AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_recognition >= FF_ER_CAREFUL) {
01251         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
01252             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
01253             err = AAC_AC3_PARSE_ERROR_CRC;
01254         }
01255     }
01256 
01257     if(err && err != AAC_AC3_PARSE_ERROR_CRC) {
01258         switch(err) {
01259             case AAC_AC3_PARSE_ERROR_SYNC:
01260                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
01261                 return -1;
01262             case AAC_AC3_PARSE_ERROR_BSID:
01263                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
01264                 break;
01265             case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
01266                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
01267                 break;
01268             case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
01269                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
01270                 break;
01271             case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
01272                 /* skip frame if CRC is ok. otherwise use error concealment. */
01273                 /* TODO: add support for substreams and dependent frames */
01274                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
01275                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
01276                     return s->frame_size;
01277                 } else {
01278                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
01279                 }
01280                 break;
01281             default:
01282                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
01283                 break;
01284         }
01285     }
01286 
01287     /* if frame is ok, set audio parameters */
01288     if (!err) {
01289         avctx->sample_rate = s->sample_rate;
01290         avctx->bit_rate = s->bit_rate;
01291 
01292         /* channel config */
01293         s->out_channels = s->channels;
01294         s->output_mode = s->channel_mode;
01295         if(s->lfe_on)
01296             s->output_mode |= AC3_OUTPUT_LFEON;
01297         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
01298                 avctx->request_channels < s->channels) {
01299             s->out_channels = avctx->request_channels;
01300             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01301         }
01302         avctx->channels = s->out_channels;
01303 
01304         /* set downmixing coefficients if needed */
01305         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
01306                 s->fbw_channels == s->out_channels)) {
01307             set_downmix_coeffs(s);
01308         }
01309     } else if (!s->out_channels) {
01310         s->out_channels = avctx->channels;
01311         if(s->out_channels < s->channels)
01312             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01313     }
01314 
01315     /* decode the audio blocks */
01316     for (blk = 0; blk < s->num_blocks; blk++) {
01317         const float *output[s->out_channels];
01318         if (!err && decode_audio_block(s, blk)) {
01319             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
01320             err = 1;
01321         }
01322         for (ch = 0; ch < s->out_channels; ch++)
01323             output[ch] = s->output[ch];
01324         s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
01325         out_samples += 256 * s->out_channels;
01326     }
01327     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
01328     return s->frame_size;
01329 }
01330 
01334 static av_cold int ac3_decode_end(AVCodecContext *avctx)
01335 {
01336     AC3DecodeContext *s = avctx->priv_data;
01337     ff_mdct_end(&s->imdct_512);
01338     ff_mdct_end(&s->imdct_256);
01339 
01340     av_freep(&s->input_buffer);
01341 
01342     return 0;
01343 }
01344 
01345 AVCodec ac3_decoder = {
01346     .name = "ac3",
01347     .type = CODEC_TYPE_AUDIO,
01348     .id = CODEC_ID_AC3,
01349     .priv_data_size = sizeof (AC3DecodeContext),
01350     .init = ac3_decode_init,
01351     .close = ac3_decode_end,
01352     .decode = ac3_decode_frame,
01353     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
01354 };
01355 
01356 AVCodec eac3_decoder = {
01357     .name = "eac3",
01358     .type = CODEC_TYPE_AUDIO,
01359     .id = CODEC_ID_EAC3,
01360     .priv_data_size = sizeof (AC3DecodeContext),
01361     .init = ac3_decode_init,
01362     .close = ac3_decode_end,
01363     .decode = ac3_decode_frame,
01364     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
01365 };

Generated on Sat Feb 16 2013 09:23:11 for ffmpeg by  doxygen 1.7.1