Merge two if's
[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
JR
326
327 /* set default output to all source channels */
d802d7ca
JR
328 s->out_channels = s->channels;
329 s->output_mode = s->channel_mode;
330 if(s->lfe_on)
331 s->output_mode |= AC3_OUTPUT_LFEON;
9fc1ab72 332
9fc1ab72 333 /* read the rest of the bsi. read twice for dual mono mode. */
d802d7ca 334 i = !(s->channel_mode);
98a27a8a 335 do {
23c8cb89
JR
336 skip_bits(gbc, 5); // skip dialog normalization
337 if (get_bits1(gbc))
338 skip_bits(gbc, 8); //skip compression
339 if (get_bits1(gbc))
340 skip_bits(gbc, 8); //skip language code
341 if (get_bits1(gbc))
342 skip_bits(gbc, 7); //skip audio production information
98a27a8a
JR
343 } while (i--);
344
23c8cb89 345 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
98a27a8a 346
5066f515
JR
347 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
348 TODO: read & use the xbsi1 downmix levels */
23c8cb89
JR
349 if (get_bits1(gbc))
350 skip_bits(gbc, 14); //skip timecode1 / xbsi1
351 if (get_bits1(gbc))
352 skip_bits(gbc, 14); //skip timecode2 / xbsi2
98a27a8a 353
5066f515 354 /* skip additional bitstream info */
23c8cb89
JR
355 if (get_bits1(gbc)) {
356 i = get_bits(gbc, 6);
486637af 357 do {
23c8cb89 358 skip_bits(gbc, 8);
98a27a8a 359 } while(i--);
1b293437 360 }
9fc1ab72 361
f0b3a7ba
JR
362 return 0;
363}
364
365/**
366 * Set stereo downmixing coefficients based on frame header info.
367 * reference: Section 7.8.2 Downmixing Into Two Channels
368 */
369static void set_downmix_coeffs(AC3DecodeContext *s)
370{
371 int i;
372 float cmix = gain_levels[s->center_mix_level];
373 float smix = gain_levels[s->surround_mix_level];
374
d802d7ca
JR
375 for(i=0; i<s->fbw_channels; i++) {
376 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
377 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
3bbb0bf8 378 }
d802d7ca 379 if(s->channel_mode > 1 && s->channel_mode & 1) {
f0b3a7ba 380 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
3bbb0bf8 381 }
d802d7ca
JR
382 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
383 int nf = s->channel_mode - 2;
f0b3a7ba 384 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
3bbb0bf8 385 }
d802d7ca
JR
386 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
387 int nf = s->channel_mode - 4;
f0b3a7ba 388 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
3bbb0bf8 389 }
9d10e6e6 390
d8870f12
JR
391 /* calculate adjustment needed for each channel to avoid clipping */
392 s->downmix_coeff_adjust[0] = s->downmix_coeff_adjust[1] = 0.0f;
9d10e6e6 393 for(i=0; i<s->fbw_channels; i++) {
d8870f12
JR
394 s->downmix_coeff_adjust[0] += s->downmix_coeffs[i][0];
395 s->downmix_coeff_adjust[1] += s->downmix_coeffs[i][1];
9d10e6e6 396 }
d8870f12
JR
397 s->downmix_coeff_adjust[0] = 1.0f / s->downmix_coeff_adjust[0];
398 s->downmix_coeff_adjust[1] = 1.0f / s->downmix_coeff_adjust[1];
2aa2c5c4
JR
399}
400
3bb004fc 401/**
5066f515
JR
402 * Decode the grouped exponents according to exponent strategy.
403 * reference: Section 7.1.3 Exponent Decoding
2aa2c5c4 404 */
23c8cb89 405static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
bc8edb7e 406 uint8_t absexp, int8_t *dexps)
2aa2c5c4 407{
e2270b4e 408 int i, j, grp, group_size;
4415076f
JR
409 int dexp[256];
410 int expacc, prevexp;
411
412 /* unpack groups */
e2270b4e 413 group_size = exp_strategy + (exp_strategy == EXP_D45);
4415076f 414 for(grp=0,i=0; grp<ngrps; grp++) {
23c8cb89 415 expacc = get_bits(gbc, 7);
bfcf690c
JR
416 dexp[i++] = exp_ungroup_tab[expacc][0];
417 dexp[i++] = exp_ungroup_tab[expacc][1];
418 dexp[i++] = exp_ungroup_tab[expacc][2];
4415076f 419 }
2aa2c5c4 420
4415076f
JR
421 /* convert to absolute exps and expand groups */
422 prevexp = absexp;
423 for(i=0; i<ngrps*3; i++) {
424 prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
e2270b4e
JR
425 for(j=0; j<group_size; j++) {
426 dexps[(i*group_size)+j] = prevexp;
1b293437 427 }
2aa2c5c4 428 }
2aa2c5c4
JR
429}
430
d7dc7ad0 431/**
5066f515 432 * Generate transform coefficients for each coupled channel in the coupling
d7dc7ad0
JR
433 * range using the coupling coefficients and coupling coordinates.
434 * reference: Section 7.4.3 Coupling Coordinate Format
435 */
d802d7ca 436static void uncouple_channels(AC3DecodeContext *s)
d7dc7ad0
JR
437{
438 int i, j, ch, bnd, subbnd;
439
440 subbnd = -1;
d802d7ca
JR
441 i = s->start_freq[CPL_CH];
442 for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
d7dc7ad0
JR
443 do {
444 subbnd++;
445 for(j=0; j<12; j++) {
d802d7ca 446 for(ch=1; ch<=s->fbw_channels; ch++) {
b02fbf75 447 if(s->channel_in_cpl[ch]) {
a4de6dd2 448 s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
b02fbf75 449 if (ch == 2 && s->phase_flags[bnd])
a4de6dd2 450 s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
b02fbf75 451 }
d7dc7ad0
JR
452 }
453 i++;
454 }
d802d7ca 455 } while(s->cpl_band_struct[subbnd]);
d7dc7ad0
JR
456 }
457}
458
5066f515
JR
459/**
460 * Grouped mantissas for 3-level 5-level and 11-level quantization
461 */
462typedef struct {
a4de6dd2
JR
463 int b1_mant[3];
464 int b2_mant[3];
465 int b4_mant[2];
5aefe3eb
JR
466 int b1ptr;
467 int b2ptr;
468 int b4ptr;
486637af
JR
469} mant_groups;
470
5066f515
JR
471/**
472 * Get the transform coefficients for a particular channel
473 * reference: Section 7.3 Quantization and Decoding of Mantissas
474 */
d802d7ca 475static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
1b293437 476{
d802d7ca 477 GetBitContext *gbc = &s->gbc;
60f07fad 478 int i, gcode, tbap, start, end;
2fbbd087
JR
479 uint8_t *exps;
480 uint8_t *bap;
a4de6dd2 481 int *coeffs;
2fbbd087 482
d802d7ca
JR
483 exps = s->dexps[ch_index];
484 bap = s->bap[ch_index];
a4de6dd2 485 coeffs = s->fixed_coeffs[ch_index];
d802d7ca
JR
486 start = s->start_freq[ch_index];
487 end = s->end_freq[ch_index];
1b293437 488
285bf28c 489 for (i = start; i < end; i++) {
98a27a8a
JR
490 tbap = bap[i];
491 switch (tbap) {
1b293437 492 case 0:
a4de6dd2 493 coeffs[i] = (av_random(&s->dith_state) & 0x7FFFFF) - 4194304;
d63f6fea 494 break;
1b293437
JR
495
496 case 1:
5aefe3eb 497 if(m->b1ptr > 2) {
23c8cb89 498 gcode = get_bits(gbc, 5);
5aefe3eb
JR
499 m->b1_mant[0] = b1_mantissas[gcode][0];
500 m->b1_mant[1] = b1_mantissas[gcode][1];
501 m->b1_mant[2] = b1_mantissas[gcode][2];
502 m->b1ptr = 0;
1b293437 503 }
5aefe3eb 504 coeffs[i] = m->b1_mant[m->b1ptr++];
d63f6fea 505 break;
1b293437
JR
506
507 case 2:
5aefe3eb 508 if(m->b2ptr > 2) {
23c8cb89 509 gcode = get_bits(gbc, 7);
5aefe3eb
JR
510 m->b2_mant[0] = b2_mantissas[gcode][0];
511 m->b2_mant[1] = b2_mantissas[gcode][1];
512 m->b2_mant[2] = b2_mantissas[gcode][2];
513 m->b2ptr = 0;
1b293437 514 }
5aefe3eb 515 coeffs[i] = m->b2_mant[m->b2ptr++];
d63f6fea 516 break;
1b293437
JR
517
518 case 3:
23c8cb89 519 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
d63f6fea 520 break;
1b293437
JR
521
522 case 4:
5aefe3eb 523 if(m->b4ptr > 1) {
23c8cb89 524 gcode = get_bits(gbc, 7);
5aefe3eb
JR
525 m->b4_mant[0] = b4_mantissas[gcode][0];
526 m->b4_mant[1] = b4_mantissas[gcode][1];
527 m->b4ptr = 0;
1b293437 528 }
5aefe3eb 529 coeffs[i] = m->b4_mant[m->b4ptr++];
d63f6fea 530 break;
1b293437
JR
531
532 case 5:
23c8cb89 533 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
d63f6fea 534 break;
1b293437 535
a4de6dd2 536 default: {
5066f515 537 /* asymmetric dequantization */
a4de6dd2
JR
538 int qlevel = quantization_tab[tbap];
539 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
d63f6fea 540 break;
a4de6dd2 541 }
1b293437 542 }
a4de6dd2 543 coeffs[i] >>= exps[i];
1b293437
JR
544 }
545
1b293437
JR
546 return 0;
547}
548
60f07fad 549/**
5066f515 550 * Remove random dithering from coefficients with zero-bit mantissas
60f07fad
JR
551 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
552 */
d802d7ca 553static void remove_dithering(AC3DecodeContext *s) {
60f07fad
JR
554 int ch, i;
555 int end=0;
a4de6dd2 556 int *coeffs;
60f07fad
JR
557 uint8_t *bap;
558
d802d7ca
JR
559 for(ch=1; ch<=s->fbw_channels; ch++) {
560 if(!s->dither_flag[ch]) {
a4de6dd2 561 coeffs = s->fixed_coeffs[ch];
d802d7ca
JR
562 bap = s->bap[ch];
563 if(s->channel_in_cpl[ch])
564 end = s->start_freq[CPL_CH];
60f07fad 565 else
d802d7ca 566 end = s->end_freq[ch];
60f07fad 567 for(i=0; i<end; i++) {
12eaa3b7 568 if(!bap[i])
a4de6dd2 569 coeffs[i] = 0;
60f07fad 570 }
d802d7ca
JR
571 if(s->channel_in_cpl[ch]) {
572 bap = s->bap[CPL_CH];
573 for(; i<s->end_freq[CPL_CH]; i++) {
12eaa3b7 574 if(!bap[i])
a4de6dd2 575 coeffs[i] = 0;
60f07fad
JR
576 }
577 }
578 }
579 }
580}
581
5066f515
JR
582/**
583 * Get the transform coefficients.
c7cfc48f 584 */
d802d7ca 585static int get_transform_coeffs(AC3DecodeContext *s)
1b293437 586{
7b4076a7 587 int ch, end;
1b293437 588 int got_cplchan = 0;
486637af
JR
589 mant_groups m;
590
5aefe3eb 591 m.b1ptr = m.b2ptr = m.b4ptr = 3;
1b293437 592
d802d7ca 593 for (ch = 1; ch <= s->channels; ch++) {
5066f515 594 /* transform coefficients for full-bandwidth channel */
d802d7ca 595 if (get_transform_coeffs_ch(s, ch, &m))
1b293437 596 return -1;
5066f515
JR
597 /* tranform coefficients for coupling channel come right after the
598 coefficients for the first coupled channel*/
d802d7ca 599 if (s->channel_in_cpl[ch]) {
486637af 600 if (!got_cplchan) {
d802d7ca
JR
601 if (get_transform_coeffs_ch(s, CPL_CH, &m)) {
602 av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n");
486637af 603 return -1;
98a27a8a 604 }
d802d7ca 605 uncouple_channels(s);
486637af
JR
606 got_cplchan = 1;
607 }
d802d7ca 608 end = s->end_freq[CPL_CH];
eaf84d97 609 } else {
d802d7ca 610 end = s->end_freq[ch];
eaf84d97 611 }
486637af 612 do
d802d7ca 613 s->transform_coeffs[ch][end] = 0;
486637af
JR
614 while(++end < 256);
615 }
1b293437 616
60f07fad 617 /* if any channel doesn't use dithering, zero appropriate coefficients */
d802d7ca
JR
618 if(!s->dither_all)
619 remove_dithering(s);
60f07fad 620
1b293437 621 return 0;
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++) {
912 if(ch == s->lfe_ch)
913 s->exp_strategy[ch] = get_bits(gbc, 1);
7b4076a7 914 else
d802d7ca
JR
915 s->exp_strategy[ch] = get_bits(gbc, 2);
916 if(s->exp_strategy[ch] != EXP_REUSE)
7b4076a7
JR
917 bit_alloc_stages[ch] = 3;
918 }
919
5066f515 920 /* channel bandwidth */
e2270b4e 921 for (ch = 1; ch <= fbw_channels; ch++) {
d802d7ca
JR
922 s->start_freq[ch] = 0;
923 if (s->exp_strategy[ch] != EXP_REUSE) {
924 int prev = s->end_freq[ch];
925 if (s->channel_in_cpl[ch])
926 s->end_freq[ch] = s->start_freq[CPL_CH];
00585845 927 else {
23c8cb89 928 int bandwidth_code = get_bits(gbc, 6);
e2270b4e 929 if (bandwidth_code > 60) {
d802d7ca 930 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
00585845
JR
931 return -1;
932 }
d802d7ca 933 s->end_freq[ch] = bandwidth_code * 3 + 73;
1b293437 934 }
d802d7ca 935 if(blk > 0 && s->end_freq[ch] != prev)
7b4076a7 936 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00585845 937 }
eaf84d97 938 }
d802d7ca
JR
939 s->start_freq[s->lfe_ch] = 0;
940 s->end_freq[s->lfe_ch] = 7;
7b4076a7 941
5066f515 942 /* decode exponents for each channel */
d802d7ca
JR
943 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
944 if (s->exp_strategy[ch] != EXP_REUSE) {
e2270b4e 945 int group_size, num_groups;
d802d7ca 946 group_size = 3 << (s->exp_strategy[ch] - 1);
7b4076a7 947 if(ch == CPL_CH)
d802d7ca
JR
948 num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;
949 else if(ch == s->lfe_ch)
e2270b4e 950 num_groups = 2;
7b4076a7 951 else
d802d7ca
JR
952 num_groups = (s->end_freq[ch] + group_size - 4) / group_size;
953 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
954 decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],
955 &s->dexps[ch][s->start_freq[ch]+!!ch]);
956 if(ch != CPL_CH && ch != s->lfe_ch)
23c8cb89 957 skip_bits(gbc, 2); /* skip gainrng */
1b293437 958 }
eaf84d97 959 }
98a27a8a 960
5066f515 961 /* bit allocation information */
23c8cb89 962 if (get_bits1(gbc)) {
d802d7ca
JR
963 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
964 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
965 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
966 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
967 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
968 for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
7b4076a7
JR
969 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
970 }
82a591d8
JR
971 } else if (!blk) {
972 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
973 return -1;
1b293437 974 }
98a27a8a 975
5066f515 976 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
23c8cb89 977 if (get_bits1(gbc)) {
4611b64e 978 int csnr;
23c8cb89 979 csnr = (get_bits(gbc, 6) - 15) << 4;
d802d7ca
JR
980 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
981 s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
982 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1b293437 983 }
7b4076a7 984 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
82a591d8
JR
985 } else if (!blk) {
986 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
987 return -1;
1b293437 988 }
98a27a8a 989
5066f515 990 /* coupling leak information */
43ad93a4
JR
991 if (s->cpl_in_use) {
992 if (get_bits1(gbc)) {
93a2c8c1
JR
993 s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
994 s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
995 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
996 } else if (!blk) {
997 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
998 return -1;
999 }
43ad93a4 1000 }
98a27a8a 1001
5066f515 1002 /* delta bit allocation information */
23c8cb89 1003 if (get_bits1(gbc)) {
5066f515 1004 /* delta bit allocation exists (strategy) */
d802d7ca
JR
1005 for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1006 s->dba_mode[ch] = get_bits(gbc, 2);
1007 if (s->dba_mode[ch] == DBA_RESERVED) {
1008 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1b293437
JR
1009 return -1;
1010 }
7b4076a7 1011 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1b293437 1012 }
5066f515 1013 /* channel delta offset, len and bit allocation */
d802d7ca
JR
1014 for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
1015 if (s->dba_mode[ch] == DBA_NEW) {
1016 s->dba_nsegs[ch] = get_bits(gbc, 3);
1017 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
1018 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1019 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1020 s->dba_values[ch][seg] = get_bits(gbc, 3);
1b293437
JR
1021 }
1022 }
eaf84d97 1023 }
9fc1ab72 1024 } else if(blk == 0) {
d802d7ca
JR
1025 for(ch=0; ch<=s->channels; ch++) {
1026 s->dba_mode[ch] = DBA_NONE;
9fc1ab72 1027 }
1b293437 1028 }
00585845 1029
5066f515 1030 /* Bit allocation */
d802d7ca 1031 for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
7b4076a7
JR
1032 if(bit_alloc_stages[ch] > 2) {
1033 /* Exponent mapping into PSD and PSD integration */
d802d7ca
JR
1034 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1035 s->start_freq[ch], s->end_freq[ch],
1036 s->psd[ch], s->band_psd[ch]);
eaf84d97 1037 }
7b4076a7
JR
1038 if(bit_alloc_stages[ch] > 1) {
1039 /* Compute excitation function, Compute masking curve, and
1040 Apply delta bit allocation */
d802d7ca
JR
1041 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1042 s->start_freq[ch], s->end_freq[ch],
1043 s->fast_gain[ch], (ch == s->lfe_ch),
1044 s->dba_mode[ch], s->dba_nsegs[ch],
1045 s->dba_offsets[ch], s->dba_lengths[ch],
1046 s->dba_values[ch], s->mask[ch]);
eaf84d97 1047 }
7b4076a7
JR
1048 if(bit_alloc_stages[ch] > 0) {
1049 /* Compute bit allocation */
d802d7ca
JR
1050 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1051 s->start_freq[ch], s->end_freq[ch],
1052 s->snr_offset[ch],
1053 s->bit_alloc_params.floor,
1054 s->bap[ch]);
eaf84d97 1055 }
2fbbd087 1056 }
98a27a8a 1057
5066f515 1058 /* unused dummy data */
23c8cb89
JR
1059 if (get_bits1(gbc)) {
1060 int skipl = get_bits(gbc, 9);
98a27a8a 1061 while(skipl--)
23c8cb89 1062 skip_bits(gbc, 8);
1b293437 1063 }
f5cefb21 1064
1b293437 1065 /* unpack the transform coefficients
5066f515 1066 this also uncouples channels if coupling is in use. */
d802d7ca
JR
1067 if (get_transform_coeffs(s)) {
1068 av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");
1b293437
JR
1069 return -1;
1070 }
486637af 1071
1b293437 1072 /* recover coefficients if rematrixing is in use */
d802d7ca
JR
1073 if(s->channel_mode == AC3_CHMODE_STEREO)
1074 do_rematrixing(s);
1b293437 1075
03726b70 1076 /* apply scaling to coefficients (headroom, dynrng) */
d802d7ca 1077 for(ch=1; ch<=s->channels; ch++) {
a4de6dd2 1078 float gain = s->mul_bias / 4194304.0f;
d802d7ca
JR
1079 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1080 gain *= s->dynamic_range[ch-1];
7bfd22f2 1081 } else {
d802d7ca 1082 gain *= s->dynamic_range[0];
7bfd22f2 1083 }
a4de6dd2
JR
1084 for(i=0; i<256; i++) {
1085 s->transform_coeffs[ch][i] = s->fixed_coeffs[ch][i] * gain;
7bfd22f2
JR
1086 }
1087 }
d7bcc4ad 1088
38dae9c3
JR
1089 /* downmix and MDCT. order depends on whether block switching is used for
1090 any channel in this block. this is because coefficients for the long
1091 and short transforms cannot be mixed. */
1092 downmix_output = s->channels != s->out_channels &&
1093 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1094 s->fbw_channels == s->out_channels);
1095 if(different_transforms) {
1096 /* the delay samples have already been downmixed, so we upmix the delay
1097 samples in order to reconstruct all channels before downmixing. */
1098 if(s->downmixed) {
1099 s->downmixed = 0;
1100 ac3_upmix_delay(s);
1101 }
1102
1103 do_imdct(s, s->channels);
1104
1105 if(downmix_output) {
1106 ac3_downmix(s, s->output, 0);
1107 }
1108 } else {
1109 if(downmix_output) {
1110 ac3_downmix(s, s->transform_coeffs, 1);
1111 }
1112
1113 if(!s->downmixed) {
1114 s->downmixed = 1;
1115 ac3_downmix(s, s->delay, 0);
1116 }
486637af 1117
38dae9c3 1118 do_imdct(s, s->out_channels);
3bbb0bf8
JR
1119 }
1120
4e092320 1121 /* convert float to 16-bit integer */
d802d7ca 1122 for(ch=0; ch<s->out_channels; ch++) {
3bbb0bf8 1123 for(i=0; i<256; i++) {
d802d7ca 1124 s->output[ch][i] += s->add_bias;
3bbb0bf8 1125 }
d802d7ca 1126 s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256);
4e092320 1127 }
1b293437 1128
4e092320 1129 return 0;
486637af
JR
1130}
1131
5066f515
JR
1132/**
1133 * Decode a single AC-3 frame.
c7cfc48f 1134 */
98f6dfa6
JR
1135static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1136 const uint8_t *buf, int buf_size)
1b293437 1137{
0345fade 1138 AC3DecodeContext *s = avctx->priv_data;
00585845 1139 int16_t *out_samples = (int16_t *)data;
3df88093 1140 int i, blk, ch, err;
d7bcc4ad 1141
5066f515 1142 /* initialize the GetBitContext with the start of valid AC-3 Frame */
509fdb0b 1143 if (s->input_buffer) {
c33a1967
JR
1144 /* copy input buffer to decoder context to avoid reading past the end
1145 of the buffer, which can be caused by a damaged input stream. */
1146 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE));
1147 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1148 } else {
984ff38a 1149 init_get_bits(&s->gbc, buf, buf_size * 8);
c33a1967 1150 }
00585845 1151
5066f515 1152 /* parse the syncinfo */
d802d7ca 1153 err = ac3_parse_header(s);
3df88093
JR
1154 if(err) {
1155 switch(err) {
1156 case AC3_PARSE_ERROR_SYNC:
ecfe94b2
JR
1157 av_log(avctx, AV_LOG_ERROR, "frame sync error : cannot use error concealment\n");
1158 return -1;
3df88093
JR
1159 case AC3_PARSE_ERROR_BSID:
1160 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1161 break;
1162 case AC3_PARSE_ERROR_SAMPLE_RATE:
1163 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1164 break;
1165 case AC3_PARSE_ERROR_FRAME_SIZE:
1166 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1167 break;
79b25a27
BW
1168 case AC3_PARSE_ERROR_FRAME_TYPE:
1169 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
4e6eeaf0 1170 break;
3df88093
JR
1171 default:
1172 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1173 break;
1174 }
1b293437 1175 }
2aa2c5c4 1176
a135bea5 1177 /* check that reported frame size fits in input buffer */
d802d7ca 1178 if(s->frame_size > buf_size) {
a135bea5
JR
1179 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1180 return -1;
1181 }
1182
d6939960 1183 /* check for crc mismatch */
cf03a817 1184 if(!err && avctx->error_resilience >= FF_ER_CAREFUL) {
3abe5fbd 1185 if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
7564658b 1186 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
ecfe94b2 1187 err = 1;
7564658b 1188 }
471db688 1189 }
d6939960 1190
cf03a817
JR
1191 /* if frame header is ok, set audio parameters */
1192 if (err >= 0) {
3336110a
JR
1193 avctx->sample_rate = s->sample_rate;
1194 avctx->bit_rate = s->bit_rate;
1195
1196 /* channel config */
1197 s->out_channels = s->channels;
1198 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1199 avctx->request_channels < s->channels) {
1200 s->out_channels = avctx->request_channels;
1201 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1202 }
1203 avctx->channels = s->out_channels;
1b293437 1204
3336110a
JR
1205 /* set downmixing coefficients if needed */
1206 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1207 s->fbw_channels == s->out_channels)) {
1208 set_downmix_coeffs(s);
1209 }
ecfe94b2 1210 }
f0b3a7ba 1211
5066f515 1212 /* parse the audio blocks */
75b9b036 1213 for (blk = 0; blk < NB_BLOCKS; blk++) {
ecfe94b2 1214 if (!err && ac3_parse_audio_block(s, blk)) {
1b293437 1215 av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1b293437 1216 }
75b9b036 1217 for (i = 0; i < 256; i++)
d802d7ca
JR
1218 for (ch = 0; ch < s->out_channels; ch++)
1219 *(out_samples++) = s->int_output[ch][i];
1b293437 1220 }
8fbb368d 1221 *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t);
d802d7ca 1222 return s->frame_size;
2aa2c5c4 1223}
1b293437 1224
5066f515
JR
1225/**
1226 * Uninitialize the AC-3 decoder.
c7cfc48f 1227 */
98a6fff9 1228static av_cold int ac3_decode_end(AVCodecContext *avctx)
1b293437 1229{
0345fade 1230 AC3DecodeContext *s = avctx->priv_data;
d802d7ca
JR
1231 ff_mdct_end(&s->imdct_512);
1232 ff_mdct_end(&s->imdct_256);
c7cfc48f 1233
509fdb0b
JR
1234 av_freep(&s->input_buffer);
1235
1b293437
JR
1236 return 0;
1237}
1238
fa67992d 1239AVCodec ac3_decoder = {
e6bca37c
JR
1240 .name = "ac3",
1241 .type = CODEC_TYPE_AUDIO,
1242 .id = CODEC_ID_AC3,
1243 .priv_data_size = sizeof (AC3DecodeContext),
1244 .init = ac3_decode_init,
1245 .close = ac3_decode_end,
1246 .decode = ac3_decode_frame,
162d4fc9 1247 .long_name = "ATSC A/52 / AC-3",
1b293437 1248};