ac3dec.c 47.6 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
 * Portions of this code are derived from liba52
11
 * http://liba52.sourceforge.net
12 13
 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
 * 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 20 21
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
22
 * FFmpeg is distributed in the hope that it will be useful,
23 24
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * 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 30 31 32 33 34 35 36
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

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

37
#include "libavutil/crc.h"
38
#include "internal.h"
39
#include "aac_ac3_parser.h"
40
#include "ac3_parser.h"
41
#include "ac3dec.h"
42
#include "ac3dec_data.h"
43

44 45
/** Large enough for maximum possible frame size when the specification limit is ignored */
#define AC3_FRAME_BUFFER_SIZE 32768
46

47 48 49 50 51
/**
 * 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];
52 53


54
/** tables for ungrouping mantissas */
55 56 57 58 59
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];
60

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

70
/** dynamic range table. converts codes to scale factors. */
71
static float dynamic_range_tab[256];
72

73
/** Adjustments in dB gain */
74 75 76
#define LEVEL_PLUS_3DB          1.4142135623730950
#define LEVEL_PLUS_1POINT5DB    1.1892071150027209
#define LEVEL_MINUS_1POINT5DB   0.8408964152537145
77 78 79
#define LEVEL_MINUS_3DB         0.7071067811865476
#define LEVEL_MINUS_4POINT5DB   0.5946035575013605
#define LEVEL_MINUS_6DB         0.5000000000000000
80
#define LEVEL_MINUS_9DB         0.3535533905932738
81
#define LEVEL_ZERO              0.0000000000000000
82 83
#define LEVEL_ONE               1.0000000000000000

84 85 86
static const float gain_levels[9] = {
    LEVEL_PLUS_3DB,
    LEVEL_PLUS_1POINT5DB,
87
    LEVEL_ONE,
88
    LEVEL_MINUS_1POINT5DB,
89 90 91
    LEVEL_MINUS_3DB,
    LEVEL_MINUS_4POINT5DB,
    LEVEL_MINUS_6DB,
92
    LEVEL_ZERO,
93 94
    LEVEL_MINUS_9DB
};
95

96 97 98 99 100 101 102 103 104 105 106 107
/**
 * 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 };

108 109 110 111 112
/**
 * 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] = {
113 114 115 116 117 118 119 120
    { { 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 }, },
121
};
122

123 124 125 126 127
/**
 * Symmetrical Dequantization
 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
 *            Tables 7.19 to 7.23
 */
128
static inline int
129
symmetric_dequant(int code, int levels)
130
{
131
    return ((code - (levels >> 1)) << 24) / levels;
132 133
}

134 135 136
/*
 * Initialize tables at runtime.
 */
137
static av_cold void ac3_tables_init(void)
138
{
139
    int i;
140

141 142 143 144 145 146 147 148
    /* 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;
    }

149 150 151 152
    /* generate grouped mantissa tables
       reference: Section 7.3.5 Ungrouping of Mantissas */
    for(i=0; i<32; i++) {
        /* bap=1 mantissas */
153 154 155
        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);
156 157 158
    }
    for(i=0; i<128; i++) {
        /* bap=2 mantissas */
159 160 161
        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);
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

        /* 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);
    }
177

178 179 180 181
    /* 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;
182
        dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
183
    }
184 185
}

186

187 188 189
/**
 * AVCodec initialization
 */
190
static av_cold int ac3_decode_init(AVCodecContext *avctx)
191
{
192 193
    AC3DecodeContext *s = avctx->priv_data;
    s->avctx = avctx;
194

195
    ac3_common_init();
196
    ac3_tables_init();
197 198
    ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
    ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
199
    ff_kbd_window_init(s->window, 5.0, 256);
200
    dsputil_init(&s->dsp, avctx);
201
    av_lfg_init(&s->dith_state, 0);
202

203
    /* set bias values for float to int16 conversion */
204
    if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
205 206
        s->add_bias = 385.0f;
        s->mul_bias = 1.0f;
207
    } else {
208 209
        s->add_bias = 0.0f;
        s->mul_bias = 32767.0f;
210 211
    }

212 213 214 215 216 217
    /* 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;
    }
218
    s->downmixed = 1;
219

220
    /* allocate context input buffer */
221
    if (avctx->error_recognition >= FF_ER_CAREFUL) {
222
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
223 224 225 226
        if (!s->input_buffer)
            return AVERROR_NOMEM;
    }

227
    avctx->sample_fmt = SAMPLE_FMT_S16;
228
    return 0;
229 230
}

