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_interleave == ff_float_to_int16_interleave_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     int err;
 280
 281     err = ff_ac3_parse_header(&s->gbc, &hdr);
 282     if(err)
 283         return err;
 284
 285     /* get decoding parameters from header info */
 286     s->bit_alloc_params.sr_code     = hdr.sr_code;
 287     s->channel_mode                 = hdr.channel_mode;
 288     s->lfe_on                       = hdr.lfe_on;
 289     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
 290     s->sample_rate                  = hdr.sample_rate;
 291     s->bit_rate                     = hdr.bit_rate;
 292     s->channels                     = hdr.channels;
 293     s->fbw_channels                 = s->channels - s->lfe_on;
 294     s->lfe_ch                       = s->fbw_channels + 1;
 295     s->frame_size                   = hdr.frame_size;
 296     s->center_mix_level             = hdr.center_mix_level;
 297     s->surround_mix_level           = hdr.surround_mix_level;
 298     s->num_blocks                   = hdr.num_blocks;
 299     s->frame_type                   = hdr.frame_type;
 300     s->substreamid                  = hdr.substreamid;
 301
 302     if(s->lfe_on) {
 303         s->start_freq[s->lfe_ch] = 0;
 304         s->end_freq[s->lfe_ch] = 7;
 305         s->num_exp_groups[s->lfe_ch] = 2;
 306         s->channel_in_cpl[s->lfe_ch] = 0;
 307     }
 308
 309     if(hdr.bitstream_id > 10)
 310         return AC3_PARSE_ERROR_BSID;
 311
 312     return ac3_parse_header(s);
 313 }
 314
 315 /**
 316  * Set stereo downmixing coefficients based on frame header info.
 317  * reference: Section 7.8.2 Downmixing Into Two Channels
 318  */
 319 static void set_downmix_coeffs(AC3DecodeContext *s)
 320 {
 321     int i;
 322     float cmix = gain_levels[center_levels[s->center_mix_level]];
 323     float smix = gain_levels[surround_levels[s->surround_mix_level]];
 324     float norm0, norm1;
 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     /* renormalize */
 343     norm0 = norm1 = 0.0;
 344     for(i=0; i<s->fbw_channels; i++) {
 345         norm0 += s->downmix_coeffs[i][0];
 346         norm1 += s->downmix_coeffs[i][1];
 347     }
 348     norm0 = 1.0f / norm0;
 349     norm1 = 1.0f / norm1;
 350     for(i=0; i<s->fbw_channels; i++) {
 351         s->downmix_coeffs[i][0] *= norm0;
 352         s->downmix_coeffs[i][1] *= norm1;
 353     }
 354
 355     if(s->output_mode == AC3_CHMODE_MONO) {
 356         for(i=0; i<s->fbw_channels; i++)
 357             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
 358     }
 359 }
 360
 361 /**
 362  * Decode the grouped exponents according to exponent strategy.
 363  * reference: Section 7.1.3 Exponent Decoding
 364  */
 365 static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
 366                              uint8_t absexp, int8_t *dexps)
 367 {
 368     int i, j, grp, group_size;
 369     int dexp[256];
 370     int expacc, prevexp;
 371
 372     /* unpack groups */
 373     group_size = exp_strategy + (exp_strategy == EXP_D45);
 374     for(grp=0,i=0; grp<ngrps; grp++) {
 375         expacc = get_bits(gbc, 7);
 376         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
 377         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
 378         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
 379     }
 380
 381     /* convert to absolute exps and expand groups */
 382     prevexp = absexp;
 383     for(i=0; i<ngrps*3; i++) {
 384         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
 385         for(j=0; j<group_size; j++) {
 386             dexps[(i*group_size)+j] = prevexp;
 387         }
 388     }
 389 }
 390
 391 /**
 392  * Generate transform coefficients for each coupled channel in the coupling
 393  * range using the coupling coefficients and coupling coordinates.
 394  * reference: Section 7.4.3 Coupling Coordinate Format
 395  */
 396 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
 397 {
 398     int i, j, ch, bnd, subbnd;
 399
 400     subbnd = -1;
 401     i = s->start_freq[CPL_CH];
 402     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
 403         do {
 404             subbnd++;
 405             for(j=0; j<12; j++) {
 406                 for(ch=1; ch<=s->fbw_channels; ch++) {
 407                     if(s->channel_in_cpl[ch]) {
 408                         s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
 409                         if (ch == 2 && s->phase_flags[bnd])
 410                             s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
 411                     }
 412                 }
 413                 i++;
 414             }
 415         } while(s->cpl_band_struct[subbnd]);
 416     }
 417 }
 418
 419 /**
 420  * Grouped mantissas for 3-level 5-level and 11-level quantization
 421  */
 422 typedef struct {
 423     int b1_mant[3];
 424     int b2_mant[3];
 425     int b4_mant[2];
 426     int b1ptr;
 427     int b2ptr;
 428     int b4ptr;
 429 } mant_groups;
 430
 431 /**
 432  * Get the transform coefficients for a particular channel
 433  * reference: Section 7.3 Quantization and Decoding of Mantissas
 434  */
 435 static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
 436 {
 437     GetBitContext *gbc = &s->gbc;
 438     int i, gcode, tbap, start, end;
 439     uint8_t *exps;
 440     uint8_t *bap;
 441     int *coeffs;
 442
 443     exps = s->dexps[ch_index];
 444     bap = s->bap[ch_index];
 445     coeffs = s->fixed_coeffs[ch_index];
 446     start = s->start_freq[ch_index];
 447     end = s->end_freq[ch_index];
 448
 449     for (i = start; i < end; i++) {
 450         tbap = bap[i];
 451         switch (tbap) {
 452             case 0:
 453                 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 0x400000;
 454                 break;
 455
 456             case 1:
 457                 if(m->b1ptr > 2) {
 458                     gcode = get_bits(gbc, 5);
 459                     m->b1_mant[0] = b1_mantissas[gcode][0];
 460                     m->b1_mant[1] = b1_mantissas[gcode][1];
 461                     m->b1_mant[2] = b1_mantissas[gcode][2];
 462                     m->b1ptr = 0;
 463                 }
 464                 coeffs[i] = m->b1_mant[m->b1ptr++];
 465                 break;
 466
 467             case 2:
 468                 if(m->b2ptr > 2) {
 469                     gcode = get_bits(gbc, 7);
 470                     m->b2_mant[0] = b2_mantissas[gcode][0];
 471                     m->b2_mant[1] = b2_mantissas[gcode][1];
 472                     m->b2_mant[2] = b2_mantissas[gcode][2];
 473                     m->b2ptr = 0;
 474                 }
 475                 coeffs[i] = m->b2_mant[m->b2ptr++];
 476                 break;
 477
 478             case 3:
 479                 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
 480                 break;
 481
 482             case 4:
 483                 if(m->b4ptr > 1) {
 484                     gcode = get_bits(gbc, 7);
 485                     m->b4_mant[0] = b4_mantissas[gcode][0];
 486                     m->b4_mant[1] = b4_mantissas[gcode][1];
 487                     m->b4ptr = 0;
 488                 }
 489                 coeffs[i] = m->b4_mant[m->b4ptr++];
 490                 break;
 491
 492             case 5:
 493                 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
 494                 break;
 495
 496             default: {
 497                 /* asymmetric dequantization */
 498                 int qlevel = quantization_tab[tbap];
 499                 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
 500                 break;
 501             }
 502         }
 503         coeffs[i] >>= exps[i];
 504     }
 505 }
 506
 507 /**
 508  * Remove random dithering from coefficients with zero-bit mantissas
 509  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 510  */
 511 static void remove_dithering(AC3DecodeContext *s) {
 512     int ch, i;
 513     int end=0;
 514     int *coeffs;
 515     uint8_t *bap;
 516
 517     for(ch=1; ch<=s->fbw_channels; ch++) {
 518         if(!s->dither_flag[ch]) {
 519             coeffs = s->fixed_coeffs[ch];
 520             bap = s->bap[ch];
 521             if(s->channel_in_cpl[ch])
 522                 end = s->start_freq[CPL_CH];
 523             else
 524                 end = s->end_freq[ch];
 525             for(i=0; i<end; i++) {
 526                 if(!bap[i])
 527                     coeffs[i] = 0;
 528             }
 529             if(s->channel_in_cpl[ch]) {
 530                 bap = s->bap[CPL_CH];
 531                 for(; i<s->end_freq[CPL_CH]; i++) {
 532                     if(!bap[i])
 533                         coeffs[i] = 0;
 534                 }
 535             }
 536         }
 537     }
 538 }
 539
 540 /**
 541  * Get the transform coefficients.
 542  */
 543 static void get_transform_coeffs(AC3DecodeContext *s)
 544 {
 545     int ch, end;
 546     int got_cplchan = 0;
 547     mant_groups m;
 548
 549     m.b1ptr = m.b2ptr = m.b4ptr = 3;
 550
 551     for (ch = 1; ch <= s->channels; ch++) {
 552         /* transform coefficients for full-bandwidth channel */
 553         get_transform_coeffs_ch(s, ch, &m);
 554         /* tranform coefficients for coupling channel come right after the
 555            coefficients for the first coupled channel*/
 556         if (s->channel_in_cpl[ch])  {
 557             if (!got_cplchan) {
 558                 get_transform_coeffs_ch(s, CPL_CH, &m);
 559                 calc_transform_coeffs_cpl(s);
 560                 got_cplchan = 1;
 561             }
 562             end = s->end_freq[CPL_CH];
 563         } else {
 564             end = s->end_freq[ch];
 565         }
 566         do
 567             s->fixed_coeffs[ch][end] = 0;
 568         while(++end < 256);
 569     }
 570
 571     /* if any channel doesn't use dithering, zero appropriate coefficients */
 572     if(!s->dither_all)
 573         remove_dithering(s);
 574 }
 575
 576 /**
 577  * Stereo rematrixing.
 578  * reference: Section 7.5.4 Rematrixing : Decoding Technique
 579  */
 580 static void do_rematrixing(AC3DecodeContext *s)
 581 {
 582     int bnd, i;
 583     int end, bndend;
 584     int tmp0, tmp1;
 585
 586     end = FFMIN(s->end_freq[1], s->end_freq[2]);
 587
 588     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
 589         if(s->rematrixing_flags[bnd]) {
 590             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
 591             for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
 592                 tmp0 = s->fixed_coeffs[1][i];
 593                 tmp1 = s->fixed_coeffs[2][i];
 594                 s->fixed_coeffs[1][i] = tmp0 + tmp1;
 595                 s->fixed_coeffs[2][i] = tmp0 - tmp1;
 596             }
 597         }
 598     }
 599 }
 600
 601 /**
 602  * Inverse MDCT Transform.
 603  * Convert frequency domain coefficients to time-domain audio samples.
 604  * reference: Section 7.9.4 Transformation Equations
 605  */
 606 static inline void do_imdct(AC3DecodeContext *s, int channels)
 607 {
 608     int ch;
 609     float add_bias = s->add_bias;
 610     if(s->out_channels==1 && channels>1)
 611         add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
 612
 613     for (ch=1; ch<=channels; ch++) {
 614         if (s->block_switch[ch]) {
 615             int i;
 616             float *x = s->tmp_output+128;
 617             for(i=0; i<128; i++)
 618                 x[i] = s->transform_coeffs[ch][2*i];
 619             ff_imdct_half(&s->imdct_256, s->tmp_output, x);
 620             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
 621             for(i=0; i<128; i++)
 622                 x[i] = s->transform_coeffs[ch][2*i+1];
 623             ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
 624         } else {
 625             ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
 626             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
 627             memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
 628         }
 629     }
 630 }
 631
 632 /**
 633  * Downmix the output to mono or stereo.
 634  */
 635 static av_noinline void ac3_downmix(AC3DecodeContext *s,
 636                                     float samples[AC3_MAX_CHANNELS][256])
 637 {
 638     int i, j;
 639     float v0, v1;
 640
 641     if(s->output_mode == AC3_CHMODE_STEREO) {
 642         for(i=0; i<256; i++) {
 643             v0 = v1 = 0.0f;
 644             for(j=0; j<s->fbw_channels; j++) {
 645                 v0 += samples[j][i] * s->downmix_coeffs[j][0];
 646                 v1 += samples[j][i] * s->downmix_coeffs[j][1];
 647             }
 648             samples[0][i] = v0;
 649             samples[1][i] = v1;
 650         }
 651     } else if(s->output_mode == AC3_CHMODE_MONO) {
 652         for(i=0; i<256; i++) {
 653             v0 = 0.0f;
 654             for(j=0; j<s->fbw_channels; j++)
 655                 v0 += samples[j][i] * s->downmix_coeffs[j][0];
 656             samples[0][i] = v0;
 657         }
 658     }
 659 }
 660
 661 /**
 662  * Upmix delay samples from stereo to original channel layout.
 663  */
 664 static void ac3_upmix_delay(AC3DecodeContext *s)
 665 {
 666     int channel_data_size = 128*sizeof(float);
 667     switch(s->channel_mode) {
 668         case AC3_CHMODE_DUALMONO:
 669         case AC3_CHMODE_STEREO:
 670             /* upmix mono to stereo */
 671             memcpy(s->delay[1], s->delay[0], channel_data_size);
 672             break;
 673         case AC3_CHMODE_2F2R:
 674             memset(s->delay[3], 0, channel_data_size);
 675         case AC3_CHMODE_2F1R:
 676             memset(s->delay[2], 0, channel_data_size);
 677             break;
 678         case AC3_CHMODE_3F2R:
 679             memset(s->delay[4], 0, channel_data_size);
 680         case AC3_CHMODE_3F1R:
 681             memset(s->delay[3], 0, channel_data_size);
 682         case AC3_CHMODE_3F:
 683             memcpy(s->delay[2], s->delay[1], channel_data_size);
 684             memset(s->delay[1], 0, channel_data_size);
 685             break;
 686     }
 687 }
 688
 689 /**
 690  * Decode a single audio block from the AC-3 bitstream.
 691  */
 692 static int decode_audio_block(AC3DecodeContext *s, int blk)
 693 {
 694     int fbw_channels = s->fbw_channels;
 695     int channel_mode = s->channel_mode;
 696     int i, bnd, seg, ch;
 697     int different_transforms;
 698     int downmix_output;
 699     int cpl_in_use;
 700     GetBitContext *gbc = &s->gbc;
 701     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
 702
 703     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
 704
 705     /* block switch flags */
 706     different_transforms = 0;
 707     for (ch = 1; ch <= fbw_channels; ch++) {
 708         s->block_switch[ch] = get_bits1(gbc);
 709         if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
 710             different_transforms = 1;
 711     }
 712
 713     /* dithering flags */
 714     s->dither_all = 1;
 715     for (ch = 1; ch <= fbw_channels; ch++) {
 716         s->dither_flag[ch] = get_bits1(gbc);
 717         if(!s->dither_flag[ch])
 718             s->dither_all = 0;
 719     }
 720
 721     /* dynamic range */
 722     i = !(s->channel_mode);
 723     do {
 724         if(get_bits1(gbc)) {
 725             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
 726                                   s->avctx->drc_scale)+1.0;
 727         } else if(blk == 0) {
 728             s->dynamic_range[i] = 1.0f;
 729         }
 730     } while(i--);
 731
 732     /* coupling strategy */
 733     if (get_bits1(gbc)) {
 734         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 735         s->cpl_in_use[blk] = get_bits1(gbc);
 736         if (s->cpl_in_use[blk]) {
 737             /* coupling in use */
 738             int cpl_begin_freq, cpl_end_freq;
 739
 740             if (channel_mode < AC3_CHMODE_STEREO) {
 741                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
 742                 return -1;
 743             }
 744
 745             /* determine which channels are coupled */
 746             for (ch = 1; ch <= fbw_channels; ch++)
 747                 s->channel_in_cpl[ch] = get_bits1(gbc);
 748
 749             /* phase flags in use */
 750             if (channel_mode == AC3_CHMODE_STEREO)
 751                 s->phase_flags_in_use = get_bits1(gbc);
 752
 753             /* coupling frequency range and band structure */
 754             cpl_begin_freq = get_bits(gbc, 4);
 755             cpl_end_freq = get_bits(gbc, 4);
 756             if (3 + cpl_end_freq - cpl_begin_freq < 0) {
 757                 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
 758                 return -1;
 759             }
 760             s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
 761             s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
 762             s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
 763             for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
 764                 if (get_bits1(gbc)) {
 765                     s->cpl_band_struct[bnd] = 1;
 766                     s->num_cpl_bands--;
 767                 }
 768             }
 769             s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
 770         } else {
 771             /* coupling not in use */
 772             for (ch = 1; ch <= fbw_channels; ch++)
 773                 s->channel_in_cpl[ch] = 0;
 774         }
 775     } else if (!blk) {
 776         av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
 777         return -1;
 778     } else {
 779         s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
 780     }
 781     cpl_in_use = s->cpl_in_use[blk];
 782
 783     /* coupling coordinates */
 784     if (cpl_in_use) {
 785         int cpl_coords_exist = 0;
 786
 787         for (ch = 1; ch <= fbw_channels; ch++) {
 788             if (s->channel_in_cpl[ch]) {
 789                 if (get_bits1(gbc)) {
 790                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
 791                     cpl_coords_exist = 1;
 792                     master_cpl_coord = 3 * get_bits(gbc, 2);
 793                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 794                         cpl_coord_exp = get_bits(gbc, 4);
 795                         cpl_coord_mant = get_bits(gbc, 4);
 796                         if (cpl_coord_exp == 15)
 797                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
 798                         else
 799                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
 800                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
 801                     }
 802                 } else if (!blk) {
 803                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
 804                     return -1;
 805                 }
 806             }
 807         }
 808         /* phase flags */
 809         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
 810             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 811                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
 812             }
 813         }
 814     }
 815
 816     /* stereo rematrixing strategy and band structure */
 817     if (channel_mode == AC3_CHMODE_STEREO) {
 818         if (get_bits1(gbc)) {
 819             s->num_rematrixing_bands = 4;
 820             if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
 821                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
 822             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
 823                 s->rematrixing_flags[bnd] = get_bits1(gbc);
 824         } else if (!blk) {
 825             av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
 826             return -1;
 827         }
 828     }
 829
 830     /* exponent strategies for each channel */
 831     s->exp_strategy[blk][CPL_CH] = EXP_REUSE;
 832     s->exp_strategy[blk][s->lfe_ch] = EXP_REUSE;
 833     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
 834         s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
 835         if(s->exp_strategy[blk][ch] != EXP_REUSE)
 836             bit_alloc_stages[ch] = 3;
 837     }
 838
 839     /* channel bandwidth */
 840     for (ch = 1; ch <= fbw_channels; ch++) {
 841         s->start_freq[ch] = 0;
 842         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
 843             int group_size;
 844             int prev = s->end_freq[ch];
 845             if (s->channel_in_cpl[ch])
 846                 s->end_freq[ch] = s->start_freq[CPL_CH];
 847             else {
 848                 int bandwidth_code = get_bits(gbc, 6);
 849                 if (bandwidth_code > 60) {
 850                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
 851                     return -1;
 852                 }
 853                 s->end_freq[ch] = bandwidth_code * 3 + 73;
 854             }
 855             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
 856             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
 857             if(blk > 0 && s->end_freq[ch] != prev)
 858                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 859         }
 860     }
 861     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
 862         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
 863                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
 864     }
 865
 866     /* decode exponents for each channel */
 867     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
 868         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
 869             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
 870             decode_exponents(gbc, s->exp_strategy[blk][ch],
 871                              s->num_exp_groups[ch], s->dexps[ch][0],
 872                              &s->dexps[ch][s->start_freq[ch]+!!ch]);
 873             if(ch != CPL_CH && ch != s->lfe_ch)
 874                 skip_bits(gbc, 2); /* skip gainrng */
 875         }
 876     }
 877
 878     /* bit allocation information */
 879     if (get_bits1(gbc)) {
 880         s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
 881         s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
 882         s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
 883         s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
 884         s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
 885         for(ch=!cpl_in_use; ch<=s->channels; ch++)
 886             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 887     } else if (!blk) {
 888         av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
 889         return -1;
 890     }
 891
 892     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
 893     if (get_bits1(gbc)) {
 894         int csnr;
 895         csnr = (get_bits(gbc, 6) - 15) << 4;
 896         for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
 897             s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
 898             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
 899         }
 900         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
 901     } else if (!blk) {
 902         av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
 903         return -1;
 904     }
 905
 906     /* coupling leak information */
 907     if (cpl_in_use) {
 908         if (get_bits1(gbc)) {
 909             s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
 910             s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
 911             bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
 912         } else if (!blk) {
 913             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
 914             return -1;
 915         }
 916     }
 917
 918     /* delta bit allocation information */
 919     if (get_bits1(gbc)) {
 920         /* delta bit allocation exists (strategy) */
 921         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
 922             s->dba_mode[ch] = get_bits(gbc, 2);
 923             if (s->dba_mode[ch] == DBA_RESERVED) {
 924                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
 925                 return -1;
 926             }
 927             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 928         }
 929         /* channel delta offset, len and bit allocation */
 930         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
 931             if (s->dba_mode[ch] == DBA_NEW) {
 932                 s->dba_nsegs[ch] = get_bits(gbc, 3);
 933                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
 934                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
 935                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
 936                     s->dba_values[ch][seg] = get_bits(gbc, 3);
 937                 }
 938                 /* run last 2 bit allocation stages if new dba values */
 939                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
 940             }
 941         }
 942     } else if(blk == 0) {
 943         for(ch=0; ch<=s->channels; ch++) {
 944             s->dba_mode[ch] = DBA_NONE;
 945         }
 946     }
 947
 948     /* Bit allocation */
 949     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
 950         if(bit_alloc_stages[ch] > 2) {
 951             /* Exponent mapping into PSD and PSD integration */
 952             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
 953                                       s->start_freq[ch], s->end_freq[ch],
 954                                       s->psd[ch], s->band_psd[ch]);
 955         }
 956         if(bit_alloc_stages[ch] > 1) {
 957             /* Compute excitation function, Compute masking curve, and
 958                Apply delta bit allocation */
 959             ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
 960                                        s->start_freq[ch], s->end_freq[ch],
 961                                        s->fast_gain[ch], (ch == s->lfe_ch),
 962                                        s->dba_mode[ch], s->dba_nsegs[ch],
 963                                        s->dba_offsets[ch], s->dba_lengths[ch],
 964                                        s->dba_values[ch], s->mask[ch]);
 965         }
 966         if(bit_alloc_stages[ch] > 0) {
 967             /* Compute bit allocation */
 968             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
 969                                       s->start_freq[ch], s->end_freq[ch],
 970                                       s->snr_offset[ch],
 971                                       s->bit_alloc_params.floor,
 972                                       ff_ac3_bap_tab, s->bap[ch]);
 973         }
 974     }
 975
 976     /* unused dummy data */
 977     if (get_bits1(gbc)) {
 978         int skipl = get_bits(gbc, 9);
 979         while(skipl--)
 980             skip_bits(gbc, 8);
 981     }
 982
 983     /* unpack the transform coefficients
 984        this also uncouples channels if coupling is in use. */
 985     get_transform_coeffs(s);
 986
 987     /* recover coefficients if rematrixing is in use */
 988     if(s->channel_mode == AC3_CHMODE_STEREO)
 989         do_rematrixing(s);
 990
 991     /* apply scaling to coefficients (headroom, dynrng) */
 992     for(ch=1; ch<=s->channels; ch++) {
 993         float gain = s->mul_bias / 4194304.0f;
 994         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
 995             gain *= s->dynamic_range[ch-1];
 996         } else {
 997             gain *= s->dynamic_range[0];
 998         }
 999         for(i=0; i<256; i++) {
1000             s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
1001         }
1002     }
1003
1004     /* downmix and MDCT. order depends on whether block switching is used for
1005        any channel in this block. this is because coefficients for the long
1006        and short transforms cannot be mixed. */
1007     downmix_output = s->channels != s->out_channels &&
1008                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1009                      s->fbw_channels == s->out_channels);
1010     if(different_transforms) {
1011         /* the delay samples have already been downmixed, so we upmix the delay
1012            samples in order to reconstruct all channels before downmixing. */
1013         if(s->downmixed) {
1014             s->downmixed = 0;
1015             ac3_upmix_delay(s);
1016         }
1017
1018         do_imdct(s, s->channels);
1019
1020         if(downmix_output) {
1021             ac3_downmix(s, s->output);
1022         }
1023     } else {
1024         if(downmix_output) {
1025             ac3_downmix(s, s->transform_coeffs+1);
1026         }
1027
1028         if(!s->downmixed) {
1029             s->downmixed = 1;
1030             // FIXME delay[] is half the size of the other downmixes
1031             ac3_downmix(s, s->delay);
1032         }
1033
1034         do_imdct(s, s->out_channels);
1035     }
1036
1037     return 0;
1038 }
1039
1040 /**
1041  * Decode a single AC-3 frame.
1042  */
1043 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1044                             const uint8_t *buf, int buf_size)
1045 {
1046     AC3DecodeContext *s = avctx->priv_data;
1047     int16_t *out_samples = (int16_t *)data;
1048     int blk, ch, err;
1049
1050     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1051     if (s->input_buffer) {
1052         /* copy input buffer to decoder context to avoid reading past the end
1053            of the buffer, which can be caused by a damaged input stream. */
1054         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1055         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1056     } else {
1057         init_get_bits(&s->gbc, buf, buf_size * 8);
1058     }
1059
1060     /* parse the syncinfo */
1061     *data_size = 0;
1062     err = parse_frame_header(s);
1063
1064     /* check that reported frame size fits in input buffer */
1065     if(s->frame_size > buf_size) {
1066         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1067         err = AC3_PARSE_ERROR_FRAME_SIZE;
1068     }
1069
1070     /* check for crc mismatch */
1071     if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1072         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1073             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1074             err = AC3_PARSE_ERROR_CRC;
1075         }
1076     }
1077
1078     if(err && err != AC3_PARSE_ERROR_CRC) {
1079         switch(err) {
1080             case AC3_PARSE_ERROR_SYNC:
1081                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1082                 return -1;
1083             case AC3_PARSE_ERROR_BSID:
1084                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1085                 break;
1086             case AC3_PARSE_ERROR_SAMPLE_RATE:
1087                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1088                 break;
1089             case AC3_PARSE_ERROR_FRAME_SIZE:
1090                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1091                 break;
1092             case AC3_PARSE_ERROR_FRAME_TYPE:
1093                 /* skip frame if CRC is ok. otherwise use error concealment. */
1094                 /* TODO: add support for substreams and dependent frames */
1095                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1096                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1097                     return s->frame_size;
1098                 } else {
1099                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1100                 }
1101                 break;
1102             default:
1103                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1104                 break;
1105         }
1106     }
1107
1108     /* if frame is ok, set audio parameters */
1109     if (!err) {
1110         avctx->sample_rate = s->sample_rate;
1111         avctx->bit_rate = s->bit_rate;
1112
1113         /* channel config */
1114         s->out_channels = s->channels;
1115         s->output_mode = s->channel_mode;
1116         if(s->lfe_on)
1117             s->output_mode |= AC3_OUTPUT_LFEON;
1118         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1119                 avctx->request_channels < s->channels) {
1120             s->out_channels = avctx->request_channels;
1121             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1122         }
1123         avctx->channels = s->out_channels;
1124
1125         /* set downmixing coefficients if needed */
1126         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1127                 s->fbw_channels == s->out_channels)) {
1128             set_downmix_coeffs(s);
1129         }
1130     } else if (!s->out_channels) {
1131         s->out_channels = avctx->channels;
1132         if(s->out_channels < s->channels)
1133             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1134     }
1135
1136     /* decode the audio blocks */
1137     for (blk = 0; blk < s->num_blocks; blk++) {
1138         const float *output[s->out_channels];
1139         if (!err && decode_audio_block(s, blk)) {
1140             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1141         }
1142         for (ch = 0; ch < s->out_channels; ch++)
1143             output[ch] = s->output[ch];
1144         s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1145         out_samples += 256 * s->out_channels;
1146     }
1147     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1148     return s->frame_size;
1149 }
1150
1151 /**
1152  * Uninitialize the AC-3 decoder.
1153  */
1154 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1155 {
1156     AC3DecodeContext *s = avctx->priv_data;
1157     ff_mdct_end(&s->imdct_512);
1158     ff_mdct_end(&s->imdct_256);
1159
1160     av_freep(&s->input_buffer);
1161
1162     return 0;
1163 }
1164
1165 AVCodec ac3_decoder = {
1166     .name = "ac3",
1167     .type = CODEC_TYPE_AUDIO,
1168     .id = CODEC_ID_AC3,
1169     .priv_data_size = sizeof (AC3DecodeContext),
1170     .init = ac3_decode_init,
1171     .close = ac3_decode_end,
1172     .decode = ac3_decode_frame,
1173     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 / AC-3"),
1174 };