pass bap table to ff_ac3_bit_alloc_calc_bap()
[libav.git] / libavcodec / ac3dec.c
CommitLineData
0ec2cc35
JR
1/*
2 * AC-3 Audio Decoder
032732d4
JR
3 * This code is developed as part of Google Summer of Code 2006 Program.
4 *
0ec2cc35 5 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
36266421 6 * Copyright (c) 2007 Justin Ruggles
032732d4 7 *
36266421 8 * Portions of this code are derived from liba52
032732d4 9 * http://liba52.sourceforge.net
36266421
JR
10 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
11 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
032732d4 12 *
0ec2cc35 13 * This file is part of FFmpeg.
2aa2c5c4 14 *
0ec2cc35 15 * FFmpeg is free software; you can redistribute it and/or
9d109601 16 * modify it under the terms of the GNU General Public
2aa2c5c4
JR
17 * License as published by the Free Software Foundation; either
18 * version 2 of the License, or (at your option) any later version.
19 *
0ec2cc35 20 * FFmpeg is distributed in the hope that it will be useful,
2aa2c5c4
JR
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
283614b5 23 * General Public License for more details.
2aa2c5c4 24 *
283614b5 25 * You should have received a copy of the GNU General Public
0ec2cc35 26 * License along with FFmpeg; if not, write to the Free Software
2aa2c5c4
JR
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 */
29
30#include <stdio.h>
31#include <stddef.h>
32#include <math.h>
2aa2c5c4
JR
33#include <string.h>
34
245976da
DB
35#include "libavutil/crc.h"
36#include "libavutil/random.h"
e6bca37c 37#include "avcodec.h"
9fc1ab72 38#include "ac3_parser.h"
2aa2c5c4
JR
39#include "bitstream.h"
40#include "dsputil.h"
98a27a8a 41
c33a1967
JR
42/** Maximum possible frame size when the specification limit is ignored */
43#define AC3_MAX_FRAME_SIZE 21695
44
8b60bbbf
JR
45/**
46 * Table of bin locations for rematrixing bands
47 * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions
48 */
bfcf690c 49static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 };
8b60bbbf 50
4415076f 51/** table for grouping exponents */
bfcf690c 52static uint8_t exp_ungroup_tab[128][3];
967d397a 53
967d397a 54
5aefe3eb 55/** tables for ungrouping mantissas */
a4de6dd2
JR
56static int b1_mantissas[32][3];
57static int b2_mantissas[128][3];
58static int b3_mantissas[8];
59static int b4_mantissas[128][2];
60static int b5_mantissas[16];
967d397a 61
5aefe3eb
JR
62/**
63 * Quantization table: levels for symmetric. bits for asymmetric.
64 * reference: Table 7.18 Mapping of bap to Quantizer
65 */
e2270b4e 66static const uint8_t quantization_tab[16] = {
5aefe3eb
JR
67 0, 3, 5, 7, 11, 15,
68 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
69};
967d397a 70
3357ff33 71/** dynamic range table. converts codes to scale factors. */
e2270b4e 72static float dynamic_range_tab[256];
3357ff33 73
5066f515 74/** Adjustments in dB gain */
967d397a
JR
75#define LEVEL_MINUS_3DB 0.7071067811865476
76#define LEVEL_MINUS_4POINT5DB 0.5946035575013605
77#define LEVEL_MINUS_6DB 0.5000000000000000
3bbb0bf8 78#define LEVEL_MINUS_9DB 0.3535533905932738
967d397a 79#define LEVEL_ZERO 0.0000000000000000
3bbb0bf8
JR
80#define LEVEL_ONE 1.0000000000000000
81
82static const float gain_levels[6] = {
83 LEVEL_ZERO,
84 LEVEL_ONE,
85 LEVEL_MINUS_3DB,
86 LEVEL_MINUS_4POINT5DB,
87 LEVEL_MINUS_6DB,
88 LEVEL_MINUS_9DB
89};
967d397a 90
3bbb0bf8 91/**
3bbb0bf8
JR
92 * Table for default stereo downmixing coefficients
93 * reference: Section 7.8.2 Downmixing Into Two Channels
94 */
95static const uint8_t ac3_default_coeffs[8][5][2] = {
96 { { 1, 0 }, { 0, 1 }, },
97 { { 2, 2 }, },
98 { { 1, 0 }, { 0, 1 }, },
99 { { 1, 0 }, { 3, 3 }, { 0, 1 }, },
100 { { 1, 0 }, { 0, 1 }, { 4, 4 }, },
101 { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 }, },
102 { { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },
103 { { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, },
104};
967d397a 105
7b4076a7
JR
106/* override ac3.h to include coupling channel */
107#undef AC3_MAX_CHANNELS
108#define AC3_MAX_CHANNELS 7
109#define CPL_CH 0
110
7bfd22f2 111#define AC3_OUTPUT_LFEON 8
1b293437 112
98a27a8a 113typedef struct {
6730e9f3 114 int num_blocks; ///< number of audio blocks
e59cc205 115 int channel_mode; ///< channel mode (acmod)
e2270b4e
JR
116 int block_switch[AC3_MAX_CHANNELS]; ///< block switch flags
117 int dither_flag[AC3_MAX_CHANNELS]; ///< dither flags
5066f515 118 int dither_all; ///< true if all channels are dithered
e2270b4e
JR
119 int cpl_in_use; ///< coupling in use
120 int channel_in_cpl[AC3_MAX_CHANNELS]; ///< channel in coupling
121 int phase_flags_in_use; ///< phase flags in use
b02fbf75 122 int phase_flags[18]; ///< phase flags
e2270b4e 123 int cpl_band_struct[18]; ///< coupling band structure
e2270b4e
JR
124 int num_rematrixing_bands; ///< number of rematrixing bands
125 int rematrixing_flags[4]; ///< rematrixing flags
126 int exp_strategy[AC3_MAX_CHANNELS]; ///< exponent strategies
5ce21342
JR
127 int snr_offset[AC3_MAX_CHANNELS]; ///< signal-to-noise ratio offsets
128 int fast_gain[AC3_MAX_CHANNELS]; ///< fast gain values (signal-to-mask ratio)
129 int dba_mode[AC3_MAX_CHANNELS]; ///< delta bit allocation mode
130 int dba_nsegs[AC3_MAX_CHANNELS]; ///< number of delta segments
131 uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets
132 uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths
133 uint8_t dba_values[AC3_MAX_CHANNELS][8]; ///< delta values for each segment
5066f515 134
866181e5 135 int sample_rate; ///< sample frequency, in Hz
5066f515 136 int bit_rate; ///< stream bit rate, in bits-per-second
be5f17b9 137 int frame_type; ///< frame type (strmtyp)
3596aa6f 138 int substreamid; ///< substream identification
5066f515
JR
139 int frame_size; ///< current frame size, in bytes
140
e2270b4e
JR
141 int channels; ///< number of total channels
142 int fbw_channels; ///< number of full-bandwidth channels
e59cc205 143 int lfe_on; ///< lfe channel in use
222ae64c
JR
144 int lfe_ch; ///< index of LFE channel
145 int output_mode; ///< output channel configuration
146 int out_channels; ///< number of output channels
c7cfc48f 147
f0b3a7ba
JR
148 int center_mix_level; ///< Center mix level index
149 int surround_mix_level; ///< Surround mix level index
222ae64c 150 float downmix_coeffs[AC3_MAX_CHANNELS][2]; ///< stereo downmix coefficients
d8870f12 151 float downmix_coeff_adjust[2]; ///< adjustment needed for each output channel when downmixing
e2270b4e 152 float dynamic_range[2]; ///< dynamic range
a4de6dd2 153 int cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates
e2270b4e
JR
154 int num_cpl_bands; ///< number of coupling bands
155 int num_cpl_subbands; ///< number of coupling sub bands
156 int start_freq[AC3_MAX_CHANNELS]; ///< start frequency bin
157 int end_freq[AC3_MAX_CHANNELS]; ///< end frequency bin
623b7943 158 AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters
c7cfc48f 159
b85a15fe 160 int num_exp_groups[AC3_MAX_CHANNELS]; ///< Number of exponent groups
222ae64c
JR
161 int8_t dexps[AC3_MAX_CHANNELS][256]; ///< decoded exponents
162 uint8_t bap[AC3_MAX_CHANNELS][256]; ///< bit allocation pointers
163 int16_t psd[AC3_MAX_CHANNELS][256]; ///< scaled exponents
5ce21342 164 int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents
222ae64c 165 int16_t mask[AC3_MAX_CHANNELS][50]; ///< masking curve values
c7cfc48f 166
a4de6dd2 167 int fixed_coeffs[AC3_MAX_CHANNELS][256]; ///> fixed-point transform coefficients
5066f515 168 DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); ///< transform coefficients
38dae9c3 169 int downmixed; ///< indicates if coeffs are currently downmixed
98a27a8a
JR
170
171 /* For IMDCT. */
5066f515
JR
172 MDCTContext imdct_512; ///< for 512 sample IMDCT
173 MDCTContext imdct_256; ///< for 256 sample IMDCT
174 DSPContext dsp; ///< for optimization
222ae64c
JR
175 float add_bias; ///< offset for float_to_int16 conversion
176 float mul_bias; ///< scaling for float_to_int16 conversion
c7cfc48f 177
38dae9c3 178 DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][256]); ///< output after imdct transform and windowing
4e092320 179 DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS-1][256]); ///< final 16-bit integer output
38dae9c3 180 DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][256]); ///< delay - added to the next block
5066f515
JR
181 DECLARE_ALIGNED_16(float, tmp_imdct[256]); ///< temporary storage for imdct transform
182 DECLARE_ALIGNED_16(float, tmp_output[512]); ///< temporary storage for output before windowing
183 DECLARE_ALIGNED_16(float, window[256]); ///< window coefficients
98a27a8a
JR
184
185 /* Miscellaneous. */
23c8cb89 186 GetBitContext gbc; ///< bitstream reader
5066f515 187 AVRandomState dith_state; ///< for dither generation
222ae64c 188 AVCodecContext *avctx; ///< parent context
509fdb0b 189 uint8_t *input_buffer; ///< temp buffer to prevent overread
98a27a8a
JR
190} AC3DecodeContext;
191
2fbbd087 192/**
5066f515
JR
193 * Symmetrical Dequantization
194 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
195 * Tables 7.19 to 7.23
196 */
a4de6dd2 197static inline int
5aefe3eb 198symmetric_dequant(int code, int levels)
98a27a8a 199{
a4de6dd2 200 return ((code - (levels >> 1)) << 24) / levels;
98a27a8a
JR
201}
202
c7cfc48f
JR
203/*
204 * Initialize tables at runtime.
205 */
98a6fff9 206static av_cold void ac3_tables_init(void)
00585845 207{
4415076f 208 int i;
98a27a8a 209
5aefe3eb
JR
210 /* generate grouped mantissa tables
211 reference: Section 7.3.5 Ungrouping of Mantissas */
212 for(i=0; i<32; i++) {
213 /* bap=1 mantissas */
214 b1_mantissas[i][0] = symmetric_dequant( i / 9 , 3);
215 b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);
216 b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);
217 }
218 for(i=0; i<128; i++) {
219 /* bap=2 mantissas */
220 b2_mantissas[i][0] = symmetric_dequant( i / 25 , 5);
221 b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);
222 b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);
223
224 /* bap=4 mantissas */
225 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
226 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
227 }
228 /* generate ungrouped mantissa tables
229 reference: Tables 7.21 and 7.23 */
230 for(i=0; i<7; i++) {
231 /* bap=3 mantissas */
232 b3_mantissas[i] = symmetric_dequant(i, 7);
233 }
234 for(i=0; i<15; i++) {
235 /* bap=5 mantissas */
236 b5_mantissas[i] = symmetric_dequant(i, 15);
237 }
c7cfc48f 238
3357ff33
JR
239 /* generate dynamic range table
240 reference: Section 7.7.1 Dynamic Range Control */
241 for(i=0; i<256; i++) {
242 int v = (i >> 5) - ((i >> 7) << 3) - 5;
e2270b4e 243 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
3357ff33
JR
244 }
245
4415076f
JR
246 /* generate exponent tables
247 reference: Section 7.1.3 Exponent Decoding */
248 for(i=0; i<128; i++) {
bfcf690c
JR
249 exp_ungroup_tab[i][0] = i / 25;
250 exp_ungroup_tab[i][1] = (i % 25) / 5;
251 exp_ungroup_tab[i][2] = (i % 25) % 5;
4415076f 252 }
00585845
JR
253}
254
1b293437 255
5066f515
JR
256/**
257 * AVCodec initialization
258 */
98a6fff9 259static av_cold int ac3_decode_init(AVCodecContext *avctx)
1b293437 260{
d802d7ca
JR
261 AC3DecodeContext *s = avctx->priv_data;
262 s->avctx = avctx;
1b293437 263
cc2a8443 264 ac3_common_init();
98a27a8a 265 ac3_tables_init();
d802d7ca
JR
266 ff_mdct_init(&s->imdct_256, 8, 1);
267 ff_mdct_init(&s->imdct_512, 9, 1);
3ed546fe 268 ff_kbd_window_init(s->window, 5.0, 256);
d802d7ca
JR
269 dsputil_init(&s->dsp, avctx);
270 av_init_random(0, &s->dith_state);
2aa2c5c4 271
5066f515 272 /* set bias values for float to int16 conversion */
d802d7ca
JR
273 if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
274 s->add_bias = 385.0f;
275 s->mul_bias = 1.0f;
4e092320 276 } else {
d802d7ca
JR
277 s->add_bias = 0.0f;
278 s->mul_bias = 32767.0f;
4e092320
JR
279 }
280
95283c17
JR
281 /* allow downmixing to stereo or mono */
282 if (avctx->channels > 0 && avctx->request_channels > 0 &&
283 avctx->request_channels < avctx->channels &&
284 avctx->request_channels <= 2) {
285 avctx->channels = avctx->request_channels;
286 }
38dae9c3 287 s->downmixed = 1;
95283c17 288
509fdb0b
JR
289 /* allocate context input buffer */
290 if (avctx->error_resilience >= FF_ER_CAREFUL) {
291 s->input_buffer = av_mallocz(AC3_MAX_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
292 if (!s->input_buffer)
293 return AVERROR_NOMEM;
294 }
295
1b293437 296 return 0;
2aa2c5c4
JR
297}
298
9fc1ab72 299/**
5066f515 300 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
c7cfc48f
JR
301 * GetBitContext within AC3DecodeContext must point to
302 * start of the synchronized ac3 bitstream.
c7cfc48f 303 */
d802d7ca 304static int ac3_parse_header(AC3DecodeContext *s)
2aa2c5c4 305{
9fc1ab72 306 AC3HeaderInfo hdr;
d802d7ca 307 GetBitContext *gbc = &s->gbc;
9fc1ab72
JR
308 int err, i;
309
55736cfb 310 err = ff_ac3_parse_header(gbc, &hdr);
9fc1ab72
JR
311 if(err)
312 return err;
313
646800f7
JR
314 if(hdr.bitstream_id > 10)
315 return AC3_PARSE_ERROR_BSID;
316
9fc1ab72 317 /* get decoding parameters from header info */
d802d7ca
JR
318 s->bit_alloc_params.sr_code = hdr.sr_code;
319 s->channel_mode = hdr.channel_mode;
1b70d88b 320 s->lfe_on = hdr.lfe_on;
d802d7ca 321 s->bit_alloc_params.sr_shift = hdr.sr_shift;
866181e5 322 s->sample_rate = hdr.sample_rate;
d802d7ca
JR
323 s->bit_rate = hdr.bit_rate;
324 s->channels = hdr.channels;
325 s->fbw_channels = s->channels - s->lfe_on;
326 s->lfe_ch = s->fbw_channels + 1;
327 s->frame_size = hdr.frame_size;
55736cfb
BW
328 s->center_mix_level = hdr.center_mix_level;
329 s->surround_mix_level = hdr.surround_mix_level;
6730e9f3 330 s->num_blocks = hdr.num_blocks;
be5f17b9 331 s->frame_type = hdr.frame_type;
3596aa6f 332 s->substreamid = hdr.substreamid;
7bfd22f2 333
6e74513a
JR
334 if(s->lfe_on) {
335 s->start_freq[s->lfe_ch] = 0;
336 s->end_freq[s->lfe_ch] = 7;
337 s->num_exp_groups[s->lfe_ch] = 2;
338 s->channel_in_cpl[s->lfe_ch] = 0;
339 }
340
9fc1ab72 341 /* read the rest of the bsi. read twice for dual mono mode. */
d802d7ca 342 i = !(s->channel_mode);
98a27a8a 343 do {
23c8cb89
JR
344 skip_bits(gbc, 5); // skip dialog normalization
345 if (get_bits1(gbc))
346 skip_bits(gbc, 8); //skip compression
347 if (get_bits1(gbc))
348 skip_bits(gbc, 8); //skip language code
349 if (get_bits1(gbc))
350 skip_bits(gbc, 7); //skip audio production information
98a27a8a
JR
351 } while (i--);
352
23c8cb89 353 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
98a27a8a 354
5066f515
JR
355 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
356 TODO: read & use the xbsi1 downmix levels */
23c8cb89
JR
357 if (get_bits1(gbc))
358 skip_bits(gbc, 14); //skip timecode1 / xbsi1
359 if (get_bits1(gbc))
360 skip_bits(gbc, 14); //skip timecode2 / xbsi2
98a27a8a 361
5066f515 362 /* skip additional bitstream info */
23c8cb89
JR
363 if (get_bits1(gbc)) {
364 i = get_bits(gbc, 6);
486637af 365 do {
23c8cb89 366 skip_bits(gbc, 8);
98a27a8a 367 } while(i--);
1b293437 368 }
9fc1ab72 369
f0b3a7ba
JR
370 return 0;
371}
372
373/**
374 * Set stereo downmixing coefficients based on frame header info.
375 * reference: Section 7.8.2 Downmixing Into Two Channels
376 */
377static void set_downmix_coeffs(AC3DecodeContext *s)
378{
379 int i;
380 float cmix = gain_levels[s->center_mix_level];
381 float smix = gain_levels[s->surround_mix_level];
382
d802d7ca
JR
383 for(i=0; i<s->fbw_channels; i++) {
384 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
385 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
3bbb0bf8 386 }
d802d7ca 387 if(s->channel_mode > 1 && s->channel_mode & 1) {
f0b3a7ba 388 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
3bbb0bf8 389 }
d802d7ca
JR
390 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
391 int nf = s->channel_mode - 2;
f0b3a7ba 392 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
3bbb0bf8 393 }
d802d7ca
JR
394 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
395 int nf = s->channel_mode - 4;
f0b3a7ba 396 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
3bbb0bf8 397 }
9d10e6e6 398
d8870f12
JR
399 /* calculate adjustment needed for each channel to avoid clipping */
400 s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
9d10e6e6 401 for(i=0; i<s->fbw_channels; i++) {
d8870f12
JR
402 s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
403 s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
9d10e6e6 404 }
d8870f12
JR
405 s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
406 s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
2aa2c5c4
JR
407}
408
3bb004fc 409/**
5066f515
JR
410 * Decode the grouped exponents according to exponent strategy.
411 * reference: Section 7.1.3 Exponent Decoding
2aa2c5c4 412 */
23c8cb89 413static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
bc8edb7e 414 uint8_t absexp, int8_t *dexps)
2aa2c5c4 415{
e2270b4e 416 int i, j, grp, group_size;
4415076f
JR
417 int dexp[256];
418 int expacc, prevexp;
419
420 /* unpack groups */
e2270b4e 421 group_size = exp_strategy + (exp_strategy == EXP_D45);
4415076f 422 for(grp=0,i=0; grp<ngrps; grp++) {
23c8cb89 423 expacc = get_bits(gbc, 7);
bfcf690c
JR
424 dexp[i++] = exp_ungroup_tab[expacc][0];
425 dexp[i++] = exp_ungroup_tab[expacc][1];
426 dexp[i++] = exp_ungroup_tab[expacc][2];
4415076f 427 }
2aa2c5c4 428
4415076f
JR
429 /* convert to absolute exps and expand groups */
430 prevexp = absexp;
431 for(i=0; i<ngrps*3; i++) {
432 prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
e2270b4e
JR
433 for(j=0; j<group_size; j++) {
434 dexps[(i*group_size)+j] = prevexp;
1b293437 435 }
2aa2c5c4 436 }
2aa2c5c4
JR
437}
438
d7dc7ad0 439/**
5066f515 440 * Generate transform coefficients for each coupled channel in the coupling
d7dc7ad0
JR
441 * range using the coupling coefficients and coupling coordinates.
442 * reference: Section 7.4.3 Coupling Coordinate Format
443 */
d802d7ca 444static void uncouple_channels(AC3DecodeContext *s)
d7dc7ad0
JR
445{
446 int i, j, ch, bnd, subbnd;
447
448 subbnd = -1;
d802d7ca
JR
449 i = s->start_freq[CPL_CH];
450 for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
d7dc7ad0
JR
451 do {
452 subbnd++;
453 for(j=0; j<12; j++) {
d802d7ca 454 for(ch=1; ch<=s->fbw_channels; ch++) {
b02fbf75 455 if(s->channel_in_cpl[ch]) {
a4de6dd2 456 s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
b02fbf75 457 if (ch == 2 && s->phase_flags[bnd])
a4de6dd2 458 s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
b02fbf75 459 }
d7dc7ad0
JR
460 }
461 i++;
462 }
d802d7ca 463 } while(s->cpl_band_struct[subbnd]);
d7dc7ad0
JR
464 }
465}
466
5066f515
JR
467/**
468 * Grouped mantissas for 3-level 5-level and 11-level quantization
469 */
470typedef struct {
a4de6dd2
JR
471 int b1_mant[3];
472 int b2_mant[3];
473 int b4_mant[2];
5aefe3eb
JR
474 int b1ptr;
475 int b2ptr;
476 int b4ptr;
486637af
JR
477} mant_groups;
478
5066f515
JR
479/**
480 * Get the transform coefficients for a particular channel
481 * reference: Section 7.3 Quantization and Decoding of Mantissas
482 */
ff5d419e 483static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
1b293437 484{
d802d7ca 485 GetBitContext *gbc = &s->gbc;
60f07fad 486 int i, gcode, tbap, start, end;
2fbbd087
JR
487 uint8_t *exps;
488 uint8_t *bap;
a4de6dd2 489 int *coeffs;
2fbbd087 490
d802d7ca
JR
491 exps = s->dexps[ch_index];
492 bap = s->bap[ch_index];
a4de6dd2 493 coeffs = s->fixed_coeffs[ch_index];
d802d7ca
JR
494 start = s->start_freq[ch_index];
495 end = s->end_freq[ch_index];
1b293437 496
285bf28c 497 for (i = start; i < end; i++) {
98a27a8a
JR
498 tbap = bap[i];
499 switch (tbap) {
1b293437 500 case 0:
a4de6dd2 501 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 4194304;
d63f6fea 502 break;
1b293437
JR
503
504 case 1:
5aefe3eb 505 if(m->b1ptr > 2) {
23c8cb89 506 gcode = get_bits(gbc, 5);
5aefe3eb
JR
507 m->b1_mant[0] = b1_mantissas[gcode][0];
508 m->b1_mant[1] = b1_mantissas[gcode][1];
509 m->b1_mant[2] = b1_mantissas[gcode][2];
510 m->b1ptr = 0;
1b293437 511 }
5aefe3eb 512 coeffs[i] = m->b1_mant[m->b1ptr++];
d63f6fea 513 break;
1b293437
JR
514
515 case 2:
5aefe3eb 516 if(m->b2ptr > 2) {
23c8cb89 517 gcode = get_bits(gbc, 7);
5aefe3eb
JR
518 m->b2_mant[0] = b2_mantissas[gcode][0];
519 m->b2_mant[1] = b2_mantissas[gcode][1];
520 m->b2_mant[2] = b2_mantissas[gcode][2];
521 m->b2ptr = 0;
1b293437 522 }
5aefe3eb 523 coeffs[i] = m->b2_mant[m->b2ptr++];
d63f6fea 524 break;
1b293437
JR
525
526 case 3:
23c8cb89 527 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
d63f6fea 528 break;
1b293437
JR
529
530 case 4:
5aefe3eb 531 if(m->b4ptr > 1) {
23c8cb89 532 gcode = get_bits(gbc, 7);
5aefe3eb
JR
533 m->b4_mant[0] = b4_mantissas[gcode][0];
534 m->b4_mant[1] = b4_mantissas[gcode][1];
535 m->b4ptr = 0;
1b293437 536 }
5aefe3eb 537 coeffs[i] = m->b4_mant[m->b4ptr++];
d63f6fea 538 break;
1b293437
JR
539
540 case 5:
23c8cb89 541 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
d63f6fea 542 break;
1b293437 543
a4de6dd2 544 default: {
5066f515 545 /* asymmetric dequantization */
a4de6dd2
JR
546 int qlevel = quantization_tab[tbap];
547 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
d63f6fea 548 break;
a4de6dd2 549 }
1b293437 550 }
a4de6dd2 551 coeffs[i] >>= exps[i];
1b293437 552 }
1b293437
JR
553}
554
60f07fad 555/**
5066f515 556 * Remove random dithering from coefficients with zero-bit mantissas
60f07fad
JR
557 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
558 */
d802d7ca 559static void remove_dithering(AC3DecodeContext *s) {
60f07fad
JR
560 int ch, i;
561 int end=0;
a4de6dd2 562 int *coeffs;
60f07fad
JR
563 uint8_t *bap;
564
d802d7ca
JR
565 for(ch=1; ch<=s->fbw_channels; ch++) {
566 if(!s->dither_flag[ch]) {
a4de6dd2 567 coeffs = s->fixed_coeffs[ch];
d802d7ca
JR
568 bap = s->bap[ch];
569 if(s->channel_in_cpl[ch])
570 end = s->start_freq[CPL_CH];
60f07fad 571 else
d802d7ca 572 end = s->end_freq[ch];
60f07fad 573 for(i=0; i<end; i++) {
12eaa3b7 574 if(!bap[i])
a4de6dd2 575 coeffs[i] = 0;
60f07fad 576 }
d802d7ca
JR
577 if(s->channel_in_cpl[ch]) {
578 bap = s->bap[CPL_CH];
579 for(; i<s->end_freq[CPL_CH]; i++) {
12eaa3b7 580 if(!bap[i])
a4de6dd2 581 coeffs[i] = 0;
60f07fad
JR
582 }
583 }
584 }
585 }
586}
587
5066f515
JR
588/**
589 * Get the transform coefficients.
c7cfc48f 590 */
ff5d419e 591static void get_transform_coeffs(AC3DecodeContext *s)
1b293437 592{
7b4076a7 593 int ch, end;
1b293437 594 int got_cplchan = 0;
486637af
JR
595 mant_groups m;
596
5aefe3eb 597 m.b1ptr = m.b2ptr = m.b4ptr = 3;
1b293437 598
d802d7ca 599 for (ch = 1; ch <= s->channels; ch++) {
5066f515 600 /* transform coefficients for full-bandwidth channel */
ff5d419e 601 get_transform_coeffs_ch(s, ch, &m);
5066f515
JR
602 /* tranform coefficients for coupling channel come right after the
603 coefficients for the first coupled channel*/
d802d7ca 604 if (s->channel_in_cpl[ch]) {
486637af 605 if (!got_cplchan) {
ff5d419e 606 get_transform_coeffs_ch(s, CPL_CH, &m);
d802d7ca 607 uncouple_channels(s);
486637af
JR
608 got_cplchan = 1;
609 }
d802d7ca 610 end = s->end_freq[CPL_CH];
eaf84d97 611 } else {
d802d7ca 612 end = s->end_freq[ch];
eaf84d97 613 }
486637af 614 do
bd98e9e2 615 s->fixed_coeffs[ch][end] = 0;
486637af
JR
616 while(++end < 256);
617 }
1b293437 618
60f07fad 619 /* if any channel doesn't use dithering, zero appropriate coefficients */
d802d7ca
JR
620 if(!s->dither_all)
621 remove_dithering(s);
2aa2c5c4
JR
622}
623
8b60bbbf 624/**
5066f515 625 * Stereo rematrixing.
8b60bbbf
JR
626 * reference: Section 7.5.4 Rematrixing : Decoding Technique
627 */
d802d7ca 628static void do_rematrixing(AC3DecodeContext *s)
1b293437 629{
8b60bbbf 630 int bnd, i;
2fbbd087 631 int end, bndend;
a4de6dd2 632 int tmp0, tmp1;
2fbbd087 633
d802d7ca 634 end = FFMIN(s->end_freq[1], s->end_freq[2]);
1b293437 635
d802d7ca
JR
636 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
637 if(s->rematrixing_flags[bnd]) {
bfcf690c
JR
638 bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
639 for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
a4de6dd2
JR
640 tmp0 = s->fixed_coeffs[1][i];
641 tmp1 = s->fixed_coeffs[2][i];
642 s->fixed_coeffs[1][i] = tmp0 + tmp1;
643 s->fixed_coeffs[2][i] = tmp0 - tmp1;
8b60bbbf
JR
644 }
645 }
1b293437
JR
646 }
647}
2aa2c5c4 648
5066f515
JR
649/**
650 * Perform the 256-point IMDCT
c7cfc48f 651 */
d802d7ca 652static void do_imdct_256(AC3DecodeContext *s, int chindex)
486637af 653{
0de73a46 654 int i, k;
dfd57c36 655 DECLARE_ALIGNED_16(float, x[128]);
0de73a46 656 FFTComplex z[2][64];
d802d7ca 657 float *o_ptr = s->tmp_output;
0de73a46
JR
658
659 for(i=0; i<2; i++) {
660 /* de-interleave coefficients */
661 for(k=0; k<128; k++) {
d802d7ca 662 x[k] = s->transform_coeffs[chindex][2*k+i];
0de73a46 663 }
98a27a8a 664
0de73a46 665 /* run standard IMDCT */
d802d7ca 666 s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct);
0de73a46
JR
667
668 /* reverse the post-rotation & reordering from standard IMDCT */
669 for(k=0; k<32; k++) {
670 z[i][32+k].re = -o_ptr[128+2*k];
671 z[i][32+k].im = -o_ptr[2*k];
672 z[i][31-k].re = o_ptr[2*k+1];
673 z[i][31-k].im = o_ptr[128+2*k+1];
674 }
1ea76064 675 }
486637af 676
0de73a46
JR
677 /* apply AC-3 post-rotation & reordering */
678 for(k=0; k<64; k++) {
679 o_ptr[ 2*k ] = -z[0][ k].im;
680 o_ptr[ 2*k+1] = z[0][63-k].re;
681 o_ptr[128+2*k ] = -z[0][ k].re;
682 o_ptr[128+2*k+1] = z[0][63-k].im;
683 o_ptr[256+2*k ] = -z[1][ k].re;
684 o_ptr[256+2*k+1] = z[1][63-k].im;
685 o_ptr[384+2*k ] = z[1][ k].im;
686 o_ptr[384+2*k+1] = -z[1][63-k].re;
687 }
98a27a8a 688}
486637af 689
5066f515
JR
690/**
691 * Inverse MDCT Transform.
692 * Convert frequency domain coefficients to time-domain audio samples.
693 * reference: Section 7.9.4 Transformation Equations
694 */
38dae9c3 695static inline void do_imdct(AC3DecodeContext *s, int channels)
486637af 696{
0de73a46 697 int ch;
7b4076a7 698
e2270b4e 699 for (ch=1; ch<=channels; ch++) {
d802d7ca
JR
700 if (s->block_switch[ch]) {
701 do_imdct_256(s, ch);
eaf84d97 702 } else {
d802d7ca 703 s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
1b70d88b 704 s->transform_coeffs[ch], s->tmp_imdct);
eaf84d97 705 }
5066f515
JR
706 /* For the first half of the block, apply the window, add the delay
707 from the previous block, and send to output */
d802d7ca
JR
708 s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
709 s->window, s->delay[ch-1], 0, 256, 1);
5066f515
JR
710 /* For the second half of the block, apply the window and store the
711 samples to delay, to be combined with the next block */
d802d7ca 712 s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
1b70d88b 713 s->window, 256);
486637af
JR
714 }
715}
716
3bbb0bf8 717/**
5066f515 718 * Downmix the output to mono or stereo.
3bbb0bf8 719 */
38dae9c3
JR
720static void ac3_downmix(AC3DecodeContext *s,
721 float samples[AC3_MAX_CHANNELS][256], int ch_offset)
3bbb0bf8
JR
722{
723 int i, j;
9d10e6e6 724 float v0, v1;
3bbb0bf8
JR
725
726 for(i=0; i<256; i++) {
9d10e6e6 727 v0 = v1 = 0.0f;
b35c67e5 728 for(j=0; j<s->fbw_channels; j++) {
38dae9c3
JR
729 v0 += samples[j+ch_offset][i] * s->downmix_coeffs[j][0];
730 v1 += samples[j+ch_offset][i] * s->downmix_coeffs[j][1];
3bbb0bf8 731 }
d8870f12
JR
732 v0 *= s->downmix_coeff_adjust[0];
733 v1 *= s->downmix_coeff_adjust[1];
b35c67e5 734 if(s->output_mode == AC3_CHMODE_MONO) {
38dae9c3 735 samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB;
b35c67e5 736 } else if(s->output_mode == AC3_CHMODE_STEREO) {
38dae9c3
JR
737 samples[ ch_offset][i] = v0;
738 samples[1+ch_offset][i] = v1;
3bbb0bf8
JR
739 }
740 }
741}
742
5066f515 743/**
38dae9c3
JR
744 * Upmix delay samples from stereo to original channel layout.
745 */
746static void ac3_upmix_delay(AC3DecodeContext *s)
747{
748 int channel_data_size = sizeof(s->delay[0]);
749 switch(s->channel_mode) {
750 case AC3_CHMODE_DUALMONO:
751 case AC3_CHMODE_STEREO:
752 /* upmix mono to stereo */
753 memcpy(s->delay[1], s->delay[0], channel_data_size);
754 break;
755 case AC3_CHMODE_2F2R:
756 memset(s->delay[3], 0, channel_data_size);
757 case AC3_CHMODE_2F1R:
758 memset(s->delay[2], 0, channel_data_size);
759 break;
760 case AC3_CHMODE_3F2R:
761 memset(s->delay[4], 0, channel_data_size);
762 case AC3_CHMODE_3F1R:
763 memset(s->delay[3], 0, channel_data_size);
764 case AC3_CHMODE_3F:
765 memcpy(s->delay[2], s->delay[1], channel_data_size);
766 memset(s->delay[1], 0, channel_data_size);
767 break;
768 }
769}
770
771/**
5066f515 772 * Parse an audio block from AC-3 bitstream.
c7cfc48f 773 */
d802d7ca 774static int ac3_parse_audio_block(AC3DecodeContext *s, int blk)
2aa2c5c4 775{
d802d7ca
JR
776 int fbw_channels = s->fbw_channels;
777 int channel_mode = s->channel_mode;
0bff58a5 778 int i, bnd, seg, ch;
38dae9c3
JR
779 int different_transforms;
780 int downmix_output;
d802d7ca 781 GetBitContext *gbc = &s->gbc;
7b4076a7 782 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
1b293437 783
7b4076a7
JR
784 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
785
5066f515 786 /* block switch flags */
38dae9c3
JR
787 different_transforms = 0;
788 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 789 s->block_switch[ch] = get_bits1(gbc);
38dae9c3
JR
790 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
791 different_transforms = 1;
792 }
98a27a8a 793
5066f515 794 /* dithering flags */
d802d7ca 795 s->dither_all = 1;
e2270b4e 796 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca
JR
797 s->dither_flag[ch] = get_bits1(gbc);
798 if(!s->dither_flag[ch])
799 s->dither_all = 0;
60f07fad 800 }
98a27a8a 801
77416325 802 /* dynamic range */
d802d7ca 803 i = !(s->channel_mode);
77416325 804 do {
23c8cb89 805 if(get_bits1(gbc)) {
d802d7ca 806 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
1b70d88b 807 s->avctx->drc_scale)+1.0;
9fc1ab72 808 } else if(blk == 0) {
d802d7ca 809 s->dynamic_range[i] = 1.0f;
9fc1ab72 810 }
77416325 811 } while(i--);
98a27a8a 812
5066f515 813 /* coupling strategy */
23c8cb89 814 if (get_bits1(gbc)) {
7b4076a7 815 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
d802d7ca
JR
816 s->cpl_in_use = get_bits1(gbc);
817 if (s->cpl_in_use) {
5066f515 818 /* coupling in use */
e2270b4e 819 int cpl_begin_freq, cpl_end_freq;
b6acc57f 820
3af91313
JR
821 if (channel_mode < AC3_CHMODE_STEREO) {
822 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
823 return -1;
824 }
825
5066f515 826 /* determine which channels are coupled */
e2270b4e 827 for (ch = 1; ch <= fbw_channels; ch++)
d802d7ca 828 s->channel_in_cpl[ch] = get_bits1(gbc);
98a27a8a 829
5066f515 830 /* phase flags in use */
e59cc205 831 if (channel_mode == AC3_CHMODE_STEREO)
d802d7ca 832 s->phase_flags_in_use = get_bits1(gbc);
98a27a8a 833
5066f515 834 /* coupling frequency range and band structure */
23c8cb89
JR
835 cpl_begin_freq = get_bits(gbc, 4);
836 cpl_end_freq = get_bits(gbc, 4);
e2270b4e 837 if (3 + cpl_end_freq - cpl_begin_freq < 0) {
d802d7ca 838 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
00585845 839 return -1;
98a27a8a 840 }
d802d7ca
JR
841 s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
842 s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
843 s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
844 for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
23c8cb89 845 if (get_bits1(gbc)) {
d802d7ca
JR
846 s->cpl_band_struct[bnd] = 1;
847 s->num_cpl_bands--;
1b293437 848 }
eaf84d97 849 }
4bc829bb 850 s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
878c40a1 851 } else {
5066f515 852 /* coupling not in use */
e2270b4e 853 for (ch = 1; ch <= fbw_channels; ch++)
d802d7ca 854 s->channel_in_cpl[ch] = 0;
1b293437 855 }
82a591d8
JR
856 } else if (!blk) {
857 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
858 return -1;
1b293437 859 }
98a27a8a 860
5066f515 861 /* coupling coordinates */
d802d7ca 862 if (s->cpl_in_use) {
e2270b4e 863 int cpl_coords_exist = 0;
98a27a8a 864
e2270b4e 865 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca 866 if (s->channel_in_cpl[ch]) {
23c8cb89 867 if (get_bits1(gbc)) {
e2270b4e
JR
868 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
869 cpl_coords_exist = 1;
23c8cb89 870 master_cpl_coord = 3 * get_bits(gbc, 2);
d802d7ca 871 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
23c8cb89
JR
872 cpl_coord_exp = get_bits(gbc, 4);
873 cpl_coord_mant = get_bits(gbc, 4);
e2270b4e 874 if (cpl_coord_exp == 15)
a4de6dd2 875 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
486637af 876 else
a4de6dd2
JR
877 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
878 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
486637af 879 }
82a591d8
JR
880 } else if (!blk) {
881 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
882 return -1;
486637af 883 }
eaf84d97
JR
884 }
885 }
5066f515 886 /* phase flags */
b02fbf75 887 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
d802d7ca 888 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
b02fbf75 889 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
eaf84d97
JR
890 }
891 }
2aa2c5c4 892 }
98a27a8a 893
5066f515 894 /* stereo rematrixing strategy and band structure */
e59cc205 895 if (channel_mode == AC3_CHMODE_STEREO) {
82a6c481 896 if (get_bits1(gbc)) {
d802d7ca
JR
897 s->num_rematrixing_bands = 4;
898 if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
899 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
900 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
901 s->rematrixing_flags[bnd] = get_bits1(gbc);
82a591d8
JR
902 } else if (!blk) {
903 av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
904 return -1;
1b293437 905 }
98a27a8a
JR
906 }
907
5066f515 908 /* exponent strategies for each channel */
d802d7ca
JR
909 s->exp_strategy[CPL_CH] = EXP_REUSE;
910 s->exp_strategy[s->lfe_ch] = EXP_REUSE;
911 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
9b575459 912 s->exp_strategy[ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
d802d7ca 913 if(s->exp_strategy[ch] != EXP_REUSE)
7b4076a7
JR
914 bit_alloc_stages[ch] = 3;
915 }
916
5066f515 917 /* channel bandwidth */
e2270b4e 918 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca
JR
919 s->start_freq[ch] = 0;
920 if (s->exp_strategy[ch] != EXP_REUSE) {
b85a15fe 921 int group_size;
d802d7ca
JR
922 int prev = s->end_freq[ch];
923 if (s->channel_in_cpl[ch])
924 s->end_freq[ch] = s->start_freq[CPL_CH];
00585845 925 else {
23c8cb89 926 int bandwidth_code = get_bits(gbc, 6);
e2270b4e 927 if (bandwidth_code > 60) {
d802d7ca 928 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
00585845
JR
929 return -1;
930 }
d802d7ca 931 s->end_freq[ch] = bandwidth_code * 3 + 73;
1b293437 932 }
b85a15fe
JR
933 group_size = 3 << (s->exp_strategy[ch] - 1);
934 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
d802d7ca 935 if(blk > 0 && s->end_freq[ch] != prev)
7b4076a7 936 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00585845 937 }
eaf84d97 938 }
b85a15fe
JR
939 if (s->cpl_in_use && s->exp_strategy[CPL_CH] != EXP_REUSE) {
940 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
941 (3 << (s->exp_strategy[CPL_CH] - 1));
942 }
7b4076a7 943
5066f515 944 /* decode exponents for each channel */
d802d7ca
JR
945 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
946 if (s->exp_strategy[ch] != EXP_REUSE) {
d802d7ca 947 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
b85a15fe
JR
948 decode_exponents(gbc, s->exp_strategy[ch],
949 s->num_exp_groups[ch], s->dexps[ch][0],
d802d7ca
JR
950 &s->dexps[ch][s->start_freq[ch]+!!ch]);
951 if(ch != CPL_CH && ch != s->lfe_ch)
23c8cb89 952 skip_bits(gbc, 2); /* skip gainrng */
1b293437 953 }
eaf84d97 954 }
98a27a8a 955
5066f515 956 /* bit allocation information */
23c8cb89 957 if (get_bits1(gbc)) {
d802d7ca
JR
958 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
959 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
960 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
961 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
962 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
aa148649 963 for(ch=!s->cpl_in_use; ch<=s->channels; ch++)
7b4076a7 964 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
82a591d8
JR
965 } else if (!blk) {
966 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
967 return -1;
1b293437 968 }
98a27a8a 969
5066f515 970 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
23c8cb89 971 if (get_bits1(gbc)) {
4611b64e 972 int csnr;
23c8cb89 973 csnr = (get_bits(gbc, 6) - 15) << 4;
d802d7ca
JR
974 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
975 s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
976 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1b293437 977 }
7b4076a7 978 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
82a591d8
JR
979 } else if (!blk) {
980 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
981 return -1;
1b293437 982 }
98a27a8a 983
5066f515 984 /* coupling leak information */
43ad93a4
JR
985 if (s->cpl_in_use) {
986 if (get_bits1(gbc)) {
93a2c8c1
JR
987 s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
988 s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
989 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
990 } else if (!blk) {
991 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
992 return -1;
993 }
43ad93a4 994 }
98a27a8a 995
5066f515 996 /* delta bit allocation information */
23c8cb89 997 if (get_bits1(gbc)) {
5066f515 998 /* delta bit allocation exists (strategy) */
d802d7ca
JR
999 for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1000 s->dba_mode[ch] = get_bits(gbc, 2);
1001 if (s->dba_mode[ch] == DBA_RESERVED) {
1002 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1b293437
JR
1003 return -1;
1004 }
7b4076a7 1005 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1006 }
5066f515 1007 /* channel delta offset, len and bit allocation */
d802d7ca
JR
1008 for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1009 if (s->dba_mode[ch] == DBA_NEW) {
1010 s->dba_nsegs[ch] = get_bits(gbc, 3);
1011 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1012 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1013 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1014 s->dba_values[ch][seg] = get_bits(gbc, 3);
1b293437 1015 }
e25973a1
JR
1016 /* run last 2 bit allocation stages if new dba values */
1017 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1018 }
eaf84d97 1019 }
9fc1ab72 1020 } else if(blk == 0) {
d802d7ca
JR
1021 for(ch=0; ch<=s->channels; ch++) {
1022 s->dba_mode[ch] = DBA_NONE;
9fc1ab72 1023 }
1b293437 1024 }
00585845 1025
5066f515 1026 /* Bit allocation */
d802d7ca 1027 for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
7b4076a7
JR
1028 if(bit_alloc_stages[ch] > 2) {
1029 /* Exponent mapping into PSD and PSD integration */
d802d7ca
JR
1030 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1031 s->start_freq[ch], s->end_freq[ch],
1032 s->psd[ch], s->band_psd[ch]);
eaf84d97 1033 }
7b4076a7
JR
1034 if(bit_alloc_stages[ch] > 1) {
1035 /* Compute excitation function, Compute masking curve, and
1036 Apply delta bit allocation */
d802d7ca
JR
1037 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1038 s->start_freq[ch], s->end_freq[ch],
1039 s->fast_gain[ch], (ch == s->lfe_ch),
1040 s->dba_mode[ch], s->dba_nsegs[ch],
1041 s->dba_offsets[ch], s->dba_lengths[ch],
1042 s->dba_values[ch], s->mask[ch]);
eaf84d97 1043 }
7b4076a7
JR
1044 if(bit_alloc_stages[ch] > 0) {
1045 /* Compute bit allocation */
d802d7ca
JR
1046 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1047 s->start_freq[ch], s->end_freq[ch],
1048 s->snr_offset[ch],
1049 s->bit_alloc_params.floor,
687671f0 1050 ff_ac3_bap_tab, s->bap[ch]);
eaf84d97 1051 }
2fbbd087 1052 }
98a27a8a 1053
5066f515 1054 /* unused dummy data */
23c8cb89
JR
1055 if (get_bits1(gbc)) {
1056 int skipl = get_bits(gbc, 9);
98a27a8a 1057 while(skipl--)
23c8cb89 1058 skip_bits(gbc, 8);
1b293437 1059 }
f5cefb21 1060
1b293437 1061 /* unpack the transform coefficients
5066f515 1062 this also uncouples channels if coupling is in use. */
ff5d419e 1063 get_transform_coeffs(s);
486637af 1064
1b293437 1065 /* recover coefficients if rematrixing is in use */
d802d7ca
JR
1066 if(s->channel_mode == AC3_CHMODE_STEREO)
1067 do_rematrixing(s);
1b293437 1068
03726b70 1069 /* apply scaling to coefficients (headroom, dynrng) */
d802d7ca 1070 for(ch=1; ch<=s->channels; ch++) {
a4de6dd2 1071 float gain = s->mul_bias / 4194304.0f;
d802d7ca
JR
1072 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1073 gain *= s->dynamic_range[ch-1];
7bfd22f2 1074 } else {
d802d7ca 1075 gain *= s->dynamic_range[0];
7bfd22f2 1076 }
a4de6dd2
JR
1077 for(i=0; i<256; i++) {
1078 s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
7bfd22f2
JR
1079 }
1080 }
d7bcc4ad 1081
38dae9c3
JR
1082 /* downmix and MDCT. order depends on whether block switching is used for
1083 any channel in this block. this is because coefficients for the long
1084 and short transforms cannot be mixed. */
1085 downmix_output = s->channels != s->out_channels &&
1086 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1087 s->fbw_channels == s->out_channels);
1088 if(different_transforms) {
1089 /* the delay samples have already been downmixed, so we upmix the delay
1090 samples in order to reconstruct all channels before downmixing. */
1091 if(s->downmixed) {
1092 s->downmixed = 0;
1093 ac3_upmix_delay(s);
1094 }
1095
1096 do_imdct(s, s->channels);
1097
1098 if(downmix_output) {
1099 ac3_downmix(s, s->output, 0);
1100 }
1101 } else {
1102 if(downmix_output) {
1103 ac3_downmix(s, s->transform_coeffs, 1);
1104 }
1105
1106 if(!s->downmixed) {
1107 s->downmixed = 1;
1108 ac3_downmix(s, s->delay, 0);
1109 }
486637af 1110
38dae9c3 1111 do_imdct(s, s->out_channels);
3bbb0bf8
JR
1112 }
1113
4e092320 1114 /* convert float to 16-bit integer */
d802d7ca 1115 for(ch=0; ch<s->out_channels; ch++) {
3bbb0bf8 1116 for(i=0; i<256; i++) {
d802d7ca 1117 s->output[ch][i] += s->add_bias;
3bbb0bf8 1118 }
d802d7ca 1119 s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
4e092320 1120 }
1b293437 1121
4e092320 1122 return 0;
486637af
JR
1123}
1124
5066f515
JR
1125/**
1126 * Decode a single AC-3 frame.
c7cfc48f 1127 */
98f6dfa6
JR
1128static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1129 const uint8_t *buf, int buf_size)
1b293437 1130{
0345fade 1131 AC3DecodeContext *s = avctx->priv_data;
00585845 1132 int16_t *out_samples = (int16_t *)data;
3df88093 1133 int i, blk, ch, err;
d7bcc4ad 1134
5066f515 1135 /* initialize the GetBitContext with the start of valid AC-3 Frame */
509fdb0b 1136 if (s->input_buffer) {
c33a1967
JR
1137 /* copy input buffer to decoder context to avoid reading past the end
1138 of the buffer, which can be caused by a damaged input stream. */
1139 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1140 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1141 } else {
984ff38a 1142 init_get_bits(&s->gbc, buf, buf_size * 8);
c33a1967 1143 }
00585845 1144
5066f515 1145 /* parse the syncinfo */
c78c6d6c 1146 *data_size = 0;
d802d7ca 1147 err = ac3_parse_header(s);
c78c6d6c
JR
1148
1149 /* check that reported frame size fits in input buffer */
1150 if(s->frame_size > buf_size) {
1151 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1152 err = AC3_PARSE_ERROR_FRAME_SIZE;
1153 }
1154
1155 /* check for crc mismatch */
1156 if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1157 if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1158 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
fbe52e41 1159 err = AC3_PARSE_ERROR_CRC;
c78c6d6c
JR
1160 }
1161 }
1162
fbe52e41 1163 if(err && err != AC3_PARSE_ERROR_CRC) {
3df88093
JR
1164 switch(err) {
1165 case AC3_PARSE_ERROR_SYNC:
c78c6d6c 1166 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
7af26d14 1167 return -1;
3df88093
JR
1168 case AC3_PARSE_ERROR_BSID:
1169 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1170 break;
1171 case AC3_PARSE_ERROR_SAMPLE_RATE:
1172 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1173 break;
1174 case AC3_PARSE_ERROR_FRAME_SIZE:
1175 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1176 break;
79b25a27 1177 case AC3_PARSE_ERROR_FRAME_TYPE:
aa5d6be8
JR
1178 /* skip frame if CRC is ok. otherwise use error concealment. */
1179 /* TODO: add support for substreams and dependent frames */
1180 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1181 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1182 return s->frame_size;
1183 } else {
4921bbba 1184 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
aa5d6be8 1185 }
4e6eeaf0 1186 break;
3df88093
JR
1187 default:
1188 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1189 break;
1190 }
1b293437 1191 }
2aa2c5c4 1192
eccba2bc
JR
1193 /* if frame is ok, set audio parameters */
1194 if (!err) {
3336110a
JR
1195 avctx->sample_rate = s->sample_rate;
1196 avctx->bit_rate = s->bit_rate;
1197
1198 /* channel config */
1199 s->out_channels = s->channels;
eccba2bc
JR
1200 s->output_mode = s->channel_mode;
1201 if(s->lfe_on)
1202 s->output_mode |= AC3_OUTPUT_LFEON;
3336110a
JR
1203 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1204 avctx->request_channels < s->channels) {
1205 s->out_channels = avctx->request_channels;
1206 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1207 }
1208 avctx->channels = s->out_channels;
1b293437 1209
3336110a
JR
1210 /* set downmixing coefficients if needed */
1211 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1212 s->fbw_channels == s->out_channels)) {
1213 set_downmix_coeffs(s);
1214 }
eccba2bc
JR
1215 } else if (!s->out_channels) {
1216 s->out_channels = avctx->channels;
1217 if(s->out_channels < s->channels)
1218 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
ecfe94b2 1219 }
f0b3a7ba 1220
5066f515 1221 /* parse the audio blocks */
6730e9f3 1222 for (blk = 0; blk < s->num_blocks; blk++) {
ecfe94b2 1223 if (!err && ac3_parse_audio_block(s, blk)) {
1b293437 1224 av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1b293437 1225 }
fb2b88a8
JR
1226
1227 /* interleave output samples */
75b9b036 1228 for (i = 0; i < 256; i++)
d802d7ca
JR
1229 for (ch = 0; ch < s->out_channels; ch++)
1230 *(out_samples++) = s->int_output[ch][i];
1b293437 1231 }
6730e9f3 1232 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
d802d7ca 1233 return s->frame_size;
2aa2c5c4 1234}
1b293437 1235
5066f515
JR
1236/**
1237 * Uninitialize the AC-3 decoder.
c7cfc48f 1238 */
98a6fff9 1239static av_cold int ac3_decode_end(AVCodecContext *avctx)
1b293437 1240{
0345fade 1241 AC3DecodeContext *s = avctx->priv_data;
d802d7ca
JR
1242 ff_mdct_end(&s->imdct_512);
1243 ff_mdct_end(&s->imdct_256);
c7cfc48f 1244
509fdb0b
JR
1245 av_freep(&s->input_buffer);
1246
1b293437
JR
1247 return 0;
1248}
1249
fa67992d 1250AVCodec ac3_decoder = {
e6bca37c
JR
1251 .name = "ac3",
1252 .type = CODEC_TYPE_AUDIO,
1253 .id = CODEC_ID_AC3,
1254 .priv_data_size = sizeof (AC3DecodeContext),
1255 .init = ac3_decode_init,
1256 .close = ac3_decode_end,
1257 .decode = ac3_decode_frame,
162d4fc9 1258 .long_name = "ATSC A/52 / AC-3",
1b293437 1259};