Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ b5ec6383

History | View | Annotate | Download (51.9 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 4c57cde9 Justin Ruggles
    ff_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 b5ec6383 Justin Ruggles
    /* set scale value for float to int16 conversion */
199
    s->mul_bias = 32767.0f;
200 4e092320 Justin Ruggles
201 95283c17 Justin Ruggles
    /* allow downmixing to stereo or mono */
202
    if (avctx->channels > 0 && avctx->request_channels > 0 &&
203
            avctx->request_channels < avctx->channels &&
204
            avctx->request_channels <= 2) {
205
        avctx->channels = avctx->request_channels;
206
    }
207 38dae9c3 Justin Ruggles
    s->downmixed = 1;
208 95283c17 Justin Ruggles
209 509fdb0b Justin Ruggles
    /* allocate context input buffer */
210 047599a4 Michael Niedermayer
    if (avctx->error_recognition >= FF_ER_CAREFUL) {
211 8e33132b Justin Ruggles
        s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
212 509fdb0b Justin Ruggles
        if (!s->input_buffer)
213 2874c81c Stefano Sabatini
            return AVERROR(ENOMEM);
214 509fdb0b Justin Ruggles
    }
215
216 5d6e4c16 Stefano Sabatini
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
217 1b293437 Justin Ruggles
    return 0;
218 2aa2c5c4 Justin Ruggles
}
219
220 9fc1ab72 Justin Ruggles
/**
221 5066f515 Justin Ruggles
 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
222 c7cfc48f Justin Ruggles
 * GetBitContext within AC3DecodeContext must point to
223 14b70628 Justin Ruggles
 * the start of the synchronized AC-3 bitstream.
224 c7cfc48f Justin Ruggles
 */
225 d802d7ca Justin Ruggles
static int ac3_parse_header(AC3DecodeContext *s)
226 2aa2c5c4 Justin Ruggles
{
227 4397d95c Justin Ruggles
    GetBitContext *gbc = &s->gbc;
228
    int i;
229
230
    /* read the rest of the bsi. read twice for dual mono mode. */
231
    i = !(s->channel_mode);
232
    do {
233
        skip_bits(gbc, 5); // skip dialog normalization
234
        if (get_bits1(gbc))
235
            skip_bits(gbc, 8); //skip compression
236
        if (get_bits1(gbc))
237
            skip_bits(gbc, 8); //skip language code
238
        if (get_bits1(gbc))
239
            skip_bits(gbc, 7); //skip audio production information
240
    } while (i--);
241
242
    skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
243
244
    /* skip the timecodes (or extra bitstream information for Alternate Syntax)
245
       TODO: read & use the xbsi1 downmix levels */
246
    if (get_bits1(gbc))
247
        skip_bits(gbc, 14); //skip timecode1 / xbsi1
248
    if (get_bits1(gbc))
249
        skip_bits(gbc, 14); //skip timecode2 / xbsi2
250
251
    /* skip additional bitstream info */
252
    if (get_bits1(gbc)) {
253
        i = get_bits(gbc, 6);
254
        do {
255
            skip_bits(gbc, 8);
256
        } while(i--);
257
    }
258
259
    return 0;
260
}
261
262
/**
263 14b70628 Justin Ruggles
 * Common function to parse AC-3 or E-AC-3 frame header
264 4397d95c Justin Ruggles
 */
265
static int parse_frame_header(AC3DecodeContext *s)
266
{
267 9fc1ab72 Justin Ruggles
    AC3HeaderInfo hdr;
268 4397d95c Justin Ruggles
    int err;
269 9fc1ab72 Justin Ruggles
270 ba7f712c Justin Ruggles
    err = ff_ac3_parse_header(&s->gbc, &hdr);
271 9fc1ab72 Justin Ruggles
    if(err)
272
        return err;
273
274
    /* get decoding parameters from header info */
275 d802d7ca Justin Ruggles
    s->bit_alloc_params.sr_code     = hdr.sr_code;
276
    s->channel_mode                 = hdr.channel_mode;
277 bfeca7be Justin Ruggles
    s->channel_layout               = hdr.channel_layout;
278 1b70d88b Justin Ruggles
    s->lfe_on                       = hdr.lfe_on;
279 d802d7ca Justin Ruggles
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
280 866181e5 Justin Ruggles
    s->sample_rate                  = hdr.sample_rate;
281 d802d7ca Justin Ruggles
    s->bit_rate                     = hdr.bit_rate;
282
    s->channels                     = hdr.channels;
283
    s->fbw_channels                 = s->channels - s->lfe_on;
284
    s->lfe_ch                       = s->fbw_channels + 1;
285
    s->frame_size                   = hdr.frame_size;
286 55736cfb Bartlomiej Wolowiec
    s->center_mix_level             = hdr.center_mix_level;
287
    s->surround_mix_level           = hdr.surround_mix_level;
288 6730e9f3 Justin Ruggles
    s->num_blocks                   = hdr.num_blocks;
289 be5f17b9 Justin Ruggles
    s->frame_type                   = hdr.frame_type;
290 3596aa6f Justin Ruggles
    s->substreamid                  = hdr.substreamid;
291 7bfd22f2 Justin Ruggles
292 6e74513a Justin Ruggles
    if(s->lfe_on) {
293
        s->start_freq[s->lfe_ch] = 0;
294
        s->end_freq[s->lfe_ch] = 7;
295
        s->num_exp_groups[s->lfe_ch] = 2;
296
        s->channel_in_cpl[s->lfe_ch] = 0;
297
    }
298
299 bf09b550 Justin Ruggles
    if (hdr.bitstream_id <= 10) {
300
        s->eac3                  = 0;
301
        s->snr_offset_strategy   = 2;
302
        s->block_switch_syntax   = 1;
303
        s->dither_flag_syntax    = 1;
304
        s->bit_allocation_syntax = 1;
305
        s->fast_gain_syntax      = 0;
306
        s->first_cpl_leak        = 0;
307
        s->dba_syntax            = 1;
308
        s->skip_syntax           = 1;
309
        memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
310 ab2a942a Justin Ruggles
        return ac3_parse_header(s);
311 d1515324 Diego Biurrun
    } else if (CONFIG_EAC3_DECODER) {
312 1f6a594d Justin Ruggles
        s->eac3 = 1;
313
        return ff_eac3_parse_header(s);
314 d1515324 Diego Biurrun
    } else {
315
        av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
316
        return -1;
317 bf09b550 Justin Ruggles
    }
318 f0b3a7ba Justin Ruggles
}
319
320
/**
321
 * Set stereo downmixing coefficients based on frame header info.
322
 * reference: Section 7.8.2 Downmixing Into Two Channels
323
 */
324
static void set_downmix_coeffs(AC3DecodeContext *s)
325
{
326
    int i;
327 30f71adc Justin Ruggles
    float cmix = gain_levels[center_levels[s->center_mix_level]];
328
    float smix = gain_levels[surround_levels[s->surround_mix_level]];
329 557ac0c4 Loren Merritt
    float norm0, norm1;
330 f0b3a7ba Justin Ruggles
331 d802d7ca Justin Ruggles
    for(i=0; i<s->fbw_channels; i++) {
332
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
333
        s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
334 3bbb0bf8 Justin Ruggles
    }
335 d802d7ca Justin Ruggles
    if(s->channel_mode > 1 && s->channel_mode & 1) {
336 f0b3a7ba Justin Ruggles
        s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
337 3bbb0bf8 Justin Ruggles
    }
338 d802d7ca Justin Ruggles
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
339
        int nf = s->channel_mode - 2;
340 f0b3a7ba Justin Ruggles
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
341 3bbb0bf8 Justin Ruggles
    }
342 d802d7ca Justin Ruggles
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
343
        int nf = s->channel_mode - 4;
344 f0b3a7ba Justin Ruggles
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
345 3bbb0bf8 Justin Ruggles
    }
346 9d10e6e6 Justin Ruggles
347 557ac0c4 Loren Merritt
    /* renormalize */
348
    norm0 = norm1 = 0.0;
349 9d10e6e6 Justin Ruggles
    for(i=0; i<s->fbw_channels; i++) {
350 557ac0c4 Loren Merritt
        norm0 += s->downmix_coeffs[i][0];
351
        norm1 += s->downmix_coeffs[i][1];
352
    }
353
    norm0 = 1.0f / norm0;
354
    norm1 = 1.0f / norm1;
