ac3dec.c 52 KB
Newer Older
1 2
/*
 * AC-3 Audio Decoder
3 4
 * This code was developed as part of Google Summer of Code 2006.
 * 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
 * This file is part of Libav.
11
 *
12
 * Libav is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * Libav is distributed in the hope that it will be useful,
18 19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with Libav; if not, write to the Free Software
24 25 26 27 28 29 30 31
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <stddef.h>
#include <math.h>
#include <string.h>

32
#include "libavutil/crc.h"
33
#include "internal.h"
34
#include "aac_ac3_parser.h"
35
#include "ac3_parser.h"
36
#include "ac3dec.h"
37
#include "ac3dec_data.h"
38
#include "kbdwin.h"
39

40 41
/** Large enough for maximum possible frame size when the specification limit is ignored */
#define AC3_FRAME_BUFFER_SIZE 32768
42

43 44 45 46 47
/**
 * table for ungrouping 3 values in 7 bits.
 * used for exponents and bap=2 mantissas
 */
static uint8_t ungroup_3_in_7_bits_tab[128][3];
48 49


50
/** tables for ungrouping mantissas */
51 52 53 54 55
static int b1_mantissas[32][3];
static int b2_mantissas[128][3];
static int b3_mantissas[8];
static int b4_mantissas[128][2];
static int b5_mantissas[16];
56

57 58 59 60
/**
 * Quantization table: levels for symmetric. bits for asymmetric.
 * reference: Table 7.18 Mapping of bap to Quantizer
 */
61
static const uint8_t quantization_tab[16] = {
62 63 64
    0, 3, 5, 7, 11, 15,
    5, 6, 7, 8, 9, 10, 11, 12, 14, 16
};
65

66
/** dynamic range table. converts codes to scale factors. */
67
static float dynamic_range_tab[256];
68

69
/** Adjustments in dB gain */
70 71 72
static const float gain_levels[9] = {
    LEVEL_PLUS_3DB,
    LEVEL_PLUS_1POINT5DB,
73
    LEVEL_ONE,
74
    LEVEL_MINUS_1POINT5DB,
75 76 77
    LEVEL_MINUS_3DB,
    LEVEL_MINUS_4POINT5DB,
    LEVEL_MINUS_6DB,
78
    LEVEL_ZERO,
79 80
    LEVEL_MINUS_9DB
};
81

82 83 84 85 86 87 88 89 90 91 92 93
/**
 * Table for center mix levels
 * reference: Section 5.4.2.4 cmixlev
 */
static const uint8_t center_levels[4] = { 4, 5, 6, 5 };

/**
 * Table for surround mix levels
 * reference: Section 5.4.2.5 surmixlev
 */
static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };

94 95 96 97 98
/**
 * Table for default stereo downmixing coefficients
 * reference: Section 7.8.2 Downmixing Into Two Channels
 */