231
/**
232
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
233
 * GetBitContext within AC3DecodeContext must point to
234
 * the start of the synchronized AC-3 bitstream.
235
 */
236
static int ac3_parse_header(AC3DecodeContext *s)
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
{
    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;
}

/**
274
 * Common function to parse AC-3 or E-AC-3 frame header
275 276
 */
static int parse_frame_header(AC3DecodeContext *s)
277
{
278
    AC3HeaderInfo hdr;
279
    int err;
280

281
    err = ff_ac3_parse_header(&s->gbc, &hdr);
282 283 284 285
    if(err)
        return err;

    /* get decoding parameters from header info */
286 287
    s->bit_alloc_params.sr_code     = hdr.sr_code;
    s->channel_mode                 = hdr.channel_mode;
288
    s->channel_layout               = hdr.channel_layout;
289
    s->lfe_on                       = hdr.lfe_on;
290
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
291
    s->sample_rate                  = hdr.sample_rate;
292 293 294 295 296
    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;
297 298
    s->center_mix_level             = hdr.center_mix_level;
    s->surround_mix_level           = hdr.surround_mix_level;
299
    s->num_blocks                   = hdr.num_blocks;
300
    s->frame_type                   = hdr.frame_type;
301
    s->substreamid                  = hdr.substreamid;
302

303 304 305 306 307 308 309
    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;
    }

310 311 312 313 314 315 316 317 318 319 320
    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
321
        return ac3_parse_header(s);
322
    } else {
323 324
        s->eac3 = 1;
        return ff_eac3_parse_header(s);
325
    }
326 327 328 329 330 331 332 333 334
}

/**
 * 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;
335 336
    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
337
    float norm0, norm1;
338

339 340 341
    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]];
342
    }
343
    if(s->channel_mode > 1 && s->channel_mode & 1) {
344
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
345
    }
346 347
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
        int nf = s->channel_mode - 2;
348
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
349
    }
350 351
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
        int nf = s->channel_mode - 4;
352
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
353
    }
354

Loren Merritt's avatar
Loren Merritt committed
355 356
    /* renormalize */
    norm0 = norm1 = 0.0;
357
    for(i=0; i<s->fbw_channels; i++) {
Loren Merritt's avatar
Loren Merritt committed
358 359 360 361 362 363 364 365 366 367 368 369 370
        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;
371
    }
372 373
}

374
/**
375 376
 * Decode the grouped exponents according to exponent strategy.
 * reference: Section 7.1.3 Exponent Decoding
377
 */
378
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
Justin Ruggles's avatar
Justin Ruggles committed
379
                            uint8_t absexp, int8_t *dexps)
380
{
381
    int i, j, grp, group_size;
382 383 384 385
    int dexp[256];
    int expacc, prevexp;

    /* unpack groups */
386
    group_size = exp_strategy + (exp_strategy == EXP_D45);
387
    for(grp=0,i=0; grp<ngrps; grp++) {
388
        expacc = get_bits(gbc, 7);
389 390 391
        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];
392
    }
393

394 395
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
396
    for(i=0,j=0; i<ngrps*3; i++) {
397
        prevexp += dexp[i] - 2;
398
        if (prevexp > 24U)
399
            return -1;
400 401 402 403 404
        switch (group_size) {
            case 4: dexps[j++] = prevexp;
                    dexps[j++] = prevexp;
            case 2: dexps[j++] = prevexp;
            case 1: dexps[j++] = prevexp;
405
        }
406
    }
407
    return 0;
408 409
}

410
/**
411
 * Generate transform coefficients for each coupled channel in the coupling
412 413 414
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
415
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
416 417 418 419
{
    int i, j, ch, bnd, subbnd;

    subbnd = -1;
420 421
    i = s->start_freq[CPL_CH];
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
422 423 424
        do {
            subbnd++;
            for(j=0; j<12; j++) {
425
                for(ch=1; ch<=s->fbw_channels; ch++) {
426
                    if(s->channel_in_cpl[ch]) {
427
                        s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
428
                        if (ch == 2 && s->phase_flags[bnd])
429
                            s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
430
                    }
431 432 433
                }
                i++;
            }
434
        } while(s->cpl_band_struct[subbnd]);
435 436 437
    }
}

438 439 440 441
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
442 443 444
    int b1_mant[3];
    int b2_mant[3];
    int b4_mant[2];
445 446 447
    int b1ptr;
    int b2ptr;
    int b4ptr;
448 449
} mant_groups;

450
/**
451
 * Decode the transform coefficients for a particular channel
452 453
 * reference: Section 7.3 Quantization and Decoding of Mantissas
 */