355
    for(i=0; i<s->fbw_channels; i++) {
356
        s->downmix_coeffs[i][0] *= norm0;
357
        s->downmix_coeffs[i][1] *= norm1;
358
    }
359
360
    if(s->output_mode == AC3_CHMODE_MONO) {
361
        for(i=0; i<s->fbw_channels; i++)
362
            s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
363 9d10e6e6 Justin Ruggles
    }
364 2aa2c5c4 Justin Ruggles
}
365
366 3bb004fc Justin Ruggles
/**
367 5066f515 Justin Ruggles
 * Decode the grouped exponents according to exponent strategy.
368
 * reference: Section 7.1.3 Exponent Decoding
369 2aa2c5c4 Justin Ruggles
 */
370 ce7d842f Justin Ruggles
static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
371 80670324 Justin Ruggles
                            uint8_t absexp, int8_t *dexps)
372 2aa2c5c4 Justin Ruggles
{
373 e2270b4e Justin Ruggles
    int i, j, grp, group_size;
374 4415076f Justin Ruggles
    int dexp[256];
375
    int expacc, prevexp;
376
377
    /* unpack groups */
378 e2270b4e Justin Ruggles
    group_size = exp_strategy + (exp_strategy == EXP_D45);
379 4415076f Justin Ruggles
    for(grp=0,i=0; grp<ngrps; grp++) {
380 23c8cb89 Justin Ruggles
        expacc = get_bits(gbc, 7);
381 7417120b Justin Ruggles
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
382
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
383
        dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
384 4415076f Justin Ruggles
    }
385 2aa2c5c4 Justin Ruggles
386 4415076f Justin Ruggles
    /* convert to absolute exps and expand groups */
387
    prevexp = absexp;
388 96f229d6 Justin Ruggles
    for(i=0,j=0; i<ngrps*3; i++) {
389 ce7d842f Justin Ruggles
        prevexp += dexp[i] - 2;
390 2ceccf04 Justin Ruggles
        if (prevexp > 24U)
391 ce7d842f Justin Ruggles
            return -1;
392 96f229d6 Justin Ruggles
        switch (group_size) {
393
            case 4: dexps[j++] = prevexp;
394
                    dexps[j++] = prevexp;
395
            case 2: dexps[j++] = prevexp;
396
            case 1: dexps[j++] = prevexp;
397 1b293437 Justin Ruggles
        }
398 2aa2c5c4 Justin Ruggles
    }
399 ce7d842f Justin Ruggles
    return 0;
400 2aa2c5c4 Justin Ruggles
}
401
402 d7dc7ad0 Justin Ruggles
/**
403 5066f515 Justin Ruggles
 * Generate transform coefficients for each coupled channel in the coupling
404 d7dc7ad0 Justin Ruggles
 * range using the coupling coefficients and coupling coordinates.
405
 * reference: Section 7.4.3 Coupling Coordinate Format
406
 */
407 5e3e4075 Justin Ruggles
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
408 d7dc7ad0 Justin Ruggles
{
409 3b6c5ad2 Justin Ruggles
    int bin, band, ch;
410 02587373 Justin Ruggles
411
    bin = s->start_freq[CPL_CH];
412
    for (band = 0; band < s->num_cpl_bands; band++) {
413 8b11b44e Justin Ruggles
        int band_start = bin;
414 3b6c5ad2 Justin Ruggles
        int band_end = bin + s->cpl_band_sizes[band];
415 8b11b44e Justin Ruggles
        for (ch = 1; ch <= s->fbw_channels; ch++) {
416
            if (s->channel_in_cpl[ch]) {
417 1460c790 Reimar Döffinger
                int cpl_coord = s->cpl_coords[ch][band] << 5;
418 8b11b44e Justin Ruggles
                for (bin = band_start; bin < band_end; bin++) {
419 1460c790 Reimar Döffinger
                    s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
420 8b11b44e Justin Ruggles
                }
421
                if (ch == 2 && s->phase_flags[band]) {
422
                    for (bin = band_start; bin < band_end; bin++)
423
                        s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
424 d7dc7ad0 Justin Ruggles
                }
425 b972c06a Justin Ruggles
            }
426 60313902 Justin Ruggles
        }
427 8b11b44e Justin Ruggles
        bin = band_end;
428 d7dc7ad0 Justin Ruggles
    }
429
}
430
431 5066f515 Justin Ruggles
/**
432
 * Grouped mantissas for 3-level 5-level and 11-level quantization
433
 */
434
typedef struct {
435 d869a460 Jason Garrett-Glaser
    int b1_mant[2];
436
    int b2_mant[2];
437
    int b4_mant;
438
    int b1;
439
    int b2;
440
    int b4;
441 486637af Justin Ruggles
} mant_groups;
442
443 5066f515 Justin Ruggles
/**
444 e522bd49 Justin Ruggles
 * Decode the transform coefficients for a particular channel
445 5066f515 Justin Ruggles
 * reference: Section 7.3 Quantization and Decoding of Mantissas
446
 */
447 e43b29ab Justin Ruggles
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
448 1b293437 Justin Ruggles
{
449 d869a460 Jason Garrett-Glaser
    int start_freq = s->start_freq[ch_index];
450
    int end_freq = s->end_freq[ch_index];
451
    uint8_t *baps = s->bap[ch_index];
452
    int8_t *exps = s->dexps[ch_index];
453
    int *coeffs = s->fixed_coeffs[ch_index];
454 25dcd182 Justin Ruggles
    int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
455 d802d7ca Justin Ruggles
    GetBitContext *gbc = &s->gbc;
456 d869a460 Jason Garrett-Glaser
    int freq;
457 2fbbd087 Justin Ruggles
458 d869a460 Jason Garrett-Glaser
    for(freq = start_freq; freq < end_freq; freq++){
459
        int bap = baps[freq];
460
        int mantissa;
461
        switch(bap){
462 1b293437 Justin Ruggles
            case 0:
463 25dcd182 Justin Ruggles
                if (dither)
464 a521aadf Justin Ruggles
                    mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
465 25dcd182 Justin Ruggles
                else
466
                    mantissa = 0;
467 d63f6fea Justin Ruggles
                break;
468 1b293437 Justin Ruggles
            case 1:
469 d869a460 Jason Garrett-Glaser
                if(m->b1){
470
                    m->b1--;
471
                    mantissa = m->b1_mant[m->b1];
472
                }
473
                else{
474
                    int bits      = get_bits(gbc, 5);
475
                    mantissa      = b1_mantissas[bits][0];
476
                    m->b1_mant[1] = b1_mantissas[bits][1];
477
                    m->b1_mant[0] = b1_mantissas[bits][2];
478
                    m->b1         = 2;
479 1b293437 Justin Ruggles
                }
480 d63f6fea Justin Ruggles
                break;
481 1b293437 Justin Ruggles
            case 2:
482 d869a460 Jason Garrett-Glaser
                if(m->b2){
483
                    m->b2--;
484
                    mantissa = m->b2_mant[m->b2];
485
                }
486
                else{
487
                    int bits      = get_bits(gbc, 7);
488
                    mantissa      = b2_mantissas[bits][0];
489
                    m->b2_mant[1] = b2_mantissas[bits][1];
490
                    m->b2_mant[0] = b2_mantissas[bits][2];
491
                    m->b2         = 2;
492 1b293437 Justin Ruggles
                }
493 d63f6fea Justin Ruggles
                break;
494 1b293437 Justin Ruggles
            case 3:
495 d869a460 Jason Garrett-Glaser
                mantissa = b3_mantissas[get_bits(gbc, 3)];
496 d63f6fea Justin Ruggles
                break;
497 1b293437 Justin Ruggles
            case 4:
498 d869a460 Jason Garrett-Glaser
                if(m->b4){
499
                    m->b4 = 0;
500
                    mantissa = m->b4_mant;
501
                }
502
                else{
503
                    int bits   = get_bits(gbc, 7);
504
                    mantissa   = b4_mantissas[bits][0];
505
                    m->b4_mant = b4_mantissas[bits][1];
506
                    m->b4      = 1;
507 1b293437 Justin Ruggles
                }
508 d63f6fea Justin Ruggles
                break;
509 1b293437 Justin Ruggles
            case 5:
510 d869a460 Jason Garrett-Glaser
                mantissa = b5_mantissas[get_bits(gbc, 4)];
511 d63f6fea Justin Ruggles
                break;
512 d869a460 Jason Garrett-Glaser
            default: /* 6 to 15 */
513
                mantissa = get_bits(gbc, quantization_tab[bap]);
514
                /* Shift mantissa and sign-extend it. */
515
                mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
516 d63f6fea Justin Ruggles
                break;
517 1b293437 Justin Ruggles
        }
518 d869a460 Jason Garrett-Glaser
        coeffs[freq] = mantissa >> exps[freq];
519 1b293437 Justin Ruggles
    }
520
}
521
522 60f07fad Justin Ruggles
/**
523 25dcd182 Justin Ruggles
 * Remove random dithering from coupling range coefficients with zero-bit
524
 * mantissas for coupled channels which do not use dithering.
525 60f07fad Justin Ruggles
 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
526
 */