static const uint8_t ac3_default_coeffs[8][5][2] = {
99 100 101 102 103 104 105 106
    { { 2, 7 }, { 7, 2 },                               },
    { { 4, 4 },                                         },
    { { 2, 7 }, { 7, 2 },                               },
    { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
    { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
    { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
    { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107
};
108

109 110 111 112 113
/**
 * Symmetrical Dequantization
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 *            Tables 7.19 to 7.23
 */
114
static inline int
115
symmetric_dequant(int code, int levels)
116
{
117
    return ((code - (levels >> 1)) << 24) / levels;
118 119
}

120 121 122
/*
 * Initialize tables at runtime.
 */
123
static av_cold void ac3_tables_init(void)
124
{
125
    int i;
126

127 128 129 130 131 132 133 134
    /* generate table for ungrouping 3 values in 7 bits
       reference: Section 7.1.3 Exponent Decoding */
    for(i=0; i<128; i++) {
        ungroup_3_in_7_bits_tab[i][0] =  i / 25;
        ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
        ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
    }

135 136 137 138
    /* generate grouped mantissa tables
       reference: Section 7.3.5 Ungrouping of Mantissas */
    for(i=0; i<32; i++) {
        /* bap=1 mantissas */
139 140 141
        b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
        b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
        b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
142 143 144
    }
    for(i=0; i<128; i++) {
        /* bap=2 mantissas */
145 146 147
        b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
        b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
        b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162

        /* bap=4 mantissas */
        b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
        b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
    }
    /* generate ungrouped mantissa tables
       reference: Tables 7.21 and 7.23 */
    for(i=0; i<7; i++) {
        /* bap=3 mantissas */
        b3_mantissas[i] = symmetric_dequant(i, 7);
    }
    for(i=0; i<15; i++) {
        /* bap=5 mantissas */
        b5_mantissas[i] = symmetric_dequant(i, 15);
    }
163

164 165 166 167
    /* generate dynamic range table
       reference: Section 7.7.1 Dynamic Range Control */
    for(i=0; i<256; i++) {
        int v = (i >> 5) - ((i >> 7) << 3) - 5;
168
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
169
    }
170 171
}

172

173 174 175
/**
 * AVCodec initialization
 */
176
static av_cold int ac3_decode_init(AVCodecContext *avctx)
177
{
178 179
    AC3DecodeContext *s = avctx->priv_data;
    s->avctx = avctx;
180

181
    ff_ac3_common_init();
182
    ac3_tables_init();
183 184
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
185
    ff_kbd_window_init(s->window, 5.0, 256);
186
    dsputil_init(&s->dsp, avctx);
187
    ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
188
    ff_fmt_convert_init(&s->fmt_conv, avctx);
189
    av_lfg_init(&s->dith_state, 0);
190

191 192
    /* set scale value for float to int16 conversion */
    s->mul_bias = 32767.0f;
193

194 195 196 197 198 199
    /* allow downmixing to stereo or mono */
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
            avctx->request_channels < avctx->channels &&
            avctx->request_channels <= 2) {
        avctx->channels = avctx->request_channels;
    }
200
    s->downmixed = 1;
201

202
    /* allocate context input buffer */
203
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
204
        if (!s->input_buffer)
205
            return AVERROR(ENOMEM);
206

207
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
208
    return 0;
209 210
}

211
/**
212
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
213
 * GetBitContext within AC3DecodeContext must point to
214
 * the start of the synchronized AC-3 bitstream.
215
 */
216
static int ac3_parse_header(AC3DecodeContext *s)
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
{
    GetBitContext *gbc = &s->gbc;
    int i;

    /* read the rest of the bsi. read twice for dual mono mode. */
    i = !(s->channel_mode);
    do {
        skip_bits(gbc, 5); // skip dialog normalization
        if (get_bits1(gbc))
            skip_bits(gbc, 8); //skip compression
        if (get_bits1(gbc))
            skip_bits(gbc, 8); //skip language code
        if (get_bits1(gbc))
            skip_bits(gbc, 7); //skip audio production information
    } while (i--);

    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit

    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
       TODO: read & use the xbsi1 downmix levels */
    if (get_bits1(gbc))
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
    if (get_bits1(gbc))
        skip_bits(gbc, 14); //skip timecode2 / xbsi2

    /* skip additional bitstream info */
    if (get_bits1(gbc)) {
        i = get_bits(gbc, 6);
        do {
            skip_bits(gbc, 8);
        } while(i--);
    }

    return 0;
}

/**
254
 * Common function to parse AC-3 or E-AC-3 frame header
255 256
 */
static int parse_frame_header(AC3DecodeContext *s)
257
{
258
    AC3HeaderInfo hdr;
259
    int err;
260

261
    err = ff_ac3_parse_header(&s->gbc, &hdr);
262 263 264 265
    if(err)
        return err;

    /* get decoding parameters from header info */
266
    s->bit_alloc_params.sr_code     = hdr.sr_code;
267
    s->bitstream_mode               = hdr.bitstream_mode;
268
    s->channel_mode                 = hdr.channel_mode;
269
    s->channel_layout               = hdr.channel_layout;
270
    s->lfe_on                       = hdr.lfe_on;
271
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
272
    s->sample_rate                  = hdr.sample_rate;
273 274 275 276 277
    s->bit_rate                     = hdr.bit_rate;
    s->channels                     = hdr.channels;
    s->fbw_channels                 = s->channels - s->lfe_on;
    s->lfe_ch                       = s->fbw_channels + 1;
    s->frame_size                   = hdr.frame_size;
278 279
    s->center_mix_level             = hdr.center_mix_level;
    s->surround_mix_level           = hdr.surround_mix_level;
280
    s->num_blocks                   = hdr.num_blocks;
281
    s->frame_type                   = hdr.frame_type;
282
    s->substreamid                  = hdr.substreamid;
283

284 285 286 287 288 289 290
    if(s->lfe_on) {
        s->start_freq[s->lfe_ch] = 0;
        s->end_freq[s->lfe_ch] = 7;
        s->num_exp_groups[s->lfe_ch] = 2;
        s->channel_in_cpl[s->lfe_ch] = 0;
    }

291 292 293 294 295 296 297 298 299 300 301
    if (hdr.bitstream_id <= 10) {
        s->eac3                  = 0;
        s->snr_offset_strategy   = 2;
        s->block_switch_syntax   = 1;
        s->dither_flag_syntax    = 1;
        s->bit_allocation_syntax = 1;
        s->fast_gain_syntax      = 0;
        s->first_cpl_leak        = 0;
        s->dba_syntax            = 1;
        s->skip_syntax           = 1;
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
Justin Ruggles's avatar
Justin Ruggles committed
302
        return ac3_parse_header(s);
303
    } else if (CONFIG_EAC3_DECODER) {
304 305
        s->eac3 = 1;
        return ff_eac3_parse_header(s);
306 307 308
    } else {
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
        return -1;
309
    }
310 311 312 313 314 315 316 317 318
}

/**
 * Set stereo downmixing coefficients based on frame header info.
 * reference: Section 7.8.2 Downmixing Into Two Channels
 */
static void set_downmix_coeffs(AC3DecodeContext *s)
{
    int i;
319 320
    float cmix = gain_levels[center_levels[s->center_mix_level]];
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
Loren Merritt's avatar
Loren Merritt committed
321
    float norm0, norm1;
322

323 324 325
    for(i=0; i<s->fbw_channels; i++) {
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
326
    }
327
    if(s->channel_mode > 1 && s->channel_mode & 1) {
328
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
329
    }
330 331
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
        int nf = s->channel_mode - 2;
332
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
333
    }
334 335
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
        int nf = s->channel_mode - 4;
336
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
337
    }
338

Loren Merritt's avatar
Loren Merritt committed
339 340
    /* renormalize */
    norm0 = norm1 = 0.0;
341
    for(i=0; i<s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
342 343 344 345 346 347 348 349 350 351 352 353 354
        norm0 += s->downmix_coeffs[i][0];
        norm1 += s->downmix_coeffs[i][1];
    }
    norm0 = 1.0f / norm0;
    norm1 = 1.0f / norm1;
    for(i=0; i<s->fbw_channels; i++) {
        s->downmix_coeffs[i][0] *= norm0;
        s->downmix_coeffs[i][1] *= norm1;
    }

    if(s->output_mode == AC3_CHMODE_MONO) {
        for(i=0; i<s->fbw_channels; i++)
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
355
    }
356 357
}

358
/**
359 360
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
361
 */
362
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
Justin Ruggles's avatar
Justin Ruggles committed
363
                            uint8_t absexp, int8_t *dexps)
