libavcodec/ac3dec.c

   1 /*
   2  * AC-3 Audio Decoder
   3  * This code is developed as part of Google Summer of Code 2006 Program.
   4  *
   5  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
   6  * Copyright (c) 2007 Justin Ruggles
   7  *
   8  * Portions of this code are derived from liba52
   9  * http://liba52.sourceforge.net
  10  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
  11  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  12  *
  13  * This file is part of FFmpeg.
  14  *
  15  * FFmpeg is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2 of the License, or (at your option) any later version.
  19  *
  20  * FFmpeg is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public
  26  * License along with FFmpeg; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  28  */
  29
  30 #include <stdio.h>
  31 #include <stddef.h>
  32 #include <math.h>
  33 #include <string.h>
  34
  35 #include "libavutil/crc.h"
  36 #include "libavutil/random.h"
  37 #include "avcodec.h"
  38 #include "ac3_parser.h"
  39 #include "bitstream.h"
  40 #include "dsputil.h"
  41 #include "ac3dec.h"
  42 #include "ac3dec_data.h"
  43
  44 /** Maximum possible frame size when the specification limit is ignored */
  45 #define AC3_MAX_FRAME_SIZE 21695
  46
  47 /**
  48  * table for ungrouping 3 values in 7 bits.
  49  * used for exponents and bap=2 mantissas
  50  */
  51 static uint8_t ungroup_3_in_7_bits_tab[128][3];
  52
  53
  54 /** tables for ungrouping mantissas */
  55 static int b1_mantissas[32][3];
  56 static int b2_mantissas[128][3];
  57 static int b3_mantissas[8];
  58 static int b4_mantissas[128][2];
  59 static int b5_mantissas[16];
  60
  61 /**
  62  * Quantization table: levels for symmetric. bits for asymmetric.
  63  * reference: Table 7.18 Mapping of bap to Quantizer
  64  */
  65 static const uint8_t quantization_tab[16] = {
  66     0, 3, 5, 7, 11, 15,
  67     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
  68 };
  69
  70 /** dynamic range table. converts codes to scale factors. */
  71 static float dynamic_range_tab[256];
  72
  73 /** Adjustments in dB gain */
  74 #define LEVEL_PLUS_3DB          1.4142135623730950
  75 #define LEVEL_PLUS_1POINT5DB    1.1892071150027209
  76 #define LEVEL_MINUS_1POINT5DB   0.8408964152537145
  77 #define LEVEL_MINUS_3DB         0.7071067811865476
  78 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
  79 #define LEVEL_MINUS_6DB         0.5000000000000000
  80 #define LEVEL_MINUS_9DB         0.3535533905932738
  81 #define LEVEL_ZERO              0.0000000000000000
  82 #define LEVEL_ONE               1.0000000000000000
  83
  84 static const float gain_levels[9] = {
  85     LEVEL_PLUS_3DB,
  86     LEVEL_PLUS_1POINT5DB,
  87     LEVEL_ONE,
  88     LEVEL_MINUS_1POINT5DB,
  89     LEVEL_MINUS_3DB,
  90     LEVEL_MINUS_4POINT5DB,
  91     LEVEL_MINUS_6DB,
  92     LEVEL_ZERO,
  93     LEVEL_MINUS_9DB
  94 };
  95
  96 /**
  97  * Table for center mix levels
  98  * reference: Section 5.4.2.4 cmixlev
  99  */
 100 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
 101
 102 /**
 103  * Table for surround mix levels
 104  * reference: Section 5.4.2.5 surmixlev
 105  */
 106 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
 107
 108 /**
 109  * Table for default stereo downmixing coefficients
 110  * reference: Section 7.8.2 Downmixing Into Two Channels
 111  */
 112 static const uint8_t ac3_default_coeffs[8][5][2] = {
 113     { { 2, 7 }, { 7, 2 },                               },
 114     { { 4, 4 },                                         },
 115     { { 2, 7 }, { 7, 2 },                               },
 116     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
 117     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
 118     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
 119     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
 120     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
 121 };
 122
 123 /**
 124  * Symmetrical Dequantization
 125  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 126  *            Tables 7.19 to 7.23
 127  */
 128 static inline int
 129 symmetric_dequant(int code, int levels)
 130 {
 131     return ((code - (levels >> 1)) << 24) / levels;
 132 }
 133
 134 /*
 135  * Initialize tables at runtime.
 136  */
 137 static av_cold void ac3_tables_init(void)
 138 {
 139     int i;
 140
 141     /* generate table for ungrouping 3 values in 7 bits
 142        reference: Section 7.1.3 Exponent Decoding */
 143     for(i=0; i<128; i++) {
 144         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
 145         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
 146         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
 147     }
 148
 149     /* generate grouped mantissa tables
 150        reference: Section 7.3.5 Ungrouping of Mantissas */
 151     for(i=0; i<32; i++) {
 152         /* bap=1 mantissas */
 153         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
 154         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
 155         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
 156     }
 157     for(i=0; i<128; i++) {
 158         /* bap=2 mantissas */
 159         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
 160         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
 161         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
 162
 163         /* bap=4 mantissas */
 164         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
 165         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
 166     }
 167     /* generate ungrouped mantissa tables
 168        reference: Tables 7.21 and 7.23 */
 169     for(i=0; i<7; i++) {
 170         /* bap=3 mantissas */
 171         b3_mantissas[i] = symmetric_dequant(i, 7);
 172     }
 173     for(i=0; i<15; i++) {
 174         /* bap=5 mantissas */
 175         b5_mantissas[i] = symmetric_dequant(i, 15);
 176     }
 177
 178     /* generate dynamic range table
 179        reference: Section 7.7.1 Dynamic Range Control */
 180     for(i=0; i<256; i++) {
 181         int v = (i >> 5) - ((i >> 7) << 3) - 5;
 182         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
 183     }
 184 }
 185
 186
 187 /**
 188  * AVCodec initialization
 189  */
 190 static av_cold int ac3_decode_init(AVCodecContext *avctx)
 191 {
 192     AC3DecodeContext *s = avctx->priv_data;
 193     s->avctx = avctx;
 194
 195     ac3_common_init();
 196     ac3_tables_init();
 197     ff_mdct_init(&s->imdct_256, 8, 1);
 198     ff_mdct_init(&s->imdct_512, 9, 1);
 199     ff_kbd_window_init(s->window, 5.0, 256);
 200     dsputil_init(&s->dsp, avctx);
 201     av_init_random(0, &s->dith_state);
 202
 203     /* set bias values for float to int16 conversion */
 204     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
 205         s->add_bias = 385.0f;
 206         s->mul_bias = 1.0f;
 207     } else {
 208         s->add_bias = 0.0f;
 209         s->mul_bias = 32767.0f;
 210     }
 211
 212     /* allow downmixing to stereo or mono */
 213     if (avctx->channels > 0 && avctx->request_channels > 0 &&
 214             avctx->request_channels < avctx->channels &&
 215             avctx->request_channels <= 2) {
 216         avctx->channels = avctx->request_channels;
 217     }
 218     s->downmixed = 1;
 219
 220     /* allocate context input buffer */
 221     if (avctx->error_resilience >= FF_ER_CAREFUL) {
 222         s->input_buffer = av_mallocz(AC3_MAX_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
 223         if (!s->input_buffer)
 224             return AVERROR_NOMEM;
 225     }
 226
 227     avctx->sample_fmt = SAMPLE_FMT_S16;
 228     return 0;
 229 }
 230
 231 /**
 232  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
 233  * GetBitContext within AC3DecodeContext must point to
 234  * the start of the synchronized AC-3 bitstream.
 235  */
 236 static int ac3_parse_header(AC3DecodeContext *s)
 237 {
 238     GetBitContext *gbc = &s->gbc;
 239     int i;
 240
 241     /* read the rest of the bsi. read twice for dual mono mode. */
 242     i = !(s->channel_mode);
 243     do {
 244         skip_bits(gbc, 5); // skip dialog normalization
 245         if (get_bits1(gbc))
 246             skip_bits(gbc, 8); //skip compression
 247         if (get_bits1(gbc))
 248             skip_bits(gbc, 8); //skip language code
 249         if (get_bits1(gbc))
 250             skip_bits(gbc, 7); //skip audio production information
 251     } while (i--);
 252
 253     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
 254
 255     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
 256        TODO: read & use the xbsi1 downmix levels */
 257     if (get_bits1(gbc))
 258         skip_bits(gbc, 14); //skip timecode1 / xbsi1
 259     if (get_bits1(gbc))
 260         skip_bits(gbc, 14); //skip timecode2 / xbsi2
 261
 262     /* skip additional bitstream info */
 263     if (get_bits1(gbc)) {
 264         i = get_bits(gbc, 6);
 265         do {
 266             skip_bits(gbc, 8);
 267         } while(i--);
 268     }
 269
 270     return 0;
 271 }
 272
 273 /**
 274  * Common function to parse AC-3 or E-AC-3 frame header
 275  */
 276 static int parse_frame_header(AC3DecodeContext *s)
 277 {
 278     AC3HeaderInfo hdr;
 279     GetBitContext *gbc = &s->gbc;
 280     int err;
 281
 282     err = ff_ac3_parse_header(gbc, &hdr);
 283     if(err)
 284         return err;
 285
 286     if(hdr.bitstream_id > 10)
 287         return AC3_PARSE_ERROR_BSID;
 288
 289     /* get decoding parameters from header info */
 290     s->bit_alloc_params.sr_code     = hdr.sr_code;
 291     s->channel_mode                 = hdr.channel_mode;
 292     s->lfe_on                       = hdr.lfe_on;
 293     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
 294     s->sample_rate                  = hdr.sample_rate;
 295     s->bit_rate                     = hdr.bit_rate;
 296     s->channels                     = hdr.channels;
 297     s->fbw_channels                 = s->channels - s->lfe_on;
 298     s->lfe_ch                       = s->fbw_channels + 1;
 299     s->frame_size                   = hdr.frame_size;
 300     s->center_mix_level             = hdr.center_mix_level;
 301     s->surround_mix_level           = hdr.surround_mix_level;
 302     s->num_blocks                   = hdr.num_blocks;
 303     s->frame_type                   = hdr.frame_type;
 304     s->substreamid                  = hdr.substreamid;
 305
 306     if(s->lfe_on) {
 307         s->start_freq[s->lfe_ch] = 0;
 308         s->end_freq[s->lfe_ch] = 7;
 309         s->num_exp_groups[s->lfe_ch] = 2;
 310         s->channel_in_cpl[s->lfe_ch] = 0;
 311     }
 312
 313     return ac3_parse_header(s);
 314 }
 315
 316 /**
 317  * Set stereo downmixing coefficients based on frame header info.
 318  * reference: Section 7.8.2 Downmixing Into Two Channels
 319  */
 320 static void set_downmix_coeffs(AC3DecodeContext *s)
 321 {
 322     int i;
 323     float cmix = gain_levels[center_levels[s->center_mix_level]];
 324     float smix = gain_levels[surround_levels[s->surround_mix_level]];
 325
 326     for(i=0; i<s->fbw_channels; i++) {
 327         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
 328         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
 329     }
 330     if(s->channel_mode > 1 && s->channel_mode & 1) {
 331         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
 332     }
 333     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
 334         int nf = s->channel_mode - 2;
 335         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
 336     }
 337     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
 338         int nf = s->channel_mode - 4;
 339         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
 340     }
 341
 342     /* calculate adjustment needed for each channel to avoid clipping */
 343     s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
 344     for(i=0; i<s->fbw_channels; i++) {
 345         s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
 346         s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
 347     }
 348     s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
 349     s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
 350 }
 351
 352 /**
 353  * Decode the grouped exponents according to exponent strategy.
 354  * reference: Section 7.1.3 Exponent Decoding
 355  */
 356 static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
 357                              uint8_t absexp, int8_t *dexps)
 358 {
 359     int i, j, grp, group_size;
 360     int dexp[256];
 361     int expacc, prevexp;
 362
 363     /* unpack groups */
 364     group_size = exp_strategy + (exp_strategy == EXP_D45);
 365     for(grp=0,i=0; grp<ngrps; grp++) {
 366         expacc = get_bits(gbc, 7);
 367         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
 368         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
 369         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
 370     }
 371
 372     /* convert to absolute exps and expand groups */
 373     prevexp = absexp;
 374     for(i=0; i<ngrps*3; i++) {
 375         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
 376         for(j=0; j<group_size; j++) {
 377             dexps[(i*group_size)+j] = prevexp;
 378         }
 379     }
 380 }
 381
 382 /**
 383  * Generate transform coefficients for each coupled channel in the coupling
 384  * range using the coupling coefficients and coupling coordinates.
 385  * reference: Section 7.4.3 Coupling Coordinate Format
 386  */
 387 static void uncouple_channels(AC3DecodeContext *s)
 388 {
 389     int i, j, ch, bnd, subbnd;
 390
 391     subbnd = -1;
 392     i = s->start_freq[CPL_CH];
 393     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
 394         do {
 395             subbnd++;
 396             for(j=0; j<12; j++) {
 397                 for(ch=1; ch<=s->fbw_channels; ch++) {
 398                     if(s->channel_in_cpl[ch]) {
 399                         s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
 400                         if (ch == 2 && s->phase_flags[bnd])
 401                             s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
 402                     }
 403                 }
 404                 i++;
 405             }
 406         } while(s->cpl_band_struct[subbnd]);
 407     }
 408 }
 409
 410 /**
 411  * Grouped mantissas for 3-level 5-level and 11-level quantization
 412  */
 413 typedef struct {
 414     int b1_mant[3];
 415     int b2_mant[3];
 416     int b4_mant[2];
 417     int b1ptr;
 418     int b2ptr;
 419     int b4ptr;
 420 } mant_groups;
 421
 422 /**
 423  * Get the transform coefficients for a particular channel
 424  * reference: Section 7.3 Quantization and Decoding of Mantissas
 425  */
 426 static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
 427 {
 428     GetBitContext *gbc = &s->gbc;
 429     int i, gcode, tbap, start, end;
 430     uint8_t *exps;
 431     uint8_t *bap;
 432     int *coeffs;
 433
 434     exps = s->dexps[ch_index];
 435     bap = s->bap[ch_index];
 436     coeffs = s->fixed_coeffs[ch_index];
 437     start = s->start_freq[ch_index];
 438     end = s->end_freq[ch_index];
 439
 440     for (i = start; i < end; i++) {
 441         tbap = bap[i];
 442         switch (tbap) {
 443             case 0:
 444                 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 0x400000;
 445                 break;
 446
 447             case 1:
 448                 if(m->b1ptr > 2) {
 449                     gcode = get_bits(gbc, 5);
 450                     m->b1_mant[0] = b1_mantissas[gcode][0];
 451                     m->b1_mant[1] = b1_mantissas[gcode][1];
 452                     m->b1_mant[2] = b1_mantissas[gcode][2];
 453                     m->b1ptr = 0;
 454                 }
 455                 coeffs[i] = m->b1_mant[m->b1ptr++];
 456                 break;
 457
 458             case 2:
 459                 if(m->b2ptr > 2) {
 460                     gcode = get_bits(gbc, 7);
 461                     m->b2_mant[0] = b2_mantissas[gcode][0];
 462                     m->b2_mant[1] = b2_mantissas[gcode][1];
 463                     m->b2_mant[2] = b2_mantissas[gcode][2];
 464                     m->b2ptr = 0;
 465                 }
 466                 coeffs[i] = m->b2_mant[m->b2ptr++];
 467                 break;
 468
 469             case 3:
 470                 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
 471                 break;
 472
 473             case 4:
 474                 if(m->b4ptr > 1) {
 475                     gcode = get_bits(gbc, 7);
 476                     m->b4_mant[0] = b4_mantissas[gcode][0];
 477                     m->b4_mant[1] = b4_mantissas[gcode][1];
 478                     m->b4ptr = 0;
 479                 }
 480                 coeffs[i] = m->b4_mant[m->b4ptr++];
 481                 break;
 482
 483             case 5:
 484                 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
 485                 break;
 486
 487             default: {
 488                 /* asymmetric dequantization */
 489                 int qlevel = quantization_tab[tbap];
 490                 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
 491                 break;
 492             }
 493         }
 494         coeffs[i] >>= exps[i];
 495     }
 496 }
 497
 498 /**
 499  * Remove random dithering from coefficients with zero-bit mantissas
 500  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 501  */
 502 static void remove_dithering(AC3DecodeContext *s) {
 503     int ch, i;
 504     int end=0;
 505     int *coeffs;
 506     uint8_t *bap;
 507
 508     for(ch=1; ch<=s->fbw_channels; ch++) {
 509         if(!s->dither_flag[ch]) {
 510             coeffs = s->fixed_coeffs[ch];
 511             bap = s->bap[ch];
 512             if(s->channel_in_cpl[ch])
 513                 end = s->start_freq[CPL_CH];
 514             else
 515                 end = s->end_freq[ch];
 516             for(i=0; i<end; i++) {
 517                 if(!bap[i])
 518                     coeffs[i] = 0;
 519             }
 520             if(s->channel_in_cpl[ch]) {
 521                 bap = s->bap[CPL_CH];
 522                 for(; i<s->end_freq[CPL_CH]; i++) {
 523                     if(!bap[i])
 524                         coeffs[i] = 0;
 525                 }
 526             }
 527         }
 528     }
 529 }
 530
 531 /**
 532  * Get the transform coefficients.
 533  */
 534 static void get_transform_coeffs(AC3DecodeContext *s)
 535 {
 536     int ch, end;
 537     int got_cplchan = 0;
 538     mant_groups m;
 539
 540     m.b1ptr = m.b2ptr = m.b4ptr = 3;
 541
 542     for (ch = 1; ch <= s->channels; ch++) {
 543         /* transform coefficients for full-bandwidth channel */
 544         get_transform_coeffs_ch(s, ch, &m);
 545         /* tranform coefficients for coupling channel come right after the
 546            coefficients for the first coupled channel*/
 547         if (s->channel_in_cpl[ch])  {
 548             if (!got_cplchan) {
 549                 get_transform_coeffs_ch(s, CPL_CH, &m);
 550                 uncouple_channels(s);
 551                 got_cplchan = 1;
 552             }
 553             end = s->end_freq[CPL_CH];
 554         } else {
 555             end = s->end_freq[ch];
 556         }
 557         do
 558             s->fixed_coeffs[ch][end] = 0;
 559         while(++end < 256);
 560     }
 561
 562     /* if any channel doesn't use dithering, zero appropriate coefficients */
 563     if(!s->dither_all)
 564         remove_dithering(s);
 565 }
 566
 567 /**
 568  * Stereo rematrixing.
 569  * reference: Section 7.5.4 Rematrixing : Decoding Technique
 570  */
 571 static void do_rematrixing(AC3DecodeContext *s)
 572 {
 573     int bnd, i;
 574     int end, bndend;
 575     int tmp0, tmp1;
 576
 577     end = FFMIN(s->end_freq[1], s->end_freq[2]);
 578
 579     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
 580         if(s->rematrixing_flags[bnd]) {
 581             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
 582             for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
 583                 tmp0 = s->fixed_coeffs[1][i];
 584                 tmp1 = s->fixed_coeffs[2][i];
 585                 s->fixed_coeffs[1][i] = tmp0 + tmp1;
 586                 s->fixed_coeffs[2][i] = tmp0 - tmp1;
 587             }
 588         }
 589     }
 590 }
 591
 592 /**
 593  * Perform the 256-point IMDCT
 594  */
 595 static void do_imdct_256(AC3DecodeContext *s, int chindex)
 596 {
 597     int i, k;
 598     DECLARE_ALIGNED_16(float, x[128]);
 599     FFTComplex z[2][64];
 600     float *o_ptr = s->tmp_output;
 601
 602     for(i=0; i<2; i++) {
 603         /* de-interleave coefficients */
 604         for(k=0; k<128; k++) {
 605             x[k] = s->transform_coeffs[chindex][2*k+i];
 606         }
 607
 608         /* run standard IMDCT */
 609         s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
 610
 611         /* reverse the post-rotation & reordering from standard IMDCT */
 612         for(k=0; k<32; k++) {
 613             z[i][32+k].re = -o_ptr[128+2*k];
 614             z[i][32+k].im = -o_ptr[2*k];
 615             z[i][31-k].re =  o_ptr[2*k+1];
 616             z[i][31-k].im =  o_ptr[128+2*k+1];
 617         }
 618     }
 619
 620     /* apply AC-3 post-rotation & reordering */
 621     for(k=0; k<64; k++) {
 622         o_ptr[    2*k  ] = -z[0][   k].im;
 623         o_ptr[    2*k+1] =  z[0][63-k].re;
 624         o_ptr[128+2*k  ] = -z[0][   k].re;
 625         o_ptr[128+2*k+1] =  z[0][63-k].im;
 626         o_ptr[256+2*k  ] = -z[1][   k].re;
 627         o_ptr[256+2*k+1] =  z[1][63-k].im;
 628         o_ptr[384+2*k  ] =  z[1][   k].im;
 629         o_ptr[384+2*k+1] = -z[1][63-k].re;
 630     }
 631 }
 632
 633 /**
 634  * Inverse MDCT Transform.
 635  * Convert frequency domain coefficients to time-domain audio samples.
 636  * reference: Section 7.9.4 Transformation Equations
 637  */
 638 static inline void do_imdct(AC3DecodeContext *s, int channels)
 639 {
 640     int ch;
 641
 642     for (ch=1; ch<=channels; ch++) {
 643         if (s->block_switch[ch]) {
 644             do_imdct_256(s, ch);
 645         } else {
 646             s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
 647                                         s->transform_coeffs[ch], s->tmp_imdct);
 648         }
 649         /* For the first half of the block, apply the window, add the delay
 650            from the previous block, and send to output */
 651         s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
 652                                      s->window, s->delay[ch-1], 0, 256, 1);
 653         /* For the second half of the block, apply the window and store the
 654            samples to delay, to be combined with the next block */
 655         s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
 656                                    s->window, 256);
 657     }
 658 }
 659
 660 /**
 661  * Downmix the output to mono or stereo.
 662  */
 663 static void ac3_downmix(AC3DecodeContext *s,
 664                         float samples[AC3_MAX_CHANNELS][256], int ch_offset)
 665 {
 666     int i, j;
 667     float v0, v1;
 668
 669     for(i=0; i<256; i++) {
 670         v0 = v1 = 0.0f;
 671         for(j=0; j<s->fbw_channels; j++) {
 672             v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
 673             v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
 674         }
 675         v0 *= s->downmix_coeff_adjust[0];
 676         v1 *= s->downmix_coeff_adjust[1];
 677         if(s->output_mode == AC3_CHMODE_MONO) {
 678             samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
 679         } else if(s->output_mode == AC3_CHMODE_STEREO) {
 680             samples[  ch_offset][i] = v0;
 681             samples[1+ch_offset][i] = v1;
 682         }
 683     }
 684 }
 685
 686 /**
 687  * Upmix delay samples from stereo to original channel layout.
 688  */
 689 static void ac3_upmix_delay(AC3DecodeContext *s)
 690 {
 691     int channel_data_size = sizeof(s->delay[0]);
 692     switch(s->channel_mode) {
 693         case AC3_CHMODE_DUALMONO:
 694         case AC3_CHMODE_STEREO:
 695             /* upmix mono to stereo */
 696             memcpy(s->delay[1], s->delay[0], channel_data_size);
 697             break;
 698         case AC3_CHMODE_2F2R:
 699             memset(s->delay[3], 0, channel_data_size);
 700         case AC3_CHMODE_2F1R:
 701             memset(s->delay[2], 0, channel_data_size);
 702             break;
 703         case AC3_CHMODE_3F2R:
 704             memset(s->delay[4], 0, channel_data_size);
 705         case AC3_CHMODE_3F1R:
 706             memset(s->delay[3], 0, channel_data_size);
 707         case AC3_CHMODE_3F:
 708             memcpy(s->delay[2], s->delay[1], channel_data_size);
 709             memset(s->delay[1], 0, channel_data_size);
 710             break;
 711     }
 712 }
 713
 714 /**
 715  * Parse an audio block from AC-3 bitstream.
 716  */
 717 static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
 718 {
 719     int fbw_channels = s->fbw_channels;
 720     int channel_mode = s->channel_mode;
 721     int i, bnd, seg, ch;
 722     int different_transforms;
 723     int downmix_output;
 724     int cpl_in_use;
 725     GetBitContext *gbc = &s->gbc;
 726     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
 727
 728     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
 729
 730     /* block switch flags */
 731     different_transforms = 0;
 732     for (ch = 1; ch <= fbw_channels; ch++) {
 733         s->block_switch[ch] = get_bits1(gbc);
 734         if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
 735             different_transforms = 1;
 736     }
 737
 738     /* dithering flags */
 739     s->dither_all = 1;
 740     for (ch = 1; ch <= fbw_channels; ch++) {
 741         s->dither_flag[ch] = get_bits1(gbc);
 742         if(!s->dither_flag[ch])
 743             s->dither_all = 0;
 744     }
 745
 746     /* dynamic range */
 747     i = !(s->channel_mode);
 748     do {
 749         if(get_bits1(gbc)) {
 750             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
 751                                   s->avctx->drc_scale)+1.0;
 752         } else if(blk == 0) {
 753             s->dynamic_range[i] = 1.0f;
 754         }
 755     } while(i--);
 756
 757     /* coupling strategy */
 758     if (get_bits1(gbc)) {
 759         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 760         s->cpl_in_use[blk] = get_bits1(gbc);
 761         if (s->cpl_in_use[blk]) {
 762             /* coupling in use */
 763             int cpl_begin_freq, cpl_end_freq;
 764
 765             if (channel_mode < AC3_CHMODE_STEREO) {
 766                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 767                 return -1;
 768             }
 769
 770             /* determine which channels are coupled */
 771             for (ch = 1; ch <= fbw_channels; ch++)
 772                 s->channel_in_cpl[ch] = get_bits1(gbc);
 773
 774             /* phase flags in use */
 775             if (channel_mode == AC3_CHMODE_STEREO)
 776                 s->phase_flags_in_use = get_bits1(gbc);
 777
 778             /* coupling frequency range and band structure */
 779             cpl_begin_freq = get_bits(gbc, 4);
 780             cpl_end_freq = get_bits(gbc, 4);
 781             if (3 + cpl_end_freq - cpl_begin_freq < 0) {
 782                 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
 783                 return -1;
 784             }
 785             s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
 786             s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
 787             s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
 788             for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
 789                 if (get_bits1(gbc)) {
 790                     s->cpl_band_struct[bnd] = 1;
 791                     s->num_cpl_bands--;
 792                 }
 793             }
 794             s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
 795         } else {
 796             /* coupling not in use */
 797             for (ch = 1; ch <= fbw_channels; ch++)
 798                 s->channel_in_cpl[ch] = 0;
 799         }
 800     } else if (!blk) {
 801         av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
 802         return -1;
 803     } else {
 804         s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 805     }
 806     cpl_in_use = s->cpl_in_use[blk];
 807
 808     /* coupling coordinates */
 809     if (cpl_in_use) {
 810         int cpl_coords_exist = 0;
 811
 812         for (ch = 1; ch <= fbw_channels; ch++) {
 813             if (s->channel_in_cpl[ch]) {
 814                 if (get_bits1(gbc)) {
 815                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
 816                     cpl_coords_exist = 1;
 817                     master_cpl_coord = 3 * get_bits(gbc, 2);
 818                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 819                         cpl_coord_exp = get_bits(gbc, 4);
 820                         cpl_coord_mant = get_bits(gbc, 4);
 821                         if (cpl_coord_exp == 15)
 822                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
 823                         else
 824                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
 825                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
 826                     }
 827                 } else if (!blk) {
 828                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
 829                     return -1;
 830                 }
 831             }
 832         }
 833         /* phase flags */
 834         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
 835             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 836                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
 837             }
 838         }
 839     }
 840
 841     /* stereo rematrixing strategy and band structure */
 842     if (channel_mode == AC3_CHMODE_STEREO) {
 843         if (get_bits1(gbc)) {
 844             s->num_rematrixing_bands = 4;
 845             if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
 846                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
 847             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
 848                 s->rematrixing_flags[bnd] = get_bits1(gbc);
 849         } else if (!blk) {
 850             av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
 851             return -1;
 852         }
 853     }
 854
 855     /* exponent strategies for each channel */
 856     s->exp_strategy[blk][CPL_CH] = EXP_REUSE;
 857     s->exp_strategy[blk][s->lfe_ch] = EXP_REUSE;
 858     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
 859         s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
 860         if(s->exp_strategy[blk][ch] != EXP_REUSE)
 861             bit_alloc_stages[ch] = 3;
 862     }
 863
 864     /* channel bandwidth */
 865     for (ch = 1; ch <= fbw_channels; ch++) {
 866         s->start_freq[ch] = 0;
 867         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
 868             int group_size;
 869             int prev = s->end_freq[ch];
 870             if (s->channel_in_cpl[ch])
 871                 s->end_freq[ch] = s->start_freq[CPL_CH];
 872             else {
 873                 int bandwidth_code = get_bits(gbc, 6);
 874                 if (bandwidth_code > 60) {
 875                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
 876                     return -1;
 877                 }
 878                 s->end_freq[ch] = bandwidth_code * 3 + 73;
 879             }
 880             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
 881             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
 882             if(blk > 0 && s->end_freq[ch] != prev)
 883                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 884         }
 885     }
 886     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
 887         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
 888                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
 889     }
 890
 891     /* decode exponents for each channel */
 892     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
 893         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
 894             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
 895             decode_exponents(gbc, s->exp_strategy[blk][ch],
 896                              s->num_exp_groups[ch], s->dexps[ch][0],
 897                              &s->dexps[ch][s->start_freq[ch]+!!ch]);
 898             if(ch != CPL_CH && ch != s->lfe_ch)
 899                 skip_bits(gbc, 2); /* skip gainrng */
 900         }
 901     }
 902
 903     /* bit allocation information */
 904     if (get_bits1(gbc)) {
 905         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
 906         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
 907         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
 908         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
 909         s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
 910         for(ch=!cpl_in_use; ch<=s->channels; ch++)
 911             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 912     } else if (!blk) {
 913         av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
 914         return -1;
 915     }
 916
 917     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
 918     if (get_bits1(gbc)) {
 919         int csnr;
 920         csnr = (get_bits(gbc, 6) - 15) << 4;
 921         for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
 922             s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
 923             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
 924         }
 925         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 926     } else if (!blk) {
 927         av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
 928         return -1;
 929     }
 930
 931     /* coupling leak information */
 932     if (cpl_in_use) {
 933         if (get_bits1(gbc)) {
 934             s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
 935             s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
 936             bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
 937         } else if (!blk) {
 938             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
 939             return -1;
 940         }
 941     }
 942
 943     /* delta bit allocation information */
 944     if (get_bits1(gbc)) {
 945         /* delta bit allocation exists (strategy) */
 946         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
 947             s->dba_mode[ch] = get_bits(gbc, 2);
 948             if (s->dba_mode[ch] == DBA_RESERVED) {
 949                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
 950                 return -1;
 951             }
 952             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 953         }
 954         /* channel delta offset, len and bit allocation */
 955         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
 956             if (s->dba_mode[ch] == DBA_NEW) {
 957                 s->dba_nsegs[ch] = get_bits(gbc, 3);
 958                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
 959                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
 960                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
 961                     s->dba_values[ch][seg] = get_bits(gbc, 3);
 962                 }
 963                 /* run last 2 bit allocation stages if new dba values */
 964                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 965             }
 966         }
 967     } else if(blk == 0) {
 968         for(ch=0; ch<=s->channels; ch++) {
 969             s->dba_mode[ch] = DBA_NONE;
 970         }
 971     }
 972
 973     /* Bit allocation */
 974     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
 975         if(bit_alloc_stages[ch] > 2) {
 976             /* Exponent mapping into PSD and PSD integration */
 977             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
 978                                       s->start_freq[ch], s->end_freq[ch],
 979                                       s->psd[ch], s->band_psd[ch]);
 980         }
 981         if(bit_alloc_stages[ch] > 1) {
 982             /* Compute excitation function, Compute masking curve, and
 983                Apply delta bit allocation */
 984             ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
 985                                        s->start_freq[ch], s->end_freq[ch],
 986                                        s->fast_gain[ch], (ch == s->lfe_ch),
 987                                        s->dba_mode[ch], s->dba_nsegs[ch],
 988                                        s->dba_offsets[ch], s->dba_lengths[ch],
 989                                        s->dba_values[ch], s->mask[ch]);
 990         }
 991         if(bit_alloc_stages[ch] > 0) {
 992             /* Compute bit allocation */
 993             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
 994                                       s->start_freq[ch], s->end_freq[ch],
 995                                       s->snr_offset[ch],
 996                                       s->bit_alloc_params.floor,
 997                                       ff_ac3_bap_tab, s->bap[ch]);
 998         }
 999     }