454
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
455
{
456
    GetBitContext *gbc = &s->gbc;
457
    int i, gcode, tbap, start, end;
458 459
    uint8_t *exps;
    uint8_t *bap;
460
    int *coeffs;
461

462 463
    exps = s->dexps[ch_index];
    bap = s->bap[ch_index];
464
    coeffs = s->fixed_coeffs[ch_index];
465 466
    start = s->start_freq[ch_index];
    end = s->end_freq[ch_index];
467

468
    for (i = start; i < end; i++) {
469 470
        tbap = bap[i];
        switch (tbap) {
471
            case 0:
472
                coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
Justin Ruggles's avatar
Justin Ruggles committed
473
                break;
474 475

            case 1:
476
                if(m->b1ptr > 2) {
477
                    gcode = get_bits(gbc, 5);
478 479 480 481
                    m->b1_mant[0] = b1_mantissas[gcode][0];
                    m->b1_mant[1] = b1_mantissas[gcode][1];
                    m->b1_mant[2] = b1_mantissas[gcode][2];
                    m->b1ptr = 0;
482
                }
483
                coeffs[i] = m->b1_mant[m->b1ptr++];
Justin Ruggles's avatar
Justin Ruggles committed
484
                break;
485 486

            case 2:
487
                if(m->b2ptr > 2) {
488
                    gcode = get_bits(gbc, 7);
489 490 491 492
                    m->b2_mant[0] = b2_mantissas[gcode][0];
                    m->b2_mant[1] = b2_mantissas[gcode][1];
                    m->b2_mant[2] = b2_mantissas[gcode][2];
                    m->b2ptr = 0;
493
                }
494
                coeffs[i] = m->b2_mant[m->b2ptr++];
Justin Ruggles's avatar
Justin Ruggles committed
495
                break;
496 497

            case 3:
498
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
Justin Ruggles's avatar
Justin Ruggles committed
499
                break;
500 501

            case 4:
502
                if(m->b4ptr > 1) {
503
                    gcode = get_bits(gbc, 7);
504 505 506
                    m->b4_mant[0] = b4_mantissas[gcode][0];
                    m->b4_mant[1] = b4_mantissas[gcode][1];
                    m->b4ptr = 0;
507
                }
508
                coeffs[i] = m->b4_mant[m->b4ptr++];
Justin Ruggles's avatar
Justin Ruggles committed
509
                break;
510 511

            case 5:
512
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
Justin Ruggles's avatar
Justin Ruggles committed
513
                break;
514

515
            default: {
516
                /* asymmetric dequantization */
517 518
                int qlevel = quantization_tab[tbap];
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
Justin Ruggles's avatar
Justin Ruggles committed
519
                break;
520
            }
521
        }
522
        coeffs[i] >>= exps[i];
523 524 525
    }
}

526
/**
527
 * Remove random dithering from coefficients with zero-bit mantissas
528 529
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
530
static void remove_dithering(AC3DecodeContext *s) {
531 532
    int ch, i;
    int end=0;
533
    int *coeffs;
534 535
    uint8_t *bap;

536 537
    for(ch=1; ch<=s->fbw_channels; ch++) {
        if(!s->dither_flag[ch]) {
538
            coeffs = s->fixed_coeffs[ch];
539 540 541
            bap = s->bap[ch];
            if(s->channel_in_cpl[ch])
                end = s->start_freq[CPL_CH];
542
            else
543
                end = s->end_freq[ch];
544
            for(i=0; i<end; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
545
                if(!bap[i])
546
                    coeffs[i] = 0;
547
            }
548 549 550
            if(s->channel_in_cpl[ch]) {
                bap = s->bap[CPL_CH];
                for(; i<s->end_freq[CPL_CH]; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
551
                    if(!bap[i])
552
                        coeffs[i] = 0;
553 554 555 556 557 558
                }
            }
        }
    }
}

559
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
560 561 562
                                    mant_groups *m)
{
    if (!s->channel_uses_aht[ch]) {
563
        ac3_decode_transform_coeffs_ch(s, ch, m);
564 565 566 567 568
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
        if (!blk)
569
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
570 571 572 573 574 575
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
        }
    }
}

576
/**
577
 * Decode the transform coefficients.
578
 */