364
{
365
    int i, j, grp, group_size;
366 367 368 369
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
370
    group_size = exp_strategy + (exp_strategy == EXP_D45);
371
    for(grp=0,i=0; grp<ngrps; grp++) {
372
        expacc = get_bits(gbc, 7);
373 374 375
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
376
    }
377

378 379
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
380
    for(i=0,j=0; i<ngrps*3; i++) {
381
        prevexp += dexp[i] - 2;
382
        if (prevexp > 24U)
383
            return -1;
384 385 386 387 388
        switch (group_size) {
            case 4: dexps[j++] = prevexp;
                    dexps[j++] = prevexp;
            case 2: dexps[j++] = prevexp;
            case 1: dexps[j++] = prevexp;
389
        }
390
    }
391
    return 0;
392 393
}

394
/**
395
 * Generate transform coefficients for each coupled channel in the coupling
396 397 398
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
399
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
400
{
401
    int bin, band, ch;
402 403 404

    bin = s->start_freq[CPL_CH];
    for (band = 0; band < s->num_cpl_bands; band++) {
405
        int band_start = bin;
406
        int band_end = bin + s->cpl_band_sizes[band];
407 408
        for (ch = 1; ch <= s->fbw_channels; ch++) {
            if (s->channel_in_cpl[ch]) {
409
                int cpl_coord = s->cpl_coords[ch][band] << 5;
410
                for (bin = band_start; bin < band_end; bin++) {
411
                    s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
412 413 414 415
                }
                if (ch == 2 && s->phase_flags[band]) {
                    for (bin = band_start; bin < band_end; bin++)
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
416
                }
417
            }
418
        }
419
        bin = band_end;
420 421 422
    }
}

423 424 425 426
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
427 428 429 430 431 432
    int b1_mant[2];
    int b2_mant[2];
    int b4_mant;
    int b1;
    int b2;
    int b4;
433 434
} mant_groups;

435
/**
436
 * Decode the transform coefficients for a particular channel
437 438
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
439
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
440
{
441 442 443 444 445
    int start_freq = s->start_freq[ch_index];
    int end_freq = s->end_freq[ch_index];
    uint8_t *baps = s->bap[ch_index];
    int8_t *exps = s->dexps[ch_index];
    int *coeffs = s->fixed_coeffs[ch_index];
446
    int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
447
    GetBitContext *gbc = &s->gbc;
448
    int freq;
449

450 451 452 453
    for(freq = start_freq; freq < end_freq; freq++){
        int bap = baps[freq];
        int mantissa;
        switch(bap){
454
            case 0:
455
                if (dither)
456
                    mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
457 458
                else
                    mantissa = 0;
Justin Ruggles's avatar
Justin Ruggles committed
459
                break;
460
            case 1:
461 462 463 464 465 466 467 468 469 470
                if(m->b1){
                    m->b1--;
                    mantissa = m->b1_mant[m->b1];
                }
                else{
                    int bits      = get_bits(gbc, 5);
                    mantissa      = b1_mantissas[bits][0];
                    m->b1_mant[1] = b1_mantissas[bits][1];
                    m->b1_mant[0] = b1_mantissas[bits][2];
                    m->b1         = 2;
471
                }
Justin Ruggles's avatar
Justin Ruggles committed
472
                break;
473
            case 2:
474 475 476 477 478 479 480 481 482 483
                if(m->b2){
                    m->b2--;
                    mantissa = m->b2_mant[m->b2];
                }
                else{
                    int bits      = get_bits(gbc, 7);
                    mantissa      = b2_mantissas[bits][0];
                    m->b2_mant[1] = b2_mantissas[bits][1];
                    m->b2_mant[0] = b2_mantissas[bits][2];
                    m->b2         = 2;
484
                }
Justin Ruggles's avatar
Justin Ruggles committed
485
                break;
486
            case 3:
487
                mantissa = b3_mantissas[get_bits(gbc, 3)];
Justin Ruggles's avatar
Justin Ruggles committed
488
                break;
489
            case 4:
490 491 492 493 494 495 496 497 498
                if(m->b4){
                    m->b4 = 0;
                    mantissa = m->b4_mant;
                }
                else{
                    int bits   = get_bits(gbc, 7);
                    mantissa   = b4_mantissas[bits][0];
                    m->b4_mant = b4_mantissas[bits][1];
                    m->b4      = 1;
499
                }
Justin Ruggles's avatar
Justin Ruggles committed
500
                break;
501
            case 5:
502
                mantissa = b5_mantissas[get_bits(gbc, 4)];
Justin Ruggles's avatar
Justin Ruggles committed
503
                break;
504 505 506 507
            default: /* 6 to 15 */
                mantissa = get_bits(gbc, quantization_tab[bap]);
                /* Shift mantissa and sign-extend it. */
                mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