527 d802d7ca Justin Ruggles
static void remove_dithering(AC3DecodeContext *s) {
528 60f07fad Justin Ruggles
    int ch, i;
529
530 d802d7ca Justin Ruggles
    for(ch=1; ch<=s->fbw_channels; ch++) {
531 25dcd182 Justin Ruggles
        if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
532
            for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
533
                if(!s->bap[CPL_CH][i])
534
                    s->fixed_coeffs[ch][i] = 0;
535 60f07fad Justin Ruggles
            }
536
        }
537
    }
538
}
539
540 6a68105e Justin Ruggles
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
541 bf09b550 Justin Ruggles
                                    mant_groups *m)
542
{
543
    if (!s->channel_uses_aht[ch]) {
544 6a68105e Justin Ruggles
        ac3_decode_transform_coeffs_ch(s, ch, m);
545 bf09b550 Justin Ruggles
    } else {
546
        /* if AHT is used, mantissas for all blocks are encoded in the first
547
           block of the frame. */
548
        int bin;
549 d1515324 Diego Biurrun
        if (!blk && CONFIG_EAC3_DECODER)
550 6a68105e Justin Ruggles
            ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
551 bf09b550 Justin Ruggles
        for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
552 ae04de31 Justin Ruggles
            s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
553 bf09b550 Justin Ruggles
        }
554
    }
555
}
556
557 5066f515 Justin Ruggles
/**
558 164e169f Justin Ruggles
 * Decode the transform coefficients.
559 c7cfc48f Justin Ruggles
 */
560 e43b29ab Justin Ruggles
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
561 1b293437 Justin Ruggles
{
562 7b4076a7 Justin Ruggles
    int ch, end;
563 1b293437 Justin Ruggles
    int got_cplchan = 0;
564 486637af Justin Ruggles
    mant_groups m;
565
566 d869a460 Jason Garrett-Glaser
    m.b1 = m.b2 = m.b4 = 0;
567 1b293437 Justin Ruggles
568 d802d7ca Justin Ruggles
    for (ch = 1; ch <= s->channels; ch++) {
569 5066f515 Justin Ruggles
        /* transform coefficients for full-bandwidth channel */
570 e43b29ab Justin Ruggles
        decode_transform_coeffs_ch(s, blk, ch, &m);
571 5066f515 Justin Ruggles
        /* tranform coefficients for coupling channel come right after the
572
           coefficients for the first coupled channel*/
573 d802d7ca Justin Ruggles
        if (s->channel_in_cpl[ch])  {
574 486637af Justin Ruggles
            if (!got_cplchan) {
575 e43b29ab Justin Ruggles
                decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
576 5e3e4075 Justin Ruggles
                calc_transform_coeffs_cpl(s);
577 486637af Justin Ruggles
                got_cplchan = 1;
578
            }
579 d802d7ca Justin Ruggles
            end = s->end_freq[CPL_CH];
580 eaf84d97 Justin Ruggles
        } else {
581 d802d7ca Justin Ruggles
            end = s->end_freq[ch];
582 eaf84d97 Justin Ruggles
        }
583 486637af Justin Ruggles
        do
584 bd98e9e2 Justin Ruggles
            s->fixed_coeffs[ch][end] = 0;
585 486637af Justin Ruggles
        while(++end < 256);
586
    }
587 1b293437 Justin Ruggles
588 ea364c74 Justin Ruggles
    /* zero the dithered coefficients for appropriate channels */
589 86662b1c Justin Ruggles
    remove_dithering(s);
590 2aa2c5c4 Justin Ruggles
}
591
592 8b60bbbf Justin Ruggles
/**
593 5066f515 Justin Ruggles
 * Stereo rematrixing.
594 8b60bbbf Justin Ruggles
 * reference: Section 7.5.4 Rematrixing : Decoding Technique
595
 */
596 d802d7ca Justin Ruggles
static void do_rematrixing(AC3DecodeContext *s)
597 1b293437 Justin Ruggles
{
598 8b60bbbf Justin Ruggles
    int bnd, i;
599 2fbbd087 Justin Ruggles
    int end, bndend;
600
601 d802d7ca Justin Ruggles
    end = FFMIN(s->end_freq[1], s->end_freq[2]);
602 1b293437 Justin Ruggles
603 d802d7ca Justin Ruggles
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
604
        if(s->rematrixing_flags[bnd]) {
605 227322b8 Justin Ruggles
            bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
606 187bc061 Justin Ruggles
            for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
607 2ed44396 Justin Ruggles
                int tmp0 = s->fixed_coeffs[1][i];
608 3fdccca0 Justin Ruggles
                s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
609 2ed44396 Justin Ruggles
                s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
610 8b60bbbf Justin Ruggles
            }
611
        }
612 1b293437 Justin Ruggles
    }
613
}
614 2aa2c5c4 Justin Ruggles
615 5066f515 Justin Ruggles
/**
616
 * Inverse MDCT Transform.
617
 * Convert frequency domain coefficients to time-domain audio samples.
618
 * reference: Section 7.9.4 Transformation Equations
619
 */
620 38dae9c3 Justin Ruggles
static inline void do_imdct(AC3DecodeContext *s, int channels)
621 486637af Justin Ruggles
{
622 0de73a46 Justin Ruggles
    int ch;
623 7b4076a7 Justin Ruggles
624 e2270b4e Justin Ruggles
    for (ch=1; ch<=channels; ch++) {
625 d802d7ca Justin Ruggles
        if (s->block_switch[ch]) {
626 916d5d6c Loren Merritt
            int i;
627
            float *x = s->tmp_output+128;
628
            for(i=0; i<128; i++)
629
                x[i] = s->transform_coeffs[ch][2*i];
630
            ff_imdct_half(&s->imdct_256, s->tmp_output, x);
631 9d06d7bc Justin Ruggles
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 0, 128);
632 916d5d6c Loren Merritt
            for(i=0; i<128; i++)
633
                x[i] = s->transform_coeffs[ch][2*i+1];
634
            ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
635 eaf84d97 Justin Ruggles
        } else {
636 916d5d6c Loren Merritt
            ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
637 9d06d7bc Justin Ruggles
            s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 0, 128);
638 916d5d6c Loren Merritt
            memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
639 eaf84d97 Justin Ruggles
        }
640 486637af Justin Ruggles
    }
641
}
642
643 3bbb0bf8 Justin Ruggles
/**
644 5066f515 Justin Ruggles
 * Downmix the output to mono or stereo.
645 3bbb0bf8 Justin Ruggles
 */
646 ac2e5564 Loren Merritt
void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
647 3bbb0bf8 Justin Ruggles
{
648
    int i, j;
649 9d10e6e6 Justin Ruggles
    float v0, v1;
650 ac2e5564 Loren Merritt
    if(out_ch == 2) {
651
        for(i=0; i<len; i++) {
652 557ac0c4 Loren Merritt
            v0 = v1 = 0.0f;
653 ac2e5564 Loren Merritt
            for(j=0; j<in_ch; j++) {
654
                v0 += samples[j][i] * matrix[j][0];
655
                v1 += samples[j][i] * matrix[j][1];
656 557ac0c4 Loren Merritt
            }
657
            samples[0][i] = v0;
658
            samples[1][i] = v1;
659 3bbb0bf8 Justin Ruggles
        }
660 ac2e5564 Loren Merritt
    } else if(out_ch == 1) {
661
        for(i=0; i<len; i++) {
662 557ac0c4 Loren Merritt
            v0 = 0.0f;
663 ac2e5564 Loren Merritt
            for(j=0; j<in_ch; j++)
664
                v0 += samples[j][i] * matrix[j][0];
665 557ac0c4 Loren Merritt
            samples[0][i] = v0;
666 3bbb0bf8 Justin Ruggles
        }
667
    }
668
}
669
670 5066f515 Justin Ruggles
/**
671 38dae9c3 Justin Ruggles
 * Upmix delay samples from stereo to original channel layout.
672
 */
