• 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, 1.0);
00193     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
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(ENOMEM);
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->channel_layout               = hdr.channel_layout;
00284     s->lfe_on                       = hdr.lfe_on;
00285     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
00286     s->sample_rate                  = hdr.sample_rate;
00287     s->bit_rate                     = hdr.bit_rate;
00288     s->channels                     = hdr.channels;
00289     s->fbw_channels                 = s->channels - s->lfe_on;
00290     s->lfe_ch                       = s->fbw_channels + 1;
00291     s->frame_size                   = hdr.frame_size;
00292     s->center_mix_level             = hdr.center_mix_level;
00293     s->surround_mix_level           = hdr.surround_mix_level;
00294     s->num_blocks                   = hdr.num_blocks;
00295     s->frame_type                   = hdr.frame_type;
00296     s->substreamid                  = hdr.substreamid;
00297 
00298     if(s->lfe_on) {
00299         s->start_freq[s->lfe_ch] = 0;
00300         s->end_freq[s->lfe_ch] = 7;
00301         s->num_exp_groups[s->lfe_ch] = 2;
00302         s->channel_in_cpl[s->lfe_ch] = 0;
00303     }
00304 
00305     if (hdr.bitstream_id <= 10) {
00306         s->eac3                  = 0;
00307         s->snr_offset_strategy   = 2;
00308         s->block_switch_syntax   = 1;
00309         s->dither_flag_syntax    = 1;
00310         s->bit_allocation_syntax = 1;
00311         s->fast_gain_syntax      = 0;
00312         s->first_cpl_leak        = 0;
00313         s->dba_syntax            = 1;
00314         s->skip_syntax           = 1;
00315         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
00316         return ac3_parse_header(s);
00317     } else if (CONFIG_EAC3_DECODER) {
00318         s->eac3 = 1;
00319         return ff_eac3_parse_header(s);
00320     } else {
00321         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
00322         return -1;
00323     }
00324 }
00325 
00330 static void set_downmix_coeffs(AC3DecodeContext *s)
00331 {
00332     int i;
00333     float cmix = gain_levels[center_levels[s->center_mix_level]];
00334     float smix = gain_levels[surround_levels[s->surround_mix_level]];
00335     float norm0, norm1;
00336 
00337     for(i=0; i<s->fbw_channels; i++) {
00338         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
00339         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
00340     }
00341     if(s->channel_mode > 1 && s->channel_mode & 1) {
00342         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
00343     }
00344     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
00345         int nf = s->channel_mode - 2;
00346         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
00347     }
00348     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
00349         int nf = s->channel_mode - 4;
00350         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
00351     }
00352 
00353     /* renormalize */
00354     norm0 = norm1 = 0.0;
00355     for(i=0; i<s->fbw_channels; i++) {
00356         norm0 += s->downmix_coeffs[i][0];
00357         norm1 += s->downmix_coeffs[i][1];
00358     }
00359     norm0 = 1.0f / norm0;
00360     norm1 = 1.0f / norm1;
00361     for(i=0; i<s->fbw_channels; i++) {
00362         s->downmix_coeffs[i][0] *= norm0;
00363         s->downmix_coeffs[i][1] *= norm1;
00364     }
00365 
00366     if(s->output_mode == AC3_CHMODE_MONO) {
00367         for(i=0; i<s->fbw_channels; i++)
00368             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
00369     }
00370 }
00371 
00376 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
00377                             uint8_t absexp, int8_t *dexps)
00378 {
00379     int i, j, grp, group_size;
00380     int dexp[256];
00381     int expacc, prevexp;
00382 
00383     /* unpack groups */
00384     group_size = exp_strategy + (exp_strategy == EXP_D45);
00385     for(grp=0,i=0; grp<ngrps; grp++) {
00386         expacc = get_bits(gbc, 7);
00387         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
00388         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
00389         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
00390     }
00391 
00392     /* convert to absolute exps and expand groups */
00393     prevexp = absexp;
00394     for(i=0,j=0; i<ngrps*3; i++) {
00395         prevexp += dexp[i] - 2;
00396         if (prevexp > 24U)
00397             return -1;
00398         switch (group_size) {
00399             case 4: dexps[j++] = prevexp;
00400                     dexps[j++] = prevexp;
00401             case 2: dexps[j++] = prevexp;
00402             case 1: dexps[j++] = prevexp;
00403         }
00404     }
00405     return 0;
00406 }
00407 
00413 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
00414 {
00415     int bin, band, ch;
00416 
00417     bin = s->start_freq[CPL_CH];
00418     for (band = 0; band < s->num_cpl_bands; band++) {
00419         int band_start = bin;
00420         int band_end = bin + s->cpl_band_sizes[band];
00421         for (ch = 1; ch <= s->fbw_channels; ch++) {
00422             if (s->channel_in_cpl[ch]) {
00423                 int cpl_coord = s->cpl_coords[ch][band] << 5;
00424                 for (bin = band_start; bin < band_end; bin++) {
00425                     s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
00426                 }
00427                 if (ch == 2 && s->phase_flags[band]) {
00428                     for (bin = band_start; bin < band_end; bin++)
00429                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
00430                 }
00431             }
00432         }
00433         bin = band_end;
00434     }
00435 }
00436 
00440 typedef struct {
00441     int b1_mant[2];
00442     int b2_mant[2];
00443     int b4_mant;
00444     int b1;
00445     int b2;
00446     int b4;
00447 } mant_groups;
00448 
00453 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
00454 {
00455     int start_freq = s->start_freq[ch_index];
00456     int end_freq = s->end_freq[ch_index];
00457     uint8_t *baps = s->bap[ch_index];
00458     int8_t *exps = s->dexps[ch_index];
00459     int *coeffs = s->fixed_coeffs[ch_index];
00460     int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
00461     GetBitContext *gbc = &s->gbc;
00462     int freq;
00463 
00464     for(freq = start_freq; freq < end_freq; freq++){
00465         int bap = baps[freq];
00466         int mantissa;
00467         switch(bap){
00468             case 0:
00469                 if (dither)
00470                     mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
00471                 else
00472                     mantissa = 0;
00473                 break;
00474             case 1:
00475                 if(m->b1){
00476                     m->b1--;
00477                     mantissa = m->b1_mant[m->b1];
00478                 }
00479                 else{
00480                     int bits      = get_bits(gbc, 5);
00481                     mantissa      = b1_mantissas[bits][0];
00482                     m->b1_mant[1] = b1_mantissas[bits][1];
00483                     m->b1_mant[0] = b1_mantissas[bits][2];
00484                     m->b1         = 2;
00485                 }
00486                 break;
00487             case 2:
00488                 if(m->b2){
00489                     m->b2--;
00490                     mantissa = m->b2_mant[m->b2];
00491                 }
00492                 else{
00493                     int bits      = get_bits(gbc, 7);
00494                     mantissa      = b2_mantissas[bits][0];
00495                     m->b2_mant[1] = b2_mantissas[bits][1];
00496                     m->b2_mant[0] = b2_mantissas[bits][2];
00497                     m->b2         = 2;
00498                 }
00499                 break;
00500             case 3:
00501                 mantissa = b3_mantissas[get_bits(gbc, 3)];
00502                 break;
00503             case 4:
00504                 if(m->b4){
00505                     m->b4 = 0;
00506                     mantissa = m->b4_mant;
00507                 }
00508                 else{
00509                     int bits   = get_bits(gbc, 7);
00510                     mantissa   = b4_mantissas[bits][0];
00511                     m->b4_mant = b4_mantissas[bits][1];
00512                     m->b4      = 1;
00513                 }
00514                 break;
00515             case 5:
00516                 mantissa = b5_mantissas[get_bits(gbc, 4)];
00517                 break;
00518             default: /* 6 to 15 */
00519                 mantissa = get_bits(gbc, quantization_tab[bap]);
00520                 /* Shift mantissa and sign-extend it. */
00521                 mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
00522                 break;
00523         }
00524         coeffs[freq] = mantissa >> exps[freq];
00525     }
00526 }
00527 
00533 static void remove_dithering(AC3DecodeContext *s) {
00534     int ch, i;
00535 
00536     for(ch=1; ch<=s->fbw_channels; ch++) {
00537         if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
00538             for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
00539                 if(!s->bap[CPL_CH][i])
00540                     s->fixed_coeffs[ch][i] = 0;
00541             }
00542         }
00543     }
00544 }
00545 
00546 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
00547                                     mant_groups *m)
00548 {
00549     if (!s->channel_uses_aht[ch]) {
00550         ac3_decode_transform_coeffs_ch(s, ch, m);
00551     } else {
00552         /* if AHT is used, mantissas for all blocks are encoded in the first
00553            block of the frame. */
00554         int bin;
00555         if (!blk && CONFIG_EAC3_DECODER)
00556             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
00557         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
00558             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
00559         }
00560     }
00561 }
00562 
00566 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
00567 {
00568     int ch, end;
00569     int got_cplchan = 0;
00570     mant_groups m;
00571 
00572     m.b1 = m.b2 = m.b4 = 0;
00573 
00574     for (ch = 1; ch <= s->channels; ch++) {
00575         /* transform coefficients for full-bandwidth channel */
00576         decode_transform_coeffs_ch(s, blk, ch, &m);
00577         /* tranform coefficients for coupling channel come right after the
00578            coefficients for the first coupled channel*/
00579         if (s->channel_in_cpl[ch])  {
00580             if (!got_cplchan) {
00581                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
00582                 calc_transform_coeffs_cpl(s);
00583                 got_cplchan = 1;
00584             }
00585             end = s->end_freq[CPL_CH];
00586         } else {
00587             end = s->end_freq[ch];
00588         }
00589         do
00590             s->fixed_coeffs[ch][end] = 0;
00591         while(++end < 256);
00592     }
00593 
00594     /* zero the dithered coefficients for appropriate channels */
00595     remove_dithering(s);
00596 }
00597 
00602 static void do_rematrixing(AC3DecodeContext *s)
00603 {
00604     int bnd, i;
00605     int end, bndend;
00606 
00607     end = FFMIN(s->end_freq[1], s->end_freq[2]);
00608 
00609     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
00610         if(s->rematrixing_flags[bnd]) {
00611             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
00612             for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
00613                 int tmp0 = s->fixed_coeffs[1][i];
00614                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
00615                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
00616             }
00617         }
00618     }
00619 }
00620 
00626 static inline void do_imdct(AC3DecodeContext *s, int channels)
00627 {
00628     int ch;
00629     float add_bias = s->add_bias;
00630     if(s->out_channels==1 && channels>1)
00631         add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
00632 
00633     for (ch=1; ch<=channels; ch++) {
00634         if (s->block_switch[ch]) {
00635             int i;
00636             float *x = s->tmp_output+128;
00637             for(i=0; i<128; i++)
00638                 x[i] = s->transform_coeffs[ch][2*i];
00639             ff_imdct_half(&s->imdct_256, s->tmp_output, x);
00640             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
00641             for(i=0; i<128; i++)
00642                 x[i] = s->transform_coeffs[ch][2*i+1];
00643             ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
00644         } else {
00645             ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
00646             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
00647             memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
00648         }
00649     }
00650 }
00651 
00655 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
00656 {
00657     int i, j;
00658     float v0, v1;
00659     if(out_ch == 2) {
00660         for(i=0; i<len; i++) {
00661             v0 = v1 = 0.0f;
00662             for(j=0; j<in_ch; j++) {
00663                 v0 += samples[j][i] * matrix[j][0];
00664                 v1 += samples[j][i] * matrix[j][1];
00665             }
00666             samples[0][i] = v0;
00667             samples[1][i] = v1;
00668         }
00669     } else if(out_ch == 1) {
00670         for(i=0; i<len; i++) {
00671             v0 = 0.0f;
00672             for(j=0; j<in_ch; j++)
00673                 v0 += samples[j][i] * matrix[j][0];
00674             samples[0][i] = v0;
00675         }
00676     }
00677 }
00678 
00682 static void ac3_upmix_delay(AC3DecodeContext *s)
00683 {
00684     int channel_data_size = sizeof(s->delay[0]);
00685     switch(s->channel_mode) {
00686         case AC3_CHMODE_DUALMONO:
00687         case AC3_CHMODE_STEREO:
00688             /* upmix mono to stereo */
00689             memcpy(s->delay[1], s->delay[0], channel_data_size);
00690             break;
00691         case AC3_CHMODE_2F2R:
00692             memset(s->delay[3], 0, channel_data_size);
00693         case AC3_CHMODE_2F1R:
00694             memset(s->delay[2], 0, channel_data_size);
00695             break;
00696         case AC3_CHMODE_3F2R:
00697             memset(s->delay[4], 0, channel_data_size);
00698         case AC3_CHMODE_3F1R:
00699             memset(s->delay[3], 0, channel_data_size);
00700         case AC3_CHMODE_3F:
00701             memcpy(s->delay[2], s->delay[1], channel_data_size);
00702             memset(s->delay[1], 0, channel_data_size);
00703             break;
00704     }
00705 }
00706 
00723 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
00724                                   int ecpl, int start_subband, int end_subband,
00725                                   const uint8_t *default_band_struct,
00726                                   int *num_bands, uint8_t *band_sizes)
00727 {
00728     int subbnd, bnd, n_subbands, n_bands=0;
00729     uint8_t bnd_sz[22];
00730     uint8_t coded_band_struct[22];
00731     const uint8_t *band_struct;
00732 
00733     n_subbands = end_subband - start_subband;
00734 
00735     /* decode band structure from bitstream or use default */
00736     if (!eac3 || get_bits1(gbc)) {
00737         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
00738             coded_band_struct[subbnd] = get_bits1(gbc);
00739         }
00740         band_struct = coded_band_struct;
00741     } else if (!blk) {
00742         band_struct = &default_band_struct[start_subband+1];
00743     } else {
00744         /* no change in band structure */
00745         return;
00746     }
00747 
00748     /* calculate number of bands and band sizes based on band structure.
00749        note that the first 4 subbands in enhanced coupling span only 6 bins
00750        instead of 12. */
00751     if (num_bands || band_sizes ) {
00752         n_bands = n_subbands;
00753         bnd_sz[0] = ecpl ? 6 : 12;
00754         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
00755             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
00756             if (band_struct[subbnd-1]) {
00757                 n_bands--;
00758                 bnd_sz[bnd] += subbnd_size;
00759             } else {
00760                 bnd_sz[++bnd] = subbnd_size;
00761             }
00762         }
00763     }
00764 
00765     /* set optional output params */
00766     if (num_bands)
00767         *num_bands = n_bands;
00768     if (band_sizes)
00769         memcpy(band_sizes, bnd_sz, n_bands);
00770 }
00771 
00775 static int decode_audio_block(AC3DecodeContext *s, int blk)
00776 {
00777     int fbw_channels = s->fbw_channels;
00778     int channel_mode = s->channel_mode;
00779     int i, bnd, seg, ch;
00780     int different_transforms;
00781     int downmix_output;
00782     int cpl_in_use;
00783     GetBitContext *gbc = &s->gbc;
00784     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
00785 
00786     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
00787 
00788     /* block switch flags */
00789     different_transforms = 0;
00790     if (s->block_switch_syntax) {
00791         for (ch = 1; ch <= fbw_channels; ch++) {
00792             s->block_switch[ch] = get_bits1(gbc);
00793             if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
00794                 different_transforms = 1;
00795         }
00796     }
00797 
00798     /* dithering flags */
00799     if (s->dither_flag_syntax) {
00800         for (ch = 1; ch <= fbw_channels; ch++) {
00801             s->dither_flag[ch] = get_bits1(gbc);
00802         }
00803     }
00804 
00805     /* dynamic range */
00806     i = !(s->channel_mode);
00807     do {
00808         if(get_bits1(gbc)) {
00809             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
00810                                   s->avctx->drc_scale)+1.0;
00811         } else if(blk == 0) {
00812             s->dynamic_range[i] = 1.0f;
00813         }
00814     } while(i--);
00815 
00816     /* spectral extension strategy */
00817     if (s->eac3 && (!blk || get_bits1(gbc))) {
00818         s->spx_in_use = get_bits1(gbc);
00819         if (s->spx_in_use) {
00820             int dst_start_freq, dst_end_freq, src_start_freq,
00821                 start_subband, end_subband;
00822 
00823             /* determine which channels use spx */
00824             if (s->channel_mode == AC3_CHMODE_MONO) {
00825                 s->channel_uses_spx[1] = 1;
00826             } else {
00827                 for (ch = 1; ch <= fbw_channels; ch++)
00828                     s->channel_uses_spx[ch] = get_bits1(gbc);
00829             }
00830 
00831             /* get the frequency bins of the spx copy region and the spx start
00832                and end subbands */
00833             dst_start_freq = get_bits(gbc, 2);
00834             start_subband  = get_bits(gbc, 3) + 2;
00835             if (start_subband > 7)
00836                 start_subband += start_subband - 7;
00837             end_subband    = get_bits(gbc, 3) + 5;
00838             if (end_subband   > 7)
00839                 end_subband   += end_subband   - 7;
00840             dst_start_freq = dst_start_freq * 12 + 25;
00841             src_start_freq = start_subband  * 12 + 25;
00842             dst_end_freq   = end_subband    * 12 + 25;
00843 
00844             /* check validity of spx ranges */
00845             if (start_subband >= end_subband) {
00846                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
00847                        "range (%d >= %d)\n", start_subband, end_subband);
00848                 return -1;
00849             }
00850             if (dst_start_freq >= src_start_freq) {
00851                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
00852                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
00853                 return -1;
00854             }
00855 
00856             s->spx_dst_start_freq = dst_start_freq;
00857             s->spx_src_start_freq = src_start_freq;
00858             s->spx_dst_end_freq   = dst_end_freq;
00859 
00860             decode_band_structure(gbc, blk, s->eac3, 0,
00861                                   start_subband, end_subband,
00862                                   ff_eac3_default_spx_band_struct,
00863                                   &s->num_spx_bands,
00864                                   s->spx_band_sizes);
00865         } else {
00866             for (ch = 1; ch <= fbw_channels; ch++) {
00867                 s->channel_uses_spx[ch] = 0;
00868                 s->first_spx_coords[ch] = 1;
00869             }
00870         }
00871     }
00872 
00873     /* spectral extension coordinates */
00874     if (s->spx_in_use) {
00875         for (ch = 1; ch <= fbw_channels; ch++) {
00876             if (s->channel_uses_spx[ch]) {
00877                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
00878                     float spx_blend;
00879                     int bin, master_spx_coord;
00880 
00881                     s->first_spx_coords[ch] = 0;
00882                     spx_blend = get_bits(gbc, 5) * (1.0f/32);
00883                     master_spx_coord = get_bits(gbc, 2) * 3;
00884 
00885                     bin = s->spx_src_start_freq;
00886                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
00887                         int bandsize;
00888                         int spx_coord_exp, spx_coord_mant;
00889                         float nratio, sblend, nblend, spx_coord;
00890 
00891                         /* calculate blending factors */
00892                         bandsize = s->spx_band_sizes[bnd];
00893                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
00894                         nratio = av_clipf(nratio, 0.0f, 1.0f);
00895                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
00896                         sblend = sqrtf(1.0f - nratio);
00897                         bin += bandsize;
00898 
00899                         /* decode spx coordinates */
00900                         spx_coord_exp  = get_bits(gbc, 4);
00901                         spx_coord_mant = get_bits(gbc, 2);
00902                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
00903                         else                     spx_coord_mant += 4;
00904                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
00905                         spx_coord = spx_coord_mant * (1.0f/(1<<23));
00906 
00907                         /* multiply noise and signal blending factors by spx coordinate */
00908                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
00909                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
00910                     }
00911                 }
00912             } else {
00913                 s->first_spx_coords[ch] = 1;
00914             }
00915         }
00916     }
00917 
00918     /* coupling strategy */
00919     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
00920         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00921         if (!s->eac3)
00922             s->cpl_in_use[blk] = get_bits1(gbc);
00923         if (s->cpl_in_use[blk]) {
00924             /* coupling in use */
00925             int cpl_start_subband, cpl_end_subband;
00926 
00927             if (channel_mode < AC3_CHMODE_STEREO) {
00928                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
00929                 return -1;
00930             }
00931 
00932             /* check for enhanced coupling */
00933             if (s->eac3 && get_bits1(gbc)) {
00934                 /* TODO: parse enhanced coupling strategy info */
00935                 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
00936                 return -1;
00937             }
00938 
00939             /* determine which channels are coupled */
00940             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
00941                 s->channel_in_cpl[1] = 1;
00942                 s->channel_in_cpl[2] = 1;
00943             } else {
00944                 for (ch = 1; ch <= fbw_channels; ch++)
00945                     s->channel_in_cpl[ch] = get_bits1(gbc);
00946             }
00947 
00948             /* phase flags in use */
00949             if (channel_mode == AC3_CHMODE_STEREO)
00950                 s->phase_flags_in_use = get_bits1(gbc);
00951 
00952             /* coupling frequency range */
00953             cpl_start_subband = get_bits(gbc, 4);
00954             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
00955                                               get_bits(gbc, 4) + 3;
00956             if (cpl_start_subband >= cpl_end_subband) {
00957                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
00958                        cpl_start_subband, cpl_end_subband);
00959                 return -1;
00960             }
00961             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
00962             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
00963 
00964             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
00965                                   cpl_end_subband,
00966                                   ff_eac3_default_cpl_band_struct,
00967                                   &s->num_cpl_bands, s->cpl_band_sizes);
00968         } else {
00969             /* coupling not in use */
00970             for (ch = 1; ch <= fbw_channels; ch++) {
00971                 s->channel_in_cpl[ch] = 0;
00972                 s->first_cpl_coords[ch] = 1;
00973             }
00974             s->first_cpl_leak = s->eac3;
00975             s->phase_flags_in_use = 0;
00976         }
00977     } else if (!s->eac3) {
00978         if(!blk) {
00979             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
00980             return -1;
00981         } else {
00982             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
00983         }
00984     }
00985     cpl_in_use = s->cpl_in_use[blk];
00986 
00987     /* coupling coordinates */
00988     if (cpl_in_use) {
00989         int cpl_coords_exist = 0;
00990 
00991         for (ch = 1; ch <= fbw_channels; ch++) {
00992             if (s->channel_in_cpl[ch]) {
00993                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
00994                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
00995                     s->first_cpl_coords[ch] = 0;
00996                     cpl_coords_exist = 1;
00997                     master_cpl_coord = 3 * get_bits(gbc, 2);
00998                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
00999                         cpl_coord_exp = get_bits(gbc, 4);
01000                         cpl_coord_mant = get_bits(gbc, 4);
01001                         if (cpl_coord_exp == 15)
01002                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
01003                         else
01004                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
01005                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
01006                     }
01007                 } else if (!blk) {
01008                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
01009                     return -1;
01010                 }
01011             } else {
01012                 /* channel not in coupling */
01013                 s->first_cpl_coords[ch] = 1;
01014             }
01015         }
01016         /* phase flags */
01017         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
01018             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
01019                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
01020             }
01021         }
01022     }
01023 
01024     /* stereo rematrixing strategy and band structure */
01025     if (channel_mode == AC3_CHMODE_STEREO) {
01026         if ((s->eac3 && !blk) || get_bits1(gbc)) {
01027             s->num_rematrixing_bands = 4;
01028             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
01029                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
01030             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
01031                 s->num_rematrixing_bands--;
01032             }
01033             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
01034                 s->rematrixing_flags[bnd] = get_bits1(gbc);
01035         } else if (!blk) {
01036             av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
01037             s->num_rematrixing_bands = 0;
01038         }
01039     }
01040 
01041     /* exponent strategies for each channel */
01042     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01043         if (!s->eac3)
01044             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
01045         if(s->exp_strategy[blk][ch] != EXP_REUSE)
01046             bit_alloc_stages[ch] = 3;
01047     }
01048 
01049     /* channel bandwidth */
01050     for (ch = 1; ch <= fbw_channels; ch++) {
01051         s->start_freq[ch] = 0;
01052         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
01053             int group_size;
01054             int prev = s->end_freq[ch];
01055             if (s->channel_in_cpl[ch])
01056                 s->end_freq[ch] = s->start_freq[CPL_CH];
01057             else if (s->channel_uses_spx[ch])
01058                 s->end_freq[ch] = s->spx_src_start_freq;
01059             else {
01060                 int bandwidth_code = get_bits(gbc, 6);
01061                 if (bandwidth_code > 60) {
01062                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
01063                     return -1;
01064                 }
01065                 s->end_freq[ch] = bandwidth_code * 3 + 73;
01066             }
01067             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
01068             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
01069             if(blk > 0 && s->end_freq[ch] != prev)
01070                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
01071         }
01072     }
01073     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
01074         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
01075                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
01076     }
01077 
01078     /* decode exponents for each channel */
01079     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01080         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
01081             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
01082             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
01083                                  s->num_exp_groups[ch], s->dexps[ch][0],
01084                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
01085                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
01086                 return -1;
01087             }
01088             if(ch != CPL_CH && ch != s->lfe_ch)
01089                 skip_bits(gbc, 2); /* skip gainrng */
01090         }
01091     }
01092 
01093     /* bit allocation information */
01094     if (s->bit_allocation_syntax) {
01095         if (get_bits1(gbc)) {
01096             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01097             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01098             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
01099             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
01100             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
01101             for(ch=!cpl_in_use; ch<=s->channels; ch++)
01102                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01103         } else if (!blk) {
01104             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
01105             return -1;
01106         }
01107     }
01108 
01109     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
01110     if(!s->eac3 || !blk){
01111         if(s->snr_offset_strategy && get_bits1(gbc)) {
01112             int snr = 0;
01113             int csnr;
01114             csnr = (get_bits(gbc, 6) - 15) << 4;
01115             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
01116                 /* snr offset */
01117                 if (ch == i || s->snr_offset_strategy == 2)
01118                     snr = (csnr + get_bits(gbc, 4)) << 2;
01119                 /* run at least last bit allocation stage if snr offset changes */
01120                 if(blk && s->snr_offset[ch] != snr) {
01121                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
01122                 }
01123                 s->snr_offset[ch] = snr;
01124 
01125                 /* fast gain (normal AC-3 only) */
01126                 if (!s->eac3) {
01127                     int prev = s->fast_gain[ch];
01128                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01129                     /* run last 2 bit allocation stages if fast gain changes */
01130                     if(blk && prev != s->fast_gain[ch])
01131                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01132                 }
01133             }
01134         } else if (!s->eac3 && !blk) {
01135             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
01136             return -1;
01137         }
01138     }
01139 
01140     /* fast gain (E-AC-3 only) */
01141     if (s->fast_gain_syntax && get_bits1(gbc)) {
01142         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01143             int prev = s->fast_gain[ch];
01144             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01145             /* run last 2 bit allocation stages if fast gain changes */
01146             if(blk && prev != s->fast_gain[ch])
01147                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01148         }
01149     } else if (s->eac3 && !blk) {
01150         for (ch = !cpl_in_use; ch <= s->channels; ch++)
01151             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
01152     }
01153 
01154     /* E-AC-3 to AC-3 converter SNR offset */
01155     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
01156         skip_bits(gbc, 10); // skip converter snr offset
01157     }
01158 
01159     /* coupling leak information */
01160     if (cpl_in_use) {
01161         if (s->first_cpl_leak || get_bits1(gbc)) {
01162             int fl = get_bits(gbc, 3);
01163             int sl = get_bits(gbc, 3);
01164             /* run last 2 bit allocation stages for coupling channel if
01165                coupling leak changes */
01166             if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
01167                        sl != s->bit_alloc_params.cpl_slow_leak)) {
01168                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
01169             }
01170             s->bit_alloc_params.cpl_fast_leak = fl;
01171             s->bit_alloc_params.cpl_slow_leak = sl;
01172         } else if (!s->eac3 && !blk) {
01173             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
01174             return -1;
01175         }
01176         s->first_cpl_leak = 0;
01177     }
01178 
01179     /* delta bit allocation information */
01180     if (s->dba_syntax && get_bits1(gbc)) {
01181         /* delta bit allocation exists (strategy) */
01182         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01183             s->dba_mode[ch] = get_bits(gbc, 2);
01184             if (s->dba_mode[ch] == DBA_RESERVED) {
01185                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
01186                 return -1;
01187             }
01188             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01189         }
01190         /* channel delta offset, len and bit allocation */
01191         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01192             if (s->dba_mode[ch] == DBA_NEW) {
01193                 s->dba_nsegs[ch] = get_bits(gbc, 3);
01194                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
01195                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
01196                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
01197                     s->dba_values[ch][seg] = get_bits(gbc, 3);
01198                 }
01199                 /* run last 2 bit allocation stages if new dba values */
01200                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01201             }
01202         }
01203     } else if(blk == 0) {
01204         for(ch=0; ch<=s->channels; ch++) {
01205             s->dba_mode[ch] = DBA_NONE;
01206         }
01207     }
01208 
01209     /* Bit allocation */
01210     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
01211         if(bit_alloc_stages[ch] > 2) {
01212             /* Exponent mapping into PSD and PSD integration */
01213             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
01214                                       s->start_freq[ch], s->end_freq[ch],
01215                                       s->psd[ch], s->band_psd[ch]);
01216         }
01217         if(bit_alloc_stages[ch] > 1) {
01218             /* Compute excitation function, Compute masking curve, and
01219                Apply delta bit allocation */
01220             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
01221                                            s->start_freq[ch], s->end_freq[ch],
01222                                            s->fast_gain[ch], (ch == s->lfe_ch),
01223                                            s->dba_mode[ch], s->dba_nsegs[ch],
01224                                            s->dba_offsets[ch], s->dba_lengths[ch],
01225                                            s->dba_values[ch], s->mask[ch])) {
01226                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
01227                 return -1;
01228             }
01229         }
01230         if(bit_alloc_stages[ch] > 0) {
01231             /* Compute bit allocation */
01232             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
01233                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
01234             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
01235                                       s->start_freq[ch], s->end_freq[ch],
01236                                       s->snr_offset[ch],
01237                                       s->bit_alloc_params.floor,
01238                                       bap_tab, s->bap[ch]);
01239         }
01240     }
01241 
01242     /* unused dummy data */
01243     if (s->skip_syntax && get_bits1(gbc)) {
01244         int skipl = get_bits(gbc, 9);
01245         while(skipl--)
01246             skip_bits(gbc, 8);
01247     }
01248 
01249     /* unpack the transform coefficients
01250        this also uncouples channels if coupling is in use. */
01251     decode_transform_coeffs(s, blk);
01252 
01253     /* TODO: generate enhanced coupling coordinates and uncouple */
01254 
01255     /* recover coefficients if rematrixing is in use */
01256     if(s->channel_mode == AC3_CHMODE_STEREO)
01257         do_rematrixing(s);
01258 
01259     /* apply scaling to coefficients (headroom, dynrng) */
01260     for(ch=1; ch<=s->channels; ch++) {
01261         float gain = s->mul_bias / 4194304.0f;
01262         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
01263             gain *= s->dynamic_range[2-ch];
01264         } else {
01265             gain *= s->dynamic_range[0];
01266         }
01267         s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
01268     }
01269 
01270     /* apply spectral extension to high frequency bins */
01271     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
01272         ff_eac3_apply_spectral_extension(s);
01273     }
01274 
01275     /* downmix and MDCT. order depends on whether block switching is used for
01276        any channel in this block. this is because coefficients for the long
01277        and short transforms cannot be mixed. */
01278     downmix_output = s->channels != s->out_channels &&
01279                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
01280                      s->fbw_channels == s->out_channels);
01281     if(different_transforms) {
01282         /* the delay samples have already been downmixed, so we upmix the delay
01283            samples in order to reconstruct all channels before downmixing. */
01284         if(s->downmixed) {
01285             s->downmixed = 0;
01286             ac3_upmix_delay(s);
01287         }
01288 
01289         do_imdct(s, s->channels);
01290 
01291         if(downmix_output) {
01292             s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
01293         }
01294     } else {
01295         if(downmix_output) {
01296             s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
01297         }
01298 
01299         if(downmix_output && !s->downmixed) {
01300             s->downmixed = 1;
01301             s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
01302         }
01303 
01304         do_imdct(s, s->out_channels);
01305     }
01306 
01307     return 0;
01308 }
01309 
01313 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
01314                             AVPacket *avpkt)
01315 {
01316     const uint8_t *buf = avpkt->data;
01317     int buf_size = avpkt->size;
01318     AC3DecodeContext *s = avctx->priv_data;
01319     int16_t *out_samples = (int16_t *)data;
01320     int blk, ch, err;
01321     const uint8_t *channel_map;
01322     const float *output[AC3_MAX_CHANNELS];
01323 
01324     /* initialize the GetBitContext with the start of valid AC-3 Frame */
01325     if (s->input_buffer) {
01326         /* copy input buffer to decoder context to avoid reading past the end
01327            of the buffer, which can be caused by a damaged input stream. */
01328         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
01329         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
01330     } else {
01331         init_get_bits(&s->gbc, buf, buf_size * 8);
01332     }
01333 
01334     /* parse the syncinfo */
01335     *data_size = 0;
01336     err = parse_frame_header(s);
01337 
01338     if (err) {
01339         switch(err) {
01340             case AAC_AC3_PARSE_ERROR_SYNC:
01341                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
01342                 return -1;
01343             case AAC_AC3_PARSE_ERROR_BSID:
01344                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
01345                 break;
01346             case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
01347                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
01348                 break;
01349             case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
01350                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
01351                 break;
01352             case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
01353                 /* skip frame if CRC is ok. otherwise use error concealment. */
01354                 /* TODO: add support for substreams and dependent frames */
01355                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
01356                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
01357                     return s->frame_size;
01358                 } else {
01359                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
01360                 }
01361                 break;
01362             default:
01363                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
01364                 break;
01365         }
01366     } else {
01367         /* check that reported frame size fits in input buffer */
01368         if (s->frame_size > buf_size) {
01369             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
01370             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
01371         } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
01372             /* check for crc mismatch */
01373             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
01374                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
01375                 err = AAC_AC3_PARSE_ERROR_CRC;
01376             }
01377         }
01378     }
01379 
01380     /* if frame is ok, set audio parameters */
01381     if (!err) {
01382         avctx->sample_rate = s->sample_rate;
01383         avctx->bit_rate = s->bit_rate;
01384 
01385         /* channel config */
01386         s->out_channels = s->channels;
01387         s->output_mode = s->channel_mode;
01388         if(s->lfe_on)
01389             s->output_mode |= AC3_OUTPUT_LFEON;
01390         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
01391                 avctx->request_channels < s->channels) {
01392             s->out_channels = avctx->request_channels;
01393             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01394             s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
01395         }
01396         avctx->channels = s->out_channels;
01397         avctx->channel_layout = s->channel_layout;
01398 
01399         /* set downmixing coefficients if needed */
01400         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
01401                 s->fbw_channels == s->out_channels)) {
01402             set_downmix_coeffs(s);
01403         }
01404     } else if (!s->out_channels) {
01405         s->out_channels = avctx->channels;
01406         if(s->out_channels < s->channels)
01407             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01408     }
01409 
01410     /* decode the audio blocks */
01411     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
01412     for (ch = 0; ch < s->out_channels; ch++)
01413         output[ch] = s->output[channel_map[ch]];
01414     for (blk = 0; blk < s->num_blocks; blk++) {
01415         if (!err && decode_audio_block(s, blk)) {
01416             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
01417             err = 1;
01418         }
01419         s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
01420         out_samples += 256 * s->out_channels;
01421     }
01422     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
01423     return FFMIN(buf_size, s->frame_size);
01424 }
01425 
01429 static av_cold int ac3_decode_end(AVCodecContext *avctx)
01430 {
01431     AC3DecodeContext *s = avctx->priv_data;
01432     ff_mdct_end(&s->imdct_512);
01433     ff_mdct_end(&s->imdct_256);
01434 
01435     av_freep(&s->input_buffer);
01436 
01437     return 0;
01438 }
01439 
01440 AVCodec ac3_decoder = {
01441     .name = "ac3",
01442     .type = AVMEDIA_TYPE_AUDIO,
01443     .id = CODEC_ID_AC3,
01444     .priv_data_size = sizeof (AC3DecodeContext),
01445     .init = ac3_decode_init,
01446     .close = ac3_decode_end,
01447     .decode = ac3_decode_frame,
01448     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
01449 };
01450 
01451 #if CONFIG_EAC3_DECODER
01452 AVCodec eac3_decoder = {
01453     .name = "eac3",
01454     .type = AVMEDIA_TYPE_AUDIO,
01455     .id = CODEC_ID_EAC3,
01456     .priv_data_size = sizeof (AC3DecodeContext),
01457     .init = ac3_decode_init,
01458     .close = ac3_decode_end,
01459     .decode = ac3_decode_frame,
01460     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
01461 };
01462 #endif

Generated on Fri Sep 16 2011 17:17:33 for FFmpeg by  doxygen 1.7.1