Justin Ruggles's avatar
Justin Ruggles committed
508
                break;
509
        }
510
        coeffs[freq] = mantissa >> exps[freq];
511 512 513
    }
}

514
/**
515 516
 * Remove random dithering from coupling range coefficients with zero-bit
 * mantissas for coupled channels which do not use dithering.
517 518
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
519
static void remove_dithering(AC3DecodeContext *s) {
520 521
    int ch, i;

522
    for(ch=1; ch<=s->fbw_channels; ch++) {
523 524 525 526
        if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
            for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
                if(!s->bap[CPL_CH][i])
                    s->fixed_coeffs[ch][i] = 0;
527 528 529 530 531
            }
        }
    }
}

532
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
533 534 535
                                    mant_groups *m)
{
    if (!s->channel_uses_aht[ch]) {
536
        ac3_decode_transform_coeffs_ch(s, ch, m);
537 538 539 540
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
541
        if (!blk && CONFIG_EAC3_DECODER)
542
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
543
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
544
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
545 546 547 548
        }
    }
}

549
/**
550
 * Decode the transform coefficients.
551
 */
552
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
553
{
554
    int ch, end;
555
    int got_cplchan = 0;
556 557
    mant_groups m;

558
    m.b1 = m.b2 = m.b4 = 0;
559

560
    for (ch = 1; ch <= s->channels; ch++) {
561
        /* transform coefficients for full-bandwidth channel */
562
        decode_transform_coeffs_ch(s, blk, ch, &m);
563 564
        /* tranform coefficients for coupling channel come right after the
           coefficients for the first coupled channel*/
565
        if (s->channel_in_cpl[ch])  {
566
            if (!got_cplchan) {
567
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
568
                calc_transform_coeffs_cpl(s);
569 570
                got_cplchan = 1;
            }
571
            end = s->end_freq[CPL_CH];
572
        } else {
573
            end = s->end_freq[ch];
574
        }
575
        do
576
            s->fixed_coeffs[ch][end] = 0;
577 578
        while(++end < 256);
    }
579

580
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
581
    remove_dithering(s);
582 583
}