673
static void ac3_upmix_delay(AC3DecodeContext *s)
674
{
675 e6300276 Justin Ruggles
    int channel_data_size = sizeof(s->delay[0]);
676 38dae9c3 Justin Ruggles
    switch(s->channel_mode) {
677
        case AC3_CHMODE_DUALMONO:
678
        case AC3_CHMODE_STEREO:
679
            /* upmix mono to stereo */
680
            memcpy(s->delay[1], s->delay[0], channel_data_size);
681
            break;
682
        case AC3_CHMODE_2F2R:
683
            memset(s->delay[3], 0, channel_data_size);
684
        case AC3_CHMODE_2F1R:
685
            memset(s->delay[2], 0, channel_data_size);
686
            break;
687
        case AC3_CHMODE_3F2R:
688
            memset(s->delay[4], 0, channel_data_size);
689
        case AC3_CHMODE_3F1R:
690
            memset(s->delay[3], 0, channel_data_size);
691
        case AC3_CHMODE_3F:
692
            memcpy(s->delay[2], s->delay[1], channel_data_size);
693
            memset(s->delay[1], 0, channel_data_size);
694
            break;
695
    }
696
}
697
698
/**
699 0c5d750d Justin Ruggles
 * Decode band structure for coupling, spectral extension, or enhanced coupling.
700 eb98cdfa Justin Ruggles
 * The band structure defines how many subbands are in each band.  For each
701
 * subband in the range, 1 means it is combined with the previous band, and 0
702
 * means that it starts a new band.
703
 *
704 0c5d750d Justin Ruggles
 * @param[in] gbc bit reader context
705
 * @param[in] blk block number
706
 * @param[in] eac3 flag to indicate E-AC-3
707
 * @param[in] ecpl flag to indicate enhanced coupling
708
 * @param[in] start_subband subband number for start of range
709
 * @param[in] end_subband subband number for end of range
710
 * @param[in] default_band_struct default band structure table
711
 * @param[out] num_bands number of bands (optionally NULL)
712
 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
713
 */
714
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
715
                                  int ecpl, int start_subband, int end_subband,
716
                                  const uint8_t *default_band_struct,
717 c36ea060 Justin Ruggles
                                  int *num_bands, uint8_t *band_sizes)
718 0c5d750d Justin Ruggles
{
719 f23dc1e1 Justin Ruggles
    int subbnd, bnd, n_subbands, n_bands=0;
720 75b53b21 Justin Ruggles
    uint8_t bnd_sz[22];
721 3f937168 Justin Ruggles
    uint8_t coded_band_struct[22];
722
    const uint8_t *band_struct;
723 0c5d750d Justin Ruggles
724
    n_subbands = end_subband - start_subband;
725
726
    /* decode band structure from bitstream or use default */
727
    if (!eac3 || get_bits1(gbc)) {
728
        for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
729 3f937168 Justin Ruggles
            coded_band_struct[subbnd] = get_bits1(gbc);
730 0c5d750d Justin Ruggles
        }
731 3f937168 Justin Ruggles
        band_struct = coded_band_struct;
732 0c5d750d Justin Ruggles
    } else if (!blk) {
733 3f937168 Justin Ruggles
        band_struct = &default_band_struct[start_subband+1];
734
    } else {
735
        /* no change in band structure */
736
        return;
737 0c5d750d Justin Ruggles
    }
738
739
    /* calculate number of bands and band sizes based on band structure.
740
       note that the first 4 subbands in enhanced coupling span only 6 bins
741
       instead of 12. */
742
    if (num_bands || band_sizes ) {
743 e202cc25 Justin Ruggles
        n_bands = n_subbands;
744 0c5d750d Justin Ruggles
        bnd_sz[0] = ecpl ? 6 : 12;
745
        for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
746
            int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
747
            if (band_struct[subbnd-1]) {
748
                n_bands--;
749
                bnd_sz[bnd] += subbnd_size;
750
            } else {
751
                bnd_sz[++bnd] = subbnd_size;
752
            }
753
        }
754
    }
755
756
    /* set optional output params */
757
    if (num_bands)
758
        *num_bands = n_bands;
759
    if (band_sizes)
760 75b53b21 Justin Ruggles
        memcpy(band_sizes, bnd_sz, n_bands);
761 0c5d750d Justin Ruggles
}
762
763
/**
764 022845ed Justin Ruggles
 * Decode a single audio block from the AC-3 bitstream.
765 c7cfc48f Justin Ruggles
 */
766 022845ed Justin Ruggles
static int decode_audio_block(AC3DecodeContext *s, int blk)
767 2aa2c5c4 Justin Ruggles
{
768 d802d7ca Justin Ruggles
    int fbw_channels = s->fbw_channels;
769
    int channel_mode = s->channel_mode;
770 0bff58a5 Justin Ruggles
    int i, bnd, seg, ch;
771 38dae9c3 Justin Ruggles
    int different_transforms;
772
    int downmix_output;
773 54624396 Justin Ruggles
    int cpl_in_use;
774 d802d7ca Justin Ruggles
    GetBitContext *gbc = &s->gbc;
775 7b4076a7 Justin Ruggles
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
776 1b293437 Justin Ruggles
777 7b4076a7 Justin Ruggles
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
778
779 5066f515 Justin Ruggles
    /* block switch flags */
780 38dae9c3 Justin Ruggles
    different_transforms = 0;
781 bf09b550 Justin Ruggles
    if (s->block_switch_syntax) {
782 ab2a942a Justin Ruggles
        for (ch = 1; ch <= fbw_channels; ch++) {
783
            s->block_switch[ch] = get_bits1(gbc);
784
            if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
785
                different_transforms = 1;
786
        }
787 bf09b550 Justin Ruggles
    }
788 98a27a8a Justin Ruggles
789 5066f515 Justin Ruggles
    /* dithering flags */
790 bf09b550 Justin Ruggles
    if (s->dither_flag_syntax) {
791 ab2a942a Justin Ruggles
        for (ch = 1; ch <= fbw_channels; ch++) {
792
            s->dither_flag[ch] = get_bits1(gbc);
793
        }
794 bf09b550 Justin Ruggles
    }
795 98a27a8a Justin Ruggles
796 77416325 Justin Ruggles
    /* dynamic range */
797 d802d7ca Justin Ruggles
    i = !(s->channel_mode);
798 77416325 Justin Ruggles
    do {
799 23c8cb89 Justin Ruggles
        if(get_bits1(gbc)) {
800 d802d7ca Justin Ruggles
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
801 1b70d88b Justin Ruggles
                                  s->avctx->drc_scale)+1.0;
802 9fc1ab72 Justin Ruggles
        } else if(blk == 0) {
803 d802d7ca Justin Ruggles
            s->dynamic_range[i] = 1.0f;
804 9fc1ab72 Justin Ruggles
        }
805 77416325 Justin Ruggles
    } while(i--);
806 98a27a8a Justin Ruggles
807 6fafb020 Justin Ruggles
    /* spectral extension strategy */
808
    if (s->eac3 && (!blk || get_bits1(gbc))) {
809 ca6e7708 Carl Eugen Hoyos
        s->spx_in_use = get_bits1(gbc);
810
        if (s->spx_in_use) {
811
            int dst_start_freq, dst_end_freq, src_start_freq,
812
                start_subband, end_subband;
813
814
            /* determine which channels use spx */
815
            if (s->channel_mode == AC3_CHMODE_MONO) {
816
                s->channel_uses_spx[1] = 1;
817
            } else {
818
                for (ch = 1; ch <= fbw_channels; ch++)
819
                    s->channel_uses_spx[ch] = get_bits1(gbc);
820
            }
821
822
            /* get the frequency bins of the spx copy region and the spx start
823
               and end subbands */
824
            dst_start_freq = get_bits(gbc, 2);
825
            start_subband  = get_bits(gbc, 3) + 2;
826
            if (start_subband > 7)
827
                start_subband += start_subband - 7;
828
            end_subband    = get_bits(gbc, 3) + 5;
829
            if (end_subband   > 7)
830
                end_subband   += end_subband   - 7;
831
            dst_start_freq = dst_start_freq * 12 + 25;
832
            src_start_freq = start_subband  * 12 + 25;
833
            dst_end_freq   = end_subband    * 12 + 25;
834
835
            /* check validity of spx ranges */
836
            if (start_subband >= end_subband) {
837
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
838
                       "range (%d >= %d)\n", start_subband, end_subband);
839
                return -1;
840
            }
841
            if (dst_start_freq >= src_start_freq) {
842
                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
843
                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
844
                return -1;
845
            }
846
847
            s->spx_dst_start_freq = dst_start_freq;
848
            s->spx_src_start_freq = src_start_freq;
849
            s->spx_dst_end_freq   = dst_end_freq;
850
851
            decode_band_structure(gbc, blk, s->eac3, 0,
852
                                  start_subband, end_subband,
853
                                  ff_eac3_default_spx_band_struct,
854
                                  &s->num_spx_bands,
855
                                  s->spx_band_sizes);
856
        } else {
857
            for (ch = 1; ch <= fbw_channels; ch++) {
858
                s->channel_uses_spx[ch] = 0;
859
                s->first_spx_coords[ch] = 1;
860
            }
861 6fafb020 Justin Ruggles
        }
