git.sesse.net Git - ffmpeg/blob - libavcodec/ac3dec.c

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