Justin Ruggles's avatar
Justin Ruggles committed
584
/**
585
 * Stereo rematrixing.
Justin Ruggles's avatar
Justin Ruggles committed
586 587
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
588
static void do_rematrixing(AC3DecodeContext *s)
589
{
Justin Ruggles's avatar
Justin Ruggles committed
590
    int bnd, i;
591 592
    int end, bndend;

593
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
594

595 596
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
        if(s->rematrixing_flags[bnd]) {
597
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
598
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
599
                int tmp0 = s->fixed_coeffs[1][i];
600
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
601
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
Justin Ruggles's avatar
Justin Ruggles committed
602 603
            }
        }
604 605
    }
}
606

607 608 609 610 611
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
612
static inline void do_imdct(AC3DecodeContext *s, int channels)
613
{
Justin Ruggles's avatar
Justin Ruggles committed
614
    int ch;
615

616
    for (ch=1; ch<=channels; ch++) {
617
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
618 619 620 621
            int i;
            float *x = s->tmp_output+128;
            for(i=0; i<128; i++)
                x[i] = s->transform_coeffs[ch][2*i];
622
            s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
623
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
Loren Merritt's avatar
Loren Merritt committed
624 625
            for(i=0; i<128; i++)
                x[i] = s->transform_coeffs[ch][2*i+1];
626
            s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch-1], x);
627
        } else {
628
            s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
629
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
Loren Merritt's avatar
Loren Merritt committed
630
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
631
        }
632 633 634
    }
}

635
/**
636
 * Downmix the output to mono or stereo.
637
 */
Loren Merritt's avatar
Loren Merritt committed
638
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
639 640
{
    int i, j;
641
    float v0, v1;
Loren Merritt's avatar
Loren Merritt committed
642 643
    if(out_ch == 2) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
644
            v0 = v1 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
645 646 647
            for(j=0; j<in_ch; j++) {
                v0 += samples[j][i] * matrix[j][0];
                v1 += samples[j][i] * matrix[j][1];
Loren Merritt's avatar
Loren Merritt committed
648 649 650
            }
            samples[0][i] = v0;
            samples[1][i] = v1;
651
        }
Loren Merritt's avatar
Loren Merritt committed
652 653
    } else if(out_ch == 1) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
654
            v0 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