862
    }
863
864 ca6e7708 Carl Eugen Hoyos
    /* spectral extension coordinates */
865
    if (s->spx_in_use) {
866
        for (ch = 1; ch <= fbw_channels; ch++) {
867
            if (s->channel_uses_spx[ch]) {
868
                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
869
                    float spx_blend;
870
                    int bin, master_spx_coord;
871
872
                    s->first_spx_coords[ch] = 0;
873
                    spx_blend = get_bits(gbc, 5) * (1.0f/32);
874
                    master_spx_coord = get_bits(gbc, 2) * 3;
875
876
                    bin = s->spx_src_start_freq;
877
                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
878
                        int bandsize;
879
                        int spx_coord_exp, spx_coord_mant;
880
                        float nratio, sblend, nblend, spx_coord;
881
882
                        /* calculate blending factors */
883
                        bandsize = s->spx_band_sizes[bnd];
884
                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
885
                        nratio = av_clipf(nratio, 0.0f, 1.0f);
886
                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance
887
                        sblend = sqrtf(1.0f - nratio);
888
                        bin += bandsize;
889
890
                        /* decode spx coordinates */
891
                        spx_coord_exp  = get_bits(gbc, 4);
892
                        spx_coord_mant = get_bits(gbc, 2);
893
                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
894
                        else                     spx_coord_mant += 4;
895
                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
896
                        spx_coord = spx_coord_mant * (1.0f/(1<<23));
897
898
                        /* multiply noise and signal blending factors by spx coordinate */
899
                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
900
                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
901
                    }
902
                }
903
            } else {
904
                s->first_spx_coords[ch] = 1;
905
            }
906
        }
907
    }
908 6fafb020 Justin Ruggles
909 5066f515 Justin Ruggles
    /* coupling strategy */
910 225c3042 Justin Ruggles
    if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
911 7b4076a7 Justin Ruggles
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
912 6fafb020 Justin Ruggles
        if (!s->eac3)
913 0569993e Justin Ruggles
            s->cpl_in_use[blk] = get_bits1(gbc);
914 4760aec6 Justin Ruggles
        if (s->cpl_in_use[blk]) {
915 5066f515 Justin Ruggles
            /* coupling in use */
916 24834c19 Justin Ruggles
            int cpl_start_subband, cpl_end_subband;
917 b6acc57f Justin Ruggles
918 3af91313 Justin Ruggles
            if (channel_mode < AC3_CHMODE_STEREO) {
919
                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
920
                return -1;
921
            }
922
923 6fafb020 Justin Ruggles
            /* check for enhanced coupling */
924
            if (s->eac3 && get_bits1(gbc)) {
925
                /* TODO: parse enhanced coupling strategy info */
926 ce863d7f Ronald S. Bultje
                av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
927 6fafb020 Justin Ruggles
                return -1;
928
            }
929
930 5066f515 Justin Ruggles
            /* determine which channels are coupled */
931 6fafb020 Justin Ruggles
            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
932
                s->channel_in_cpl[1] = 1;
933
                s->channel_in_cpl[2] = 1;
934
            } else {
935 0569993e Justin Ruggles
                for (ch = 1; ch <= fbw_channels; ch++)
936
                    s->channel_in_cpl[ch] = get_bits1(gbc);
937 6fafb020 Justin Ruggles
            }
938 98a27a8a Justin Ruggles
939 5066f515 Justin Ruggles
            /* phase flags in use */
940 e59cc205 Justin Ruggles
            if (channel_mode == AC3_CHMODE_STEREO)
941 d802d7ca Justin Ruggles
                s->phase_flags_in_use = get_bits1(gbc);
942 98a27a8a Justin Ruggles
943 6fafb020 Justin Ruggles
            /* coupling frequency range */
944 24834c19 Justin Ruggles
            cpl_start_subband = get_bits(gbc, 4);
945 ca6e7708 Carl Eugen Hoyos
            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
946
                                              get_bits(gbc, 4) + 3;
947 1ac7d1ac Justin Ruggles
            if (cpl_start_subband >= cpl_end_subband) {
948
                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
949 6ee6d068 Justin Ruggles
                       cpl_start_subband, cpl_end_subband);
950 00585845 Justin Ruggles
                return -1;
951 98a27a8a Justin Ruggles
            }
952 24834c19 Justin Ruggles
            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
953 6ee6d068 Justin Ruggles
            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
954 6fafb020 Justin Ruggles
955 778bc09b Justin Ruggles
            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
956
                                  cpl_end_subband,
957
                                  ff_eac3_default_cpl_band_struct,
958 c36ea060 Justin Ruggles
                                  &s->num_cpl_bands, s->cpl_band_sizes);
959 878c40a1 Justin Ruggles
        } else {
960 5066f515 Justin Ruggles
            /* coupling not in use */
961 6fafb020 Justin Ruggles
            for (ch = 1; ch <= fbw_channels; ch++) {
962 d802d7ca Justin Ruggles
                s->channel_in_cpl[ch] = 0;
963 6fafb020 Justin Ruggles
                s->first_cpl_coords[ch] = 1;
964
            }
965 63d72fb1 Justin Ruggles
            s->first_cpl_leak = s->eac3;
966 6fafb020 Justin Ruggles
            s->phase_flags_in_use = 0;
967 1b293437 Justin Ruggles
        }
968 6fafb020 Justin Ruggles
    } else if (!s->eac3) {
969
        if(!blk) {
970 0569993e Justin Ruggles
            av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
971
            return -1;
972
        } else {
973
            s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
974
        }
975 6fafb020 Justin Ruggles
    }
976 4760aec6 Justin Ruggles
    cpl_in_use = s->cpl_in_use[blk];
977 98a27a8a Justin Ruggles
978 5066f515 Justin Ruggles
    /* coupling coordinates */
979 54624396 Justin Ruggles
    if (cpl_in_use) {
980 e2270b4e Justin Ruggles
        int cpl_coords_exist = 0;
981 98a27a8a Justin Ruggles
982 e2270b4e Justin Ruggles
        for (ch = 1; ch <= fbw_channels; ch++) {
983 d802d7ca Justin Ruggles
            if (s->channel_in_cpl[ch]) {
984 225c3042 Justin Ruggles
                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
985 e2270b4e Justin Ruggles
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
986 225c3042 Justin Ruggles
                    s->first_cpl_coords[ch] = 0;
987 e2270b4e Justin Ruggles
                    cpl_coords_exist = 1;
988 23c8cb89 Justin Ruggles
                    master_cpl_coord = 3 * get_bits(gbc, 2);
989 d802d7ca Justin Ruggles
                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
990 23c8cb89 Justin Ruggles
                        cpl_coord_exp = get_bits(gbc, 4);
991
                        cpl_coord_mant = get_bits(gbc, 4);
992 e2270b4e Justin Ruggles
                        if (cpl_coord_exp == 15)
993 a4de6dd2 Justin Ruggles
                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
994 486637af Justin Ruggles
                        else
995 a4de6dd2 Justin Ruggles
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
996
                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
997 486637af Justin Ruggles
                    }
998 82a591d8 Justin Ruggles
                } else if (!blk) {
999
                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
1000
                    return -1;
1001 486637af Justin Ruggles
                }
1002 225c3042 Justin Ruggles
            } else {
1003
                /* channel not in coupling */
1004
                s->first_cpl_coords[ch] = 1;
1005 eaf84d97 Justin Ruggles
            }
