ac3dec.c 47.1 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 "ac3_parser.h"
39
#include "ac3dec.h"
40
#include "ac3dec_data.h"
41

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

184

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

193
    ac3_common_init();
194
    ac3_tables_init();
195 196
    ff_mdct_init(&s->imdct_256, 8, 1);
    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 204
        s->add_bias = 385.0f;
        s->mul_bias = 1.0f;
205
    } else {
206 207
        s->add_bias = 0.0f;
        s->mul_bias = 32767.0f;
208 209
    }

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

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

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 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
{
    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;
}

/**
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 281 282 283
    if(err)
        return err;

    /* get decoding parameters from header info */
284 285
    s->bit_alloc_params.sr_code     = hdr.sr_code;
    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 290 291 292 293
    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;
294 295
    s->center_mix_level             = hdr.center_mix_level;
    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 301 302 303 304 305 306
    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;
    }

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

/**
 * 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;
332 333
    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
334
    float norm0, norm1;
335

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

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

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

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

391 392 393
    /* convert to absolute exps and expand groups */
    prevexp = absexp;
    for(i=0; i<ngrps*3; i++) {
394 395 396
        prevexp += dexp[i] - 2;
        if (prevexp < 0 || prevexp > 24)
            return -1;
397 398
        for(j=0; j<group_size; j++) {
            dexps[(i*group_size)+j] = prevexp;
399
        }
400
    }
401
    return 0;
402 403
}

404
/**
405
 * Generate transform coefficients for each coupled channel in the coupling
406 407 408
 * range using the coupling coefficients and coupling coordinates.
 * reference: Section 7.4.3 Coupling Coordinate Format
 */
409
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
410 411 412 413
{
    int i, j, ch, bnd, subbnd;

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

432 433 434 435
/**
 * Grouped mantissas for 3-level 5-level and 11-level quantization
 */
typedef struct {
436 437 438
    int b1_mant[3];
    int b2_mant[3];
    int b4_mant[2];
439 440 441
    int b1ptr;
    int b2ptr;
    int b4ptr;
442 443
} mant_groups;

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

456 457
    exps = s->dexps[ch_index];
    bap = s->bap[ch_index];
458
    coeffs = s->fixed_coeffs[ch_index];
459 460
    start = s->start_freq[ch_index];
    end = s->end_freq[ch_index];
461

462
    for (i = start; i < end; i++) {
463 464
        tbap = bap[i];
        switch (tbap) {
465
            case 0:
466
                coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
Justin Ruggles's avatar
Justin Ruggles committed
467
                break;
468 469

            case 1:
470
                if(m->b1ptr > 2) {
471
                    gcode = get_bits(gbc, 5);
472 473 474 475
                    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;
476
                }
477
                coeffs[i] = m->b1_mant[m->b1ptr++];
Justin Ruggles's avatar
Justin Ruggles committed
478
                break;
479 480

            case 2:
481
                if(m->b2ptr > 2) {
482
                    gcode = get_bits(gbc, 7);
483 484 485 486
                    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;
487
                }
488
                coeffs[i] = m->b2_mant[m->b2ptr++];
Justin Ruggles's avatar
Justin Ruggles committed
489
                break;
490 491

            case 3:
492
                coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
Justin Ruggles's avatar
Justin Ruggles committed
493
                break;
494 495

            case 4:
496
                if(m->b4ptr > 1) {
497
                    gcode = get_bits(gbc, 7);
498 499 500
                    m->b4_mant[0] = b4_mantissas[gcode][0];
                    m->b4_mant[1] = b4_mantissas[gcode][1];
                    m->b4ptr = 0;
501
                }
502
                coeffs[i] = m->b4_mant[m->b4ptr++];
Justin Ruggles's avatar
Justin Ruggles committed
503
                break;
504 505

            case 5:
506
                coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
Justin Ruggles's avatar
Justin Ruggles committed
507
                break;
508

509
            default: {
510
                /* asymmetric dequantization */
511 512
                int qlevel = quantization_tab[tbap];
                coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
Justin Ruggles's avatar
Justin Ruggles committed
513
                break;
514
            }
515
        }
516
        coeffs[i] >>= exps[i];
517 518 519
    }
}

520
/**
521
 * Remove random dithering from coefficients with zero-bit mantissas
522 523
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
 */
