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

libavcodec/ac3dec.c

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