1006
        }
1007 5066f515 Justin Ruggles
        /* phase flags */
1008 b02fbf75 Justin Ruggles
        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
1009 d802d7ca Justin Ruggles
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1010 b02fbf75 Justin Ruggles
                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
1011 eaf84d97 Justin Ruggles
            }
1012
        }
1013 2aa2c5c4 Justin Ruggles
    }
1014 98a27a8a Justin Ruggles
1015 5066f515 Justin Ruggles
    /* stereo rematrixing strategy and band structure */
1016 e59cc205 Justin Ruggles
    if (channel_mode == AC3_CHMODE_STEREO) {
1017 6fafb020 Justin Ruggles
        if ((s->eac3 && !blk) || get_bits1(gbc)) {
1018 d802d7ca Justin Ruggles
            s->num_rematrixing_bands = 4;
1019 ca6e7708 Carl Eugen Hoyos
            if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1020 e202cc25 Justin Ruggles
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1021 ca6e7708 Carl Eugen Hoyos
            } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1022
                s->num_rematrixing_bands--;
1023
            }
1024 d802d7ca Justin Ruggles
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
1025
                s->rematrixing_flags[bnd] = get_bits1(gbc);
1026 82a591d8 Justin Ruggles
        } else if (!blk) {
1027 535497f1 Justin Ruggles
            av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
1028
            s->num_rematrixing_bands = 0;
1029 1b293437 Justin Ruggles
        }
1030 98a27a8a Justin Ruggles
    }
1031
1032 5066f515 Justin Ruggles
    /* exponent strategies for each channel */
1033 54624396 Justin Ruggles
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1034 6b4bfed9 Justin Ruggles
        if (!s->eac3)
1035 aec0407f Justin Ruggles
            s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1036 da04be10 Justin Ruggles
        if(s->exp_strategy[blk][ch] != EXP_REUSE)
1037 7b4076a7 Justin Ruggles
            bit_alloc_stages[ch] = 3;
1038
    }
1039
1040 5066f515 Justin Ruggles
    /* channel bandwidth */
1041 e2270b4e Justin Ruggles
    for (ch = 1; ch <= fbw_channels; ch++) {
1042 d802d7ca Justin Ruggles
        s->start_freq[ch] = 0;
1043 da04be10 Justin Ruggles
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1044 b85a15fe Justin Ruggles
            int group_size;
1045 d802d7ca Justin Ruggles
            int prev = s->end_freq[ch];
1046
            if (s->channel_in_cpl[ch])
1047
                s->end_freq[ch] = s->start_freq[CPL_CH];
1048 ca6e7708 Carl Eugen Hoyos
            else if (s->channel_uses_spx[ch])
1049
                s->end_freq[ch] = s->spx_src_start_freq;
1050 00585845 Justin Ruggles
            else {
1051 23c8cb89 Justin Ruggles
                int bandwidth_code = get_bits(gbc, 6);
1052 e2270b4e Justin Ruggles
                if (bandwidth_code > 60) {
1053 6c6f9272 Justin Ruggles
                    av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1054 00585845 Justin Ruggles
                    return -1;
1055
                }
1056 d802d7ca Justin Ruggles
                s->end_freq[ch] = bandwidth_code * 3 + 73;
1057 1b293437 Justin Ruggles
            }
1058 da04be10 Justin Ruggles
            group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1059 b85a15fe Justin Ruggles
            s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
1060 d802d7ca Justin Ruggles
            if(blk > 0 && s->end_freq[ch] != prev)
1061 7b4076a7 Justin Ruggles
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1062 00585845 Justin Ruggles
        }
1063 eaf84d97 Justin Ruggles
    }
1064 da04be10 Justin Ruggles
    if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1065 b85a15fe Justin Ruggles
        s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1066 da04be10 Justin Ruggles
                                    (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1067 b85a15fe Justin Ruggles
    }
1068 7b4076a7 Justin Ruggles
1069 5066f515 Justin Ruggles
    /* decode exponents for each channel */
1070 54624396 Justin Ruggles
    for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1071 da04be10 Justin Ruggles
        if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1072 d802d7ca Justin Ruggles
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1073 ce7d842f Justin Ruggles
            if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1074 1cdd567f Justin Ruggles
                                 s->num_exp_groups[ch], s->dexps[ch][0],
1075
                                 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1076 ce7d842f Justin Ruggles
                av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1077
                return -1;
1078
            }
1079 d802d7ca Justin Ruggles
            if(ch != CPL_CH && ch != s->lfe_ch)
1080 23c8cb89 Justin Ruggles
                skip_bits(gbc, 2); /* skip gainrng */
1081 1b293437 Justin Ruggles
        }
1082 eaf84d97 Justin Ruggles
    }
1083 98a27a8a Justin Ruggles
1084 5066f515 Justin Ruggles
    /* bit allocation information */
1085 bf09b550 Justin Ruggles
    if (s->bit_allocation_syntax) {
1086 ab2a942a Justin Ruggles
        if (get_bits1(gbc)) {
1087
            s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1088
            s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1089
            s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1090
            s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1091 e202cc25 Justin Ruggles
            s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1092 ab2a942a Justin Ruggles
            for(ch=!cpl_in_use; ch<=s->channels; ch++)
1093
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1094
        } else if (!blk) {
1095
            av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
1096
            return -1;
1097
        }
1098 bf09b550 Justin Ruggles
    }
1099 98a27a8a Justin Ruggles
1100 5066f515 Justin Ruggles
    /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1101 8dfc56ec Justin Ruggles
    if(!s->eac3 || !blk){
1102
        if(s->snr_offset_strategy && get_bits1(gbc)) {
1103 f2e4eb62 Justin Ruggles
            int snr = 0;
1104
            int csnr;
1105
            csnr = (get_bits(gbc, 6) - 15) << 4;
1106
            for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1107
                /* snr offset */
1108
                if (ch == i || s->snr_offset_strategy == 2)
1109
                    snr = (csnr + get_bits(gbc, 4)) << 2;
1110
                /* run at least last bit allocation stage if snr offset changes */
1111
                if(blk && s->snr_offset[ch] != snr) {
1112
                    bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1113
                }
1114
                s->snr_offset[ch] = snr;
1115 8dfc56ec Justin Ruggles
1116
                /* fast gain (normal AC-3 only) */
1117
                if (!s->eac3) {
1118
                    int prev = s->fast_gain[ch];
1119 f2e4eb62 Justin Ruggles
                    s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1120 8dfc56ec Justin Ruggles
                    /* run last 2 bit allocation stages if fast gain changes */
1121
                    if(blk && prev != s->fast_gain[ch])
1122
                        bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1123
                }
1124 f2e4eb62 Justin Ruggles
            }
1125 8dfc56ec Justin Ruggles
        } else if (!s->eac3 && !blk) {
1126 f2e4eb62 Justin Ruggles
            av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1127
            return -1;
1128 8dfc56ec Justin Ruggles
        }
1129 1b293437 Justin Ruggles
    }
1130 98a27a8a Justin Ruggles
1131 6fafb020 Justin Ruggles
    /* fast gain (E-AC-3 only) */
1132
    if (s->fast_gain_syntax && get_bits1(gbc)) {
1133
        for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1134
            int prev = s->fast_gain[ch];
1135
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1136
            /* run last 2 bit allocation stages if fast gain changes */
1137
            if(blk && prev != s->fast_gain[ch])
1138
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1139
        }
1140
    } else if (s->eac3 && !blk) {
1141
        for (ch = !cpl_in_use; ch <= s->channels; ch++)
1142
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1143
    }
1144
1145
    /* E-AC-3 to AC-3 converter SNR offset */
1146
    if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1147
        skip_bits(gbc, 10); // skip converter snr offset
1148
    }
1149
1150 5066f515 Justin Ruggles
    /* coupling leak information */
1151 54624396 Justin Ruggles
    if (cpl_in_use) {
1152 8dfc56ec Justin Ruggles
        if (s->first_cpl_leak || get_bits1(gbc)) {
1153
            int fl = get_bits(gbc, 3);
1154
            int sl = get_bits(gbc, 3);
1155
            /* run last 2 bit allocation stages for coupling channel if
1156
               coupling leak changes */
1157
            if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1158
                       sl != s->bit_alloc_params.cpl_slow_leak)) {
1159 f2e4eb62 Justin Ruggles
                bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1160 8dfc56ec Justin Ruggles
            }