524
static void remove_dithering(AC3DecodeContext *s) {
525 526
    int ch, i;
    int end=0;
527
    int *coeffs;
528 529
    uint8_t *bap;

530 531
    for(ch=1; ch<=s->fbw_channels; ch++) {
        if(!s->dither_flag[ch]) {
532
            coeffs = s->fixed_coeffs[ch];
533 534 535
            bap = s->bap[ch];
            if(s->channel_in_cpl[ch])
                end = s->start_freq[CPL_CH];
536
            else
537
                end = s->end_freq[ch];
538
            for(i=0; i<end; i++) {
Justin Ruggles's avatar
Justin Ruggles committed
539
                if(!bap[i])
540
                    coeffs[i] = 0;
541
            }
542 543 544
            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
545
                    if(!bap[i])
546
                        coeffs[i] = 0;
547 548 549 550 551 552
                }
            }
        }
    }
}

553
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
554 555 556
                                    mant_groups *m)
{
    if (!s->channel_uses_aht[ch]) {
557
        ac3_decode_transform_coeffs_ch(s, ch, m);
558 559 560 561 562
    } else {
        /* if AHT is used, mantissas for all blocks are encoded in the first
           block of the frame. */
        int bin;
        if (!blk)
563
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
564 565 566 567 568 569
        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];
        }
    }
}

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 578
    mant_groups m;

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 585
        /* tranform coefficients for coupling channel come right after the
           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 591
                got_cplchan = 1;
            }
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 599
        while(++end < 256);
    }
600

601
    /* zero the dithered coefficients for appropriate channels */
Justin Ruggles's avatar
Justin Ruggles committed
602
    remove_dithering(s);
603 604
}

Justin Ruggles's avatar
Justin Ruggles committed
605
/**
606
 * Stereo rematrixing.
Justin Ruggles's avatar
Justin Ruggles committed
607 608
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
 */
609
static void do_rematrixing(AC3DecodeContext *s)
610
{
Justin Ruggles's avatar
Justin Ruggles committed
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 618
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
        if(s->rematrixing_flags[bnd]) {
619 620
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
621 622 623 624
                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
625 626
            }
        }
627 628
    }
}
629

630 631 632 633 634
/**
 * Inverse MDCT Transform.
 * Convert frequency domain coefficients to time-domain audio samples.
 * reference: Section 7.9.4 Transformation Equations
 */
635
static inline void do_imdct(AC3DecodeContext *s, int channels)
636
{
Justin Ruggles's avatar
Justin Ruggles committed
637
    int ch;
638 639 640
    float add_bias = s->add_bias;
    if(s->out_channels==1 && channels>1)
        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]) {
Loren Merritt's avatar
Loren Merritt committed
644 645 646 647 648
            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);
649
            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
650 651 652
            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);
653
        } else {
Loren Merritt's avatar
Loren Merritt committed
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);
Loren Merritt's avatar
Loren Merritt committed
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
 */
Loren Merritt's avatar
Loren Merritt committed
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;
Loren Merritt's avatar
Loren Merritt committed
668 669
    if(out_ch == 2) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
670
            v0 = v1 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
671 672 673
            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
674 675 676
            }
            samples[0][i] = v0;
            samples[1][i] = v1;
677
        }
Loren Merritt's avatar
Loren Merritt committed
678 679
    } else if(out_ch == 1) {
        for(i=0; i<len; i++) {
Loren Merritt's avatar
Loren Merritt committed
680
            v0 = 0.0f;
Loren Merritt's avatar
Loren Merritt committed
681 682
            for(j=0; j<in_ch; j++)
                v0 += samples[j][i] * matrix[j][0];
Loren Merritt's avatar
Loren Merritt committed
683
            samples[0][i] = v0;
684 685 686 687
        }
    }
}

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

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
/**
 * 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_subbands number of subbands (optionally NULL)
 * @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,
                                  uint8_t *band_struct, int *num_subbands,
734
                                  int *num_bands, uint8_t *band_sizes)
735
{
736
    int subbnd, bnd, n_subbands, n_bands=0;
737
    uint8_t bnd_sz[22];
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756

    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 ) {
757
        n_bands = n_subbands;
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
        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_subbands)
        *num_subbands = n_subbands;
    if (num_bands)
        *num_bands = n_bands;
    if (band_sizes)
Justin Ruggles's avatar