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