1161
            s->bit_alloc_params.cpl_fast_leak = fl;
1162
            s->bit_alloc_params.cpl_slow_leak = sl;
1163
        } else if (!s->eac3 && !blk) {
1164 93a2c8c1 Justin Ruggles
            av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
1165
            return -1;
1166
        }
1167 8dfc56ec Justin Ruggles
        s->first_cpl_leak = 0;
1168 43ad93a4 Justin Ruggles
    }
1169 98a27a8a Justin Ruggles
1170 5066f515 Justin Ruggles
    /* delta bit allocation information */
1171 bf09b550 Justin Ruggles
    if (s->dba_syntax && get_bits1(gbc)) {
1172 5066f515 Justin Ruggles
        /* delta bit allocation exists (strategy) */
1173 54624396 Justin Ruggles
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1174 d802d7ca Justin Ruggles
            s->dba_mode[ch] = get_bits(gbc, 2);
1175
            if (s->dba_mode[ch] == DBA_RESERVED) {
1176
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1177 1b293437 Justin Ruggles
                return -1;
1178
            }
1179 7b4076a7 Justin Ruggles
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1180 1b293437 Justin Ruggles
        }
1181 5066f515 Justin Ruggles
        /* channel delta offset, len and bit allocation */
1182 54624396 Justin Ruggles
        for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1183 d802d7ca Justin Ruggles
            if (s->dba_mode[ch] == DBA_NEW) {
1184
                s->dba_nsegs[ch] = get_bits(gbc, 3);
1185
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1186
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1187
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1188
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
1189 1b293437 Justin Ruggles
                }
1190 e25973a1 Justin Ruggles
                /* run last 2 bit allocation stages if new dba values */
1191
                bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1192 1b293437 Justin Ruggles
            }
1193 eaf84d97 Justin Ruggles
        }
1194 9fc1ab72 Justin Ruggles
    } else if(blk == 0) {
1195 d802d7ca Justin Ruggles
        for(ch=0; ch<=s->channels; ch++) {
1196
            s->dba_mode[ch] = DBA_NONE;
1197 9fc1ab72 Justin Ruggles
        }
1198 1b293437 Justin Ruggles
    }
1199 00585845 Justin Ruggles
1200 5066f515 Justin Ruggles
    /* Bit allocation */
1201 54624396 Justin Ruggles
    for(ch=!cpl_in_use; ch<=s->channels; ch++) {
1202 7b4076a7 Justin Ruggles
        if(bit_alloc_stages[ch] > 2) {
1203
            /* Exponent mapping into PSD and PSD integration */
1204 d802d7ca Justin Ruggles
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1205
                                      s->start_freq[ch], s->end_freq[ch],
1206
                                      s->psd[ch], s->band_psd[ch]);
1207 eaf84d97 Justin Ruggles
        }
1208 7b4076a7 Justin Ruggles
        if(bit_alloc_stages[ch] > 1) {
1209
            /* Compute excitation function, Compute masking curve, and
1210
               Apply delta bit allocation */
1211 72a6244b Justin Ruggles
            if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1212 20e04726 Justin Ruggles
                                           s->start_freq[ch], s->end_freq[ch],
1213
                                           s->fast_gain[ch], (ch == s->lfe_ch),
1214
                                           s->dba_mode[ch], s->dba_nsegs[ch],
1215
                                           s->dba_offsets[ch], s->dba_lengths[ch],
1216
                                           s->dba_values[ch], s->mask[ch])) {
1217 72a6244b Justin Ruggles
                av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1218
                return -1;
1219
            }
1220 eaf84d97 Justin Ruggles
        }
1221 7b4076a7 Justin Ruggles
        if(bit_alloc_stages[ch] > 0) {
1222
            /* Compute bit allocation */
1223 bf09b550 Justin Ruggles
            const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1224
                                     ff_eac3_hebap_tab : ff_ac3_bap_tab;
1225 d802d7ca Justin Ruggles
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1226
                                      s->start_freq[ch], s->end_freq[ch],
1227
                                      s->snr_offset[ch],
1228
                                      s->bit_alloc_params.floor,
1229 bf09b550 Justin Ruggles
                                      bap_tab, s->bap[ch]);
1230 eaf84d97 Justin Ruggles
        }
1231 2fbbd087 Justin Ruggles
    }
1232 98a27a8a Justin Ruggles
1233 5066f515 Justin Ruggles
    /* unused dummy data */
1234 bf09b550 Justin Ruggles
    if (s->skip_syntax && get_bits1(gbc)) {
1235 23c8cb89 Justin Ruggles
        int skipl = get_bits(gbc, 9);
1236 98a27a8a Justin Ruggles
        while(skipl--)
1237 23c8cb89 Justin Ruggles
            skip_bits(gbc, 8);
1238 1b293437 Justin Ruggles
    }
1239 f5cefb21 Justin Ruggles
1240 1b293437 Justin Ruggles
    /* unpack the transform coefficients
1241 5066f515 Justin Ruggles
       this also uncouples channels if coupling is in use. */
1242 e43b29ab Justin Ruggles
    decode_transform_coeffs(s, blk);
1243 486637af Justin Ruggles
1244 bf09b550 Justin Ruggles
    /* TODO: generate enhanced coupling coordinates and uncouple */
1245
1246 1b293437 Justin Ruggles
    /* recover coefficients if rematrixing is in use */
1247 d802d7ca Justin Ruggles
    if(s->channel_mode == AC3_CHMODE_STEREO)
1248
        do_rematrixing(s);
1249 1b293437 Justin Ruggles
1250 03726b70 Justin Ruggles
    /* apply scaling to coefficients (headroom, dynrng) */
1251 d802d7ca Justin Ruggles
    for(ch=1; ch<=s->channels; ch++) {
1252 a4de6dd2 Justin Ruggles
        float gain = s->mul_bias / 4194304.0f;
1253 d802d7ca Justin Ruggles
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1254 7934cbb3 Justin Ruggles
            gain *= s->dynamic_range[2-ch];
1255 7bfd22f2 Justin Ruggles
        } else {
1256 d802d7ca Justin Ruggles
            gain *= s->dynamic_range[0];
1257 7bfd22f2 Justin Ruggles
        }
1258 911e21a3 Loren Merritt
        s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1259 7bfd22f2 Justin Ruggles
    }
1260 d7bcc4ad Justin Ruggles
1261 ca6e7708 Carl Eugen Hoyos
    /* apply spectral extension to high frequency bins */
1262 eb0a4d32 Carl Eugen Hoyos
    if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1263 ca6e7708 Carl Eugen Hoyos
        ff_eac3_apply_spectral_extension(s);
1264
    }
1265
1266 38dae9c3 Justin Ruggles
    /* downmix and MDCT. order depends on whether block switching is used for
1267
       any channel in this block. this is because coefficients for the long
1268
       and short transforms cannot be mixed. */
1269
    downmix_output = s->channels != s->out_channels &&
1270
                     !((s->output_mode & AC3_OUTPUT_LFEON) &&
1271
                     s->fbw_channels == s->out_channels);
1272
    if(different_transforms) {
1273
        /* the delay samples have already been downmixed, so we upmix the delay
1274
           samples in order to reconstruct all channels before downmixing. */
1275
        if(s->downmixed) {
1276
            s->downmixed = 0;
1277
            ac3_upmix_delay(s);
1278
        }
1279
1280
        do_imdct(s, s->channels);
1281
1282
        if(downmix_output) {
1283 ac2e5564 Loren Merritt
            s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1284 38dae9c3 Justin Ruggles
        }
1285
    } else {
1286
        if(downmix_output) {
1287 ac2e5564 Loren Merritt
            s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1288 38dae9c3 Justin Ruggles
        }
1289
1290 45d9d618 Loren Merritt
        if(downmix_output && !s->downmixed) {
1291 38dae9c3 Justin Ruggles
            s->downmixed = 1;
1292 ac2e5564 Loren Merritt
            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1293 38dae9c3 Justin Ruggles
        }
1294 486637af Justin Ruggles
1295 38dae9c3 Justin Ruggles
        do_imdct(s, s->out_channels);
1296 3bbb0bf8 Justin Ruggles
    }
1297
1298 4e092320 Justin Ruggles
    return 0;
1299 486637af Justin Ruggles
}
1300
1301 5066f515 Justin Ruggles
/**
1302
 * Decode a single AC-3 frame.
1303 c7cfc48f Justin Ruggles
 */
1304 98f6dfa6 Justin Ruggles
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1305 7a00bbad Thilo Borgmann
                            AVPacket *avpkt)
1306 1b293437 Justin Ruggles
{
1307 7a00bbad Thilo Borgmann
    const uint8_t *buf = avpkt->data;
1308
    int buf_size = avpkt->size;
1309 0345fade Justin Ruggles
    AC3DecodeContext *s = avctx->priv_data;
1310 00585845 Justin Ruggles
    int16_t *out_samples = (int16_t *)data;
1311 72745cff Loren Merritt
    int blk, ch, err;
1312 95f3019a Justin Ruggles
    const uint8_t *channel_map;
1313 13ec9428 Justin Ruggles
    const float *output[AC3_MAX_CHANNELS];
1314 d7bcc4ad Justin Ruggles
1315 5066f515 Justin Ruggles
    /* initialize the GetBitContext with the start of valid AC-3 Frame */
1316 509fdb0b Justin Ruggles
    if (s->input_buffer) {
1317 c33a1967 Justin Ruggles
        /* copy input buffer to decoder context to avoid reading past the end
1318
           of the buffer, which can be caused by a damaged input stream. */
1319 8e33132b Justin Ruggles
        memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1320 c33a1967 Justin Ruggles
        init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1321
    } else {
1322 984ff38a Justin Ruggles
        init_get_bits(&s->gbc, buf, buf_size * 8);
1323 c33a1967 Justin Ruggles
    }
1324 00585845 Justin Ruggles
1325 5066f515 Justin Ruggles
    /* parse the syncinfo */
1326 c78c6d6c Justin Ruggles
    *data_size = 0;
1327 4397d95c Justin Ruggles
    err = parse_frame_header(s);
1328 c78c6d6c Justin Ruggles
1329 2c2cdc0b Justin Ruggles
    if (err) {
1330 3df88093 Justin Ruggles
        switch(err) {
1331 11d6f38c Alex Converse
            case AAC_AC3_PARSE_ERROR_SYNC:
1332 c78c6d6c Justin Ruggles
                av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1333 7af26d14 Justin Ruggles
                return -1;
1334 11d6f38c Alex Converse
            case AAC_AC3_PARSE_ERROR_BSID:
1335 3df88093 Justin Ruggles
                av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1336
                break;
1337 11d6f38c Alex Converse
            case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1338 3df88093 Justin Ruggles
                av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1339
                break;
1340 11d6f38c Alex Converse
            case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1341 3df88093 Justin Ruggles
                av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1342
                break;
1343 11d6f38c Alex Converse
            case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1344 aa5d6be8 Justin Ruggles
                /* skip frame if CRC is ok. otherwise use error concealment. */
1345
                /* TODO: add support for substreams and dependent frames */
1346
                if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1347
                    av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1348
                    return s->frame_size;
1349
                } else {
1350 4921bbba Justin Ruggles
                    av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1351 aa5d6be8 Justin Ruggles
                }
1352 4e6eeaf0 Bartlomiej Wolowiec
                break;
1353 3df88093 Justin Ruggles
            default:
1354
                av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1355
                break;
1356
        }
1357 2c2cdc0b Justin Ruggles
    } else {
1358
        /* check that reported frame size fits in input buffer */
1359
        if (s->frame_size > buf_size) {
1360
            av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1361
            err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1362
        } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
1363
            /* check for crc mismatch */
1364
            if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1365
                av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1366
                err = AAC_AC3_PARSE_ERROR_CRC;
1367
            }
1368
        }
1369 1b293437 Justin Ruggles
    }
1370 2aa2c5c4 Justin Ruggles
1371 eccba2bc Justin Ruggles
    /* if frame is ok, set audio parameters */
1372
    if (!err) {
1373 3336110a Justin Ruggles
        avctx->sample_rate = s->sample_rate;
1374
        avctx->bit_rate = s->bit_rate;
1375
1376
        /* channel config */
1377
        s->out_channels = s->channels;
1378 eccba2bc Justin Ruggles
        s->output_mode = s->channel_mode;
1379
        if(s->lfe_on)
1380
            s->output_mode |= AC3_OUTPUT_LFEON;
1381 3336110a Justin Ruggles
        if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1382
                avctx->request_channels < s->channels) {
1383
            s->out_channels = avctx->request_channels;
1384
            s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1385 bfeca7be Justin Ruggles
            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
1386 3336110a Justin Ruggles
        }
1387
        avctx->channels = s->out_channels;
1388 bfeca7be Justin Ruggles
        avctx->channel_layout = s->channel_layout;
1389 1b293437 Justin Ruggles
1390 3336110a Justin Ruggles
        /* set downmixing coefficients if needed */
1391
        if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1392
                s->fbw_channels == s->out_channels)) {
1393
            set_downmix_coeffs(s);
1394
        }
1395 eccba2bc Justin Ruggles
    } else if (!s->out_channels) {
1396
        s->out_channels = avctx->channels;
1397
        if(s->out_channels < s->channels)
1398
            s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1399 ecfe94b2 Justin Ruggles
    }
1400 f0b3a7ba Justin Ruggles
1401 022845ed Justin Ruggles
    /* decode the audio blocks */
1402 95f3019a Justin Ruggles
    channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1403 52dc3fc8 Justin Ruggles
    for (ch = 0; ch < s->out_channels; ch++)
1404
        output[ch] = s->output[channel_map[ch]];
1405 6730e9f3 Justin Ruggles
    for (blk = 0; blk < s->num_blocks; blk++) {
1406 022845ed Justin Ruggles
        if (!err && decode_audio_block(s, blk)) {
1407
            av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1408 af2272b2 Justin Ruggles
            err = 1;
1409 1b293437 Justin Ruggles
        }
1410 72745cff Loren Merritt
        s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1411
        out_samples += 256 * s->out_channels;
1412 1b293437 Justin Ruggles
    }
1413 6730e9f3 Justin Ruggles
    *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1414 cc8538ff Justin Ruggles
    return FFMIN(buf_size, s->frame_size);
1415 2aa2c5c4 Justin Ruggles
}
1416 1b293437 Justin Ruggles
1417 5066f515 Justin Ruggles
/**
1418
 * Uninitialize the AC-3 decoder.
1419 c7cfc48f Justin Ruggles
 */
1420 98a6fff9 Zuxy Meng
static av_cold int ac3_decode_end(AVCodecContext *avctx)
1421 1b293437 Justin Ruggles
{
1422 0345fade Justin Ruggles
    AC3DecodeContext *s = avctx->priv_data;
1423 d802d7ca Justin Ruggles
    ff_mdct_end(&s->imdct_512);
1424
    ff_mdct_end(&s->imdct_256);
1425 c7cfc48f Justin Ruggles
1426 509fdb0b Justin Ruggles
    av_freep(&s->input_buffer);
1427
1428 1b293437 Justin Ruggles
    return 0;
1429
}
1430
1431 d36beb3f Diego Elio Pettenò
AVCodec ff_ac3_decoder = {
1432 e6bca37c Justin Ruggles
    .name = "ac3",
1433 72415b2a Stefano Sabatini
    .type = AVMEDIA_TYPE_AUDIO,
1434 e6bca37c Justin Ruggles
    .id = CODEC_ID_AC3,
1435
    .priv_data_size = sizeof (AC3DecodeContext),
1436
    .init = ac3_decode_init,
1437
    .close = ac3_decode_end,
1438
    .decode = ac3_decode_frame,
1439 2988c93d Justin Ruggles
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1440
};
1441
1442 89547cfb Diego Biurrun
#if CONFIG_EAC3_DECODER
1443 d36beb3f Diego Elio Pettenò
AVCodec ff_eac3_decoder = {
1444 2988c93d Justin Ruggles
    .name = "eac3",
1445 72415b2a Stefano Sabatini
    .type = AVMEDIA_TYPE_AUDIO,
1446 2988c93d Justin Ruggles
    .id = CODEC_ID_EAC3,
1447
    .priv_data_size = sizeof (AC3DecodeContext),
1448
    .init = ac3_decode_init,
1449
    .close = ac3_decode_end,
1450
    .decode = ac3_decode_frame,
1451
    .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1452 1b293437 Justin Ruggles
};
1453 89547cfb Diego Biurrun
#endif