579
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
580
{
581
    int ch, end;
582
    int got_cplchan = 0;
583 584
    mant_groups m;

585
    m.b1ptr = m.b2ptr = m.b4ptr = 3;
586

587
    for (ch = 1; ch <= s->channels; ch++) {
588
        /* transform coefficients for full-bandwidth channel */
589
        decode_transform_coeffs_ch(s, blk, ch, &m);
590 591
        /* tranform coefficients for coupling channel come right after the
           coefficients for the first coupled channel*/
592
        if (s->channel_in_cpl[ch])  {
593
            if (!got_cplchan) {
594
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
595
                calc_transform_coeffs_cpl(s);
596 597
                got_cplchan = 1;
            }
598
            end = s->end_freq[CPL_CH];
599
        } else {
600
            end = s->end_freq[ch];
601
        }
602
        do
603
            s->fixed_coeffs[ch][end] = 0;
604 605
        while(++end < 256);
    }
606

607
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
608
    remove_dithering(s);
609 610
}

Justin Ruggles's avatar
Justin Ruggles committed
611
/**
612
 * Stereo rematrixing.
Justin Ruggles's avatar
Justin Ruggles committed
613 614
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
615
static void do_rematrixing(AC3DecodeContext *s)
616
{
Justin Ruggles's avatar
Justin Ruggles committed
617
    int bnd, i;
618
    int end, bndend;
619
    int tmp0, tmp1;
620

621
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
622

623 624
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
        if(s->rematrixing_flags[bnd]) {
625 626
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
627 628 629 630
                tmp0 = s->fixed_coeffs[1][i];
                tmp1 = s->fixed_coeffs[2][i];
                s->fixed_coeffs[1][i] = tmp0 + tmp1;
                s->fixed_coeffs[2][i] = tmp0 - tmp1;
Justin Ruggles's avatar
Justin Ruggles committed
631 632
            }
        }
633 634
    }
}
635

636 637 638 639 640
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
641
static inline void do_imdct(AC3DecodeContext *s, int channels)
642
{
Justin Ruggles's avatar
Justin Ruggles committed
643
    int ch;
644 645 646
    float add_bias = s->add_bias;
    if(s->out_channels==1 && channels>1)
        add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
647

648
    for (ch=1; ch<=channels; ch++) {
649
        if (s->block_switch[ch]) {
Loren Merritt's avatar
Loren Merritt committed
650 651 652 653 654
            int i;
            float *x = s->tmp_output+128;
            for(i=0; i<128; i++)
                x[i] = s->transform_coeffs[ch][2*i];
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
655
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
Loren Merritt's avatar
Loren Merritt committed
656 657 658
            for(i=0; i<128; i++)
                x[i] = s->transform_coeffs[ch][2*i+1];
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
659
        } else {
Loren Merritt's avatar
Loren Merritt committed
660
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
661
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
Loren Merritt's avatar
Loren Merritt committed
662
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
663
        }
664 665 666
    }
}

667
/**
668
 * Downmix the output to mono or stereo.
669
 */
Loren Merritt's avatar
Loren Merritt committed
670
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
671 672
{
    int i, j;
673
    float v0, v1;
Loren Merritt's avatar
Loren Merritt committed
674 675
    if(out_ch == 2) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
676
            v0 = v1 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
677 678 679
            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
680 681 682
            }
            samples[0][i] = v0;
            samples[1][i] = v1;
683
        }
Loren Merritt's avatar
Loren Merritt committed
684 685
    } else if(out_ch == 1) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
686
            v0 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
687 688
            for(j=0; j<in_ch; j++)
                v0 += samples[j][i] * matrix[j][0];
Loren Merritt's avatar
Loren Merritt committed
689
            samples[0][i] = v0;
690 691 692 693
        }
    }
}

694 695 696 697 698
/**
 * Upmix delay samples from stereo to original channel layout.
 */
static void ac3_upmix_delay(AC3DecodeContext *s)
{
699
    int channel_data_size = sizeof(s->delay[0]);
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
    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;
    }
}

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
/**
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
 * @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] band_struct decoded band structure
 * @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,
738 739
                                  uint8_t *band_struct, int *num_bands,
                                  uint8_t *band_sizes)
740
{
741
    int subbnd, bnd, n_subbands, n_bands=0;
742
    uint8_t bnd_sz[22];
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761

    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++) {
            band_struct[subbnd] = get_bits1(gbc);
        }
    } else if (!blk) {
        memcpy(band_struct,
               &default_band_struct[start_subband+1],
               n_subbands-1);
    }
    band_struct[n_subbands-1] = 0;

    /* 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 ) {
762
        n_bands = n_subbands;
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
        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)
779
        memcpy(band_sizes, bnd_sz, n_bands);