1000
1001     /* unused dummy data */
1002     if (get_bits1(gbc)) {
1003         int skipl = get_bits(gbc, 9);
1004         while(skipl--)
1005             skip_bits(gbc, 8);
1006     }
1007
1008     /* unpack the transform coefficients
1009        this also uncouples channels if coupling is in use. */
1010     get_transform_coeffs(s);
1011
1012     /* recover coefficients if rematrixing is in use */
1013     if(s->channel_mode == AC3_CHMODE_STEREO)
1014         do_rematrixing(s);
1015
1016     /* apply scaling to coefficients (headroom, dynrng) */
1017     for(ch=1; ch<=s->channels; ch++) {
1018         float gain = s->mul_bias / 4194304.0f;
1019         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1020             gain *= s->dynamic_range[ch-1];
1021         } else {
1022             gain *= s->dynamic_range[0];
1023         }
1024         for(i=0; i<256; i++) {
1025             s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
1026         }
1027     }
1028
1029     /* downmix and MDCT. order depends on whether block switching is used for
1030        any channel in this block. this is because coefficients for the long
1031        and short transforms cannot be mixed. */
1032     downmix_output = s->channels != s->out_channels &&
1033                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1034                      s->fbw_channels == s->out_channels);
1035     if(different_transforms) {
1036         /* the delay samples have already been downmixed, so we upmix the delay
1037            samples in order to reconstruct all channels before downmixing. */
1038         if(s->downmixed) {
1039             s->downmixed = 0;
1040             ac3_upmix_delay(s);
1041         }
1042
1043         do_imdct(s, s->channels);
1044
1045         if(downmix_output) {
1046             ac3_downmix(s, s->output, 0);
1047         }
1048     } else {
1049         if(downmix_output) {
1050             ac3_downmix(s, s->transform_coeffs, 1);
1051         }
1052
1053         if(!s->downmixed) {
1054             s->downmixed = 1;
1055             ac3_downmix(s, s->delay, 0);
1056         }
1057
1058         do_imdct(s, s->out_channels);
1059     }
1060
1061     /* convert float to 16-bit integer */
1062     for(ch=0; ch<s->out_channels; ch++) {
1063         for(i=0; i<256; i++) {
1064             s->output[ch][i] += s->add_bias;
1065         }
1066         s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
1067     }
1068
1069     return 0;
1070 }
1071
1072 /**
1073  * Decode a single AC-3 frame.
1074  */
1075 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1076                             const uint8_t *buf, int buf_size)
1077 {
1078     AC3DecodeContext *s = avctx->priv_data;
1079     int16_t *out_samples = (int16_t *)data;
1080     int i, blk, ch, err;
1081
1082     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1083     if (s->input_buffer) {
1084         /* copy input buffer to decoder context to avoid reading past the end
1085            of the buffer, which can be caused by a damaged input stream. */
1086         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1087         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1088     } else {
1089         init_get_bits(&s->gbc, buf, buf_size * 8);
1090     }
1091
1092     /* parse the syncinfo */
1093     *data_size = 0;
1094     err = parse_frame_header(s);
1095
1096     /* check that reported frame size fits in input buffer */
1097     if(s->frame_size > buf_size) {
1098         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1099         err = AC3_PARSE_ERROR_FRAME_SIZE;
1100     }
1101
1102     /* check for crc mismatch */
1103     if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1104         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1105             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1106             err = AC3_PARSE_ERROR_CRC;
1107         }
1108     }
1109
1110     if(err && err != AC3_PARSE_ERROR_CRC) {
1111         switch(err) {
1112             case AC3_PARSE_ERROR_SYNC:
1113                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1114                 return -1;
1115             case AC3_PARSE_ERROR_BSID:
1116                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1117                 break;
1118             case AC3_PARSE_ERROR_SAMPLE_RATE:
1119                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1120                 break;
1121             case AC3_PARSE_ERROR_FRAME_SIZE:
1122                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1123                 break;
1124             case AC3_PARSE_ERROR_FRAME_TYPE:
1125                 /* skip frame if CRC is ok. otherwise use error concealment. */
1126                 /* TODO: add support for substreams and dependent frames */
1127                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1128                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1129                     return s->frame_size;
1130                 } else {
1131                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1132                 }
1133                 break;
1134             default:
1135                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1136                 break;
1137         }
1138     }
1139
1140     /* if frame is ok, set audio parameters */
1141     if (!err) {
1142         avctx->sample_rate = s->sample_rate;
1143         avctx->bit_rate = s->bit_rate;
1144
1145         /* channel config */
1146         s->out_channels = s->channels;
1147         s->output_mode = s->channel_mode;
1148         if(s->lfe_on)
1149             s->output_mode |= AC3_OUTPUT_LFEON;
1150         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1151                 avctx->request_channels < s->channels) {
1152             s->out_channels = avctx->request_channels;
1153             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1154         }
1155         avctx->channels = s->out_channels;
1156
1157         /* set downmixing coefficients if needed */
1158         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1159                 s->fbw_channels == s->out_channels)) {
1160             set_downmix_coeffs(s);
1161         }
1162     } else if (!s->out_channels) {
1163         s->out_channels = avctx->channels;
1164         if(s->out_channels < s->channels)
1165             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1166     }
1167
1168     /* parse the audio blocks */
1169     for (blk = 0; blk < s->num_blocks; blk++) {
1170         if (!err && ac3_parse_audio_block(s, blk)) {
1171             av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1172         }
1173
1174         /* interleave output samples */
1175         for (i = 0; i < 256; i++)
1176             for (ch = 0; ch < s->out_channels; ch++)
1177                 *(out_samples++) = s->int_output[ch][i];
1178     }
1179     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1180     return s->frame_size;
1181 }
1182
1183 /**
1184  * Uninitialize the AC-3 decoder.
1185  */
1186 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1187 {
1188     AC3DecodeContext *s = avctx->priv_data;
1189     ff_mdct_end(&s->imdct_512);
1190     ff_mdct_end(&s->imdct_256);
1191
1192     av_freep(&s->input_buffer);
1193
1194     return 0;
1195 }
1196
1197 AVCodec ac3_decoder = {
1198     .name = "ac3",
1199     .type = CODEC_TYPE_AUDIO,
1200     .id = CODEC_ID_AC3,
1201     .priv_data_size = sizeof (AC3DecodeContext),
1202     .init = ac3_decode_init,
1203     .close = ac3_decode_end,
1204     .decode = ac3_decode_frame,
1205     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 / AC-3"),
1206 };