Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ be187388

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