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