655 656
            for(j=0; j<in_ch; j++)
                v0 += samples[j][i] * matrix[j][0];
Loren Merritt's avatar
Loren Merritt committed
657
            samples[0][i] = v0;
658 659 660 661
        }
    }
}

662 663 664 665 666
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
667
    int channel_data_size = sizeof(s->delay[0]);
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
    switch(s->channel_mode) {
        case AC3_CHMODE_DUALMONO:
        case AC3_CHMODE_STEREO:
            /* upmix mono to stereo */
            memcpy(s->delay[1], s->delay[0], channel_data_size);
            break;
        case AC3_CHMODE_2F2R:
            memset(s->delay[3], 0, channel_data_size);
        case AC3_CHMODE_2F1R:
            memset(s->delay[2], 0, channel_data_size);
            break;
        case AC3_CHMODE_3F2R:
            memset(s->delay[4], 0, channel_data_size);
        case AC3_CHMODE_3F1R:
            memset(s->delay[3], 0, channel_data_size);
        case AC3_CHMODE_3F:
            memcpy(s->delay[2], s->delay[1], channel_data_size);
            memset(s->delay[1], 0, channel_data_size);
            break;
    }
}

690 691
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
692 693 694 695
 * The band structure defines how many subbands are in each band.  For each
 * subband in the range, 1 means it is combined with the previous band, and 0
 * means that it starts a new band.
 *
696 697 698 699 700 701 702 703 704 705 706 707 708
 * @param[in] gbc bit reader context
 * @param[in] blk block number
 * @param[in] eac3 flag to indicate E-AC-3
 * @param[in] ecpl flag to indicate enhanced coupling
 * @param[in] start_subband subband number for start of range
 * @param[in] end_subband subband number for end of range
 * @param[in] default_band_struct default band structure table
 * @param[out] num_bands number of bands (optionally NULL)
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
 */
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
                                  int ecpl, int start_subband, int end_subband,
                                  const uint8_t *default_band_struct,
Justin Ruggles's avatar
Justin Ruggles committed
709
                                  int *num_bands, uint8_t *band_sizes)
710
{
711
    int subbnd, bnd, n_subbands, n_bands=0;
712
    uint8_t bnd_sz[22];
713 714
    uint8_t coded_band_struct[22];
    const uint8_t *band_struct;
715 716 717 718 719 720

    n_subbands = end_subband - start_subband;

    /* decode band structure from bitstream or use default */
    if (!eac3 || get_bits1(gbc)) {
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
721
            coded_band_struct[subbnd] = get_bits1(gbc);
722
        }
723
        band_struct = coded_band_struct;
724
    } else if (!blk) {
725 726 727 728
        band_struct = &default_band_struct[start_subband+1];
    } else {
        /* no change in band structure */
        return;
729 730 731 732 733 734
    }

    /* calculate number of bands and band sizes based on band structure.
       note that the first 4 subbands in enhanced coupling span only 6 bins
       instead of 12. */
    if (num_bands || band_sizes ) {
735
        n_bands = n_subbands;
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
        bnd_sz[0] = ecpl ? 6 : 12;
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
            if (band_struct[subbnd-1]) {
                n_bands--;
                bnd_sz[bnd] += subbnd_size;
            } else {
                bnd_sz[++bnd] = subbnd_size;
            }
        }
    }

    /* set optional output params */
    if (num_bands)
        *num_bands = n_bands;
    if (band_sizes)
752
        memcpy(band_sizes, bnd_sz, n_bands);
753 754
}

755
/**
756
 * Decode a single audio block from the AC-3 bitstream.
757
 */
758
static int decode_audio_block(AC3DecodeContext *s, int blk)
759
{
760 761
    int fbw_channels = s->fbw_channels;
    int channel_mode = s->channel_mode;
762
    int i, bnd, seg, ch;
763 764
    int different_transforms;
    int downmix_output;
765
    int cpl_in_use;
766
    GetBitContext *gbc = &s->gbc;
767
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
768

769 770
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

771
    /* block switch flags */
772
    different_transforms = 0;
773
    if (s->block_switch_syntax) {
Justin Ruggles's avatar
Justin Ruggles committed
774 775