Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 1754fe4d

History | View | Annotate | Download (47.6 KB)

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