ffmpeg / libavcodec / ac3dec.c @ 984ff38a
History  View  Annotate  Download (43.1 KB)
1 
/*


2 
* AC3 Audio Decoder

3 
* This code is developed as part of Google Summer of Code 2006 Program.

4 
*

5 
* Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).

6 
* Copyright (c) 2007 Justin Ruggles

7 
*

8 
* Portions of this code are derived from liba52

9 
* http://liba52.sourceforge.net

10 
* Copyright (C) 20002003 Michel Lespinasse <walken@zoy.org>

11 
* Copyright (C) 19992000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>

12 
*

13 
* This file is part of FFmpeg.

14 
*

15 
* FFmpeg is free software; you can redistribute it and/or

16 
* modify it under the terms of the GNU General Public

17 
* License as published by the Free Software Foundation; either

18 
* version 2 of the License, or (at your option) any later version.

19 
*

20 
* FFmpeg is distributed in the hope that it will be useful,

21 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

22 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

23 
* General Public License for more details.

24 
*

25 
* You should have received a copy of the GNU General Public

26 
* License along with FFmpeg; if not, write to the Free Software

27 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

28 
*/

29  
30 
#include <stdio.h> 
31 
#include <stddef.h> 
32 
#include <math.h> 
33 
#include <string.h> 
34  
35 
#include "avcodec.h" 
36 
#include "ac3_parser.h" 
37 
#include "bitstream.h" 
38 
#include "crc.h" 
39 
#include "dsputil.h" 
40 
#include "random.h" 
41  
42 
/** Maximum possible frame size when the specification limit is ignored */

43 
#define AC3_MAX_FRAME_SIZE 21695 
44  
45 
/**

46 
* Table of bin locations for rematrixing bands

47 
* reference: Section 7.5.2 Rematrixing : Frequency Band Definitions

48 
*/

49 
static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 }; 
50  
51 
/** table for grouping exponents */

52 
static uint8_t exp_ungroup_tab[128][3]; 
53  
54  
55 
/** tables for ungrouping mantissas */

56 
static int b1_mantissas[32][3]; 
57 
static int b2_mantissas[128][3]; 
58 
static int b3_mantissas[8]; 
59 
static int b4_mantissas[128][2]; 
60 
static int b5_mantissas[16]; 
61  
62 
/**

63 
* Quantization table: levels for symmetric. bits for asymmetric.

64 
* reference: Table 7.18 Mapping of bap to Quantizer

65 
*/

66 
static const uint8_t quantization_tab[16] = { 
67 
0, 3, 5, 7, 11, 15, 
68 
5, 6, 7, 8, 9, 10, 11, 12, 14, 16 
69 
}; 
70  
71 
/** dynamic range table. converts codes to scale factors. */

72 
static float dynamic_range_tab[256]; 
73  
74 
/** Adjustments in dB gain */

75 
#define LEVEL_MINUS_3DB 0.7071067811865476 
76 
#define LEVEL_MINUS_4POINT5DB 0.5946035575013605 
77 
#define LEVEL_MINUS_6DB 0.5000000000000000 
78 
#define LEVEL_MINUS_9DB 0.3535533905932738 
79 
#define LEVEL_ZERO 0.0000000000000000 
80 
#define LEVEL_ONE 1.0000000000000000 
81  
82 
static 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 
}; 
90  
91 
/**

92 
* Table for center mix levels

93 
* reference: Section 5.4.2.4 cmixlev

94 
*/

95 
static const uint8_t center_levels[4] = { 2, 3, 4, 3 }; 
96  
97 
/**

98 
* Table for surround mix levels

99 
* reference: Section 5.4.2.5 surmixlev

100 
*/

101 
static const uint8_t surround_levels[4] = { 2, 4, 0, 4 }; 
102  
103 
/**

104 
* Table for default stereo downmixing coefficients

105 
* reference: Section 7.8.2 Downmixing Into Two Channels

106 
*/

107 
static const uint8_t ac3_default_coeffs[8][5][2] = { 
108 
{ { 1, 0 }, { 0, 1 }, }, 
109 
{ { 2, 2 }, }, 
110 
{ { 1, 0 }, { 0, 1 }, }, 
111 
{ { 1, 0 }, { 3, 3 }, { 0, 1 }, }, 
112 
{ { 1, 0 }, { 0, 1 }, { 4, 4 }, }, 
113 
{ { 1, 0 }, { 3, 3 }, { 0, 1 }, { 5, 5 }, }, 
114 
{ { 1, 0 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, }, 
115 
{ { 1, 0 }, { 3, 3 }, { 0, 1 }, { 4, 0 }, { 0, 4 }, }, 
116 
}; 
117  
118 
/* override ac3.h to include coupling channel */

119 
#undef AC3_MAX_CHANNELS

120 
#define AC3_MAX_CHANNELS 7 
121 
#define CPL_CH 0 
122  
123 
#define AC3_OUTPUT_LFEON 8 
124  
125 
typedef struct { 
126 
int channel_mode; ///< channel mode (acmod) 
127 
int block_switch[AC3_MAX_CHANNELS]; ///< block switch flags 
128 
int dither_flag[AC3_MAX_CHANNELS]; ///< dither flags 
129 
int dither_all; ///< true if all channels are dithered 
130 
int cpl_in_use; ///< coupling in use 
131 
int channel_in_cpl[AC3_MAX_CHANNELS]; ///< channel in coupling 
132 
int phase_flags_in_use; ///< phase flags in use 
133 
int phase_flags[18]; ///< phase flags 
134 
int cpl_band_struct[18]; ///< coupling band structure 
135 
int num_rematrixing_bands; ///< number of rematrixing bands 
136 
int rematrixing_flags[4]; ///< rematrixing flags 
137 
int exp_strategy[AC3_MAX_CHANNELS]; ///< exponent strategies 
138 
int snr_offset[AC3_MAX_CHANNELS]; ///< signaltonoise ratio offsets 
139 
int fast_gain[AC3_MAX_CHANNELS]; ///< fast gain values (signaltomask ratio) 
140 
int dba_mode[AC3_MAX_CHANNELS]; ///< delta bit allocation mode 
141 
int dba_nsegs[AC3_MAX_CHANNELS]; ///< number of delta segments 
142 
uint8_t dba_offsets[AC3_MAX_CHANNELS][8]; ///< delta segment offsets 
143 
uint8_t dba_lengths[AC3_MAX_CHANNELS][8]; ///< delta segment lengths 
144 
uint8_t dba_values[AC3_MAX_CHANNELS][8]; ///< delta values for each segment 
145  
146 
int sample_rate; ///< sample frequency, in Hz 
147 
int bit_rate; ///< stream bit rate, in bitspersecond 
148 
int frame_size; ///< current frame size, in bytes 
149  
150 
int channels; ///< number of total channels 
151 
int fbw_channels; ///< number of fullbandwidth channels 
152 
int lfe_on; ///< lfe channel in use 
153 
int lfe_ch; ///< index of LFE channel 
154 
int output_mode; ///< output channel configuration 
155 
int out_channels; ///< number of output channels 
156  
157 
int center_mix_level; ///< Center mix level index 
158 
int surround_mix_level; ///< Surround mix level index 
159 
float downmix_coeffs[AC3_MAX_CHANNELS][2]; ///< stereo downmix coefficients 
160 
float downmix_coeff_adjust[2]; ///< adjustment needed for each output channel when downmixing 
161 
float dynamic_range[2]; ///< dynamic range 
162 
int cpl_coords[AC3_MAX_CHANNELS][18]; ///< coupling coordinates 
163 
int num_cpl_bands; ///< number of coupling bands 
164 
int num_cpl_subbands; ///< number of coupling sub bands 
165 
int start_freq[AC3_MAX_CHANNELS]; ///< start frequency bin 
166 
int end_freq[AC3_MAX_CHANNELS]; ///< end frequency bin 
167 
AC3BitAllocParameters bit_alloc_params; ///< bit allocation parameters

168  
169 
int8_t dexps[AC3_MAX_CHANNELS][256]; ///< decoded exponents 
170 
uint8_t bap[AC3_MAX_CHANNELS][256]; ///< bit allocation pointers 
171 
int16_t psd[AC3_MAX_CHANNELS][256]; ///< scaled exponents 
172 
int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents 
173 
int16_t mask[AC3_MAX_CHANNELS][50]; ///< masking curve values 
174  
175 
int fixed_coeffs[AC3_MAX_CHANNELS][256]; ///> fixedpoint transform coefficients 
176 
DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); ///< transform coefficients 
177 
int downmixed; ///< indicates if coeffs are currently downmixed 
178  
179 
/* For IMDCT. */

180 
MDCTContext imdct_512; ///< for 512 sample IMDCT

181 
MDCTContext imdct_256; ///< for 256 sample IMDCT

182 
DSPContext dsp; ///< for optimization

183 
float add_bias; ///< offset for float_to_int16 conversion 
184 
float mul_bias; ///< scaling for float_to_int16 conversion 
185  
186 
DECLARE_ALIGNED_16(float, output[AC3_MAX_CHANNELS][256]); ///< output after imdct transform and windowing 
187 
DECLARE_ALIGNED_16(short, int_output[AC3_MAX_CHANNELS1][256]); ///< final 16bit integer output 
188 
DECLARE_ALIGNED_16(float, delay[AC3_MAX_CHANNELS][256]); ///< delay  added to the next block 
189 
DECLARE_ALIGNED_16(float, tmp_imdct[256]); ///< temporary storage for imdct transform 
190 
DECLARE_ALIGNED_16(float, tmp_output[512]); ///< temporary storage for output before windowing 
191 
DECLARE_ALIGNED_16(float, window[256]); ///< window coefficients 
192  
193 
/* Miscellaneous. */

194 
GetBitContext gbc; ///< bitstream reader

195 
AVRandomState dith_state; ///< for dither generation

196 
AVCodecContext *avctx; ///< parent context

197 
uint8_t input_buffer[AC3_MAX_FRAME_SIZE]; ///< temp buffer to prevent overread

198 
} AC3DecodeContext; 
199  
200 
/**

201 
* Symmetrical Dequantization

202 
* reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization

203 
* Tables 7.19 to 7.23

204 
*/

205 
static inline int 
206 
symmetric_dequant(int code, int levels) 
207 
{ 
208 
return ((code  (levels >> 1)) << 24) / levels; 
209 
} 
210  
211 
/*

212 
* Initialize tables at runtime.

213 
*/

214 
static av_cold void ac3_tables_init(void) 
215 
{ 
216 
int i;

217  
218 
/* generate grouped mantissa tables

219 
reference: Section 7.3.5 Ungrouping of Mantissas */

220 
for(i=0; i<32; i++) { 
221 
/* bap=1 mantissas */

222 
b1_mantissas[i][0] = symmetric_dequant( i / 9 , 3); 
223 
b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3); 
224 
b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3); 
225 
} 
226 
for(i=0; i<128; i++) { 
227 
/* bap=2 mantissas */

228 
b2_mantissas[i][0] = symmetric_dequant( i / 25 , 5); 
229 
b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5); 
230 
b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5); 
231  
232 
/* bap=4 mantissas */

233 
b4_mantissas[i][0] = symmetric_dequant(i / 11, 11); 
234 
b4_mantissas[i][1] = symmetric_dequant(i % 11, 11); 
235 
} 
236 
/* generate ungrouped mantissa tables

237 
reference: Tables 7.21 and 7.23 */

238 
for(i=0; i<7; i++) { 
239 
/* bap=3 mantissas */

240 
b3_mantissas[i] = symmetric_dequant(i, 7);

241 
} 
242 
for(i=0; i<15; i++) { 
243 
/* bap=5 mantissas */

244 
b5_mantissas[i] = symmetric_dequant(i, 15);

245 
} 
246  
247 
/* generate dynamic range table

248 
reference: Section 7.7.1 Dynamic Range Control */

249 
for(i=0; i<256; i++) { 
250 
int v = (i >> 5)  ((i >> 7) << 3)  5; 
251 
dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F)  0x20); 
252 
} 
253  
254 
/* generate exponent tables

255 
reference: Section 7.1.3 Exponent Decoding */

256 
for(i=0; i<128; i++) { 
257 
exp_ungroup_tab[i][0] = i / 25; 
258 
exp_ungroup_tab[i][1] = (i % 25) / 5; 
259 
exp_ungroup_tab[i][2] = (i % 25) % 5; 
260 
} 
261 
} 
262  
263  
264 
/**

265 
* AVCodec initialization

266 
*/

267 
static av_cold int ac3_decode_init(AVCodecContext *avctx) 
268 
{ 
269 
AC3DecodeContext *s = avctx>priv_data; 
270 
s>avctx = avctx; 
271  
272 
ac3_common_init(); 
273 
ac3_tables_init(); 
274 
ff_mdct_init(&s>imdct_256, 8, 1); 
275 
ff_mdct_init(&s>imdct_512, 9, 1); 
276 
ff_kbd_window_init(s>window, 5.0, 256); 
277 
dsputil_init(&s>dsp, avctx); 
278 
av_init_random(0, &s>dith_state);

279  
280 
/* set bias values for float to int16 conversion */

281 
if(s>dsp.float_to_int16 == ff_float_to_int16_c) {

282 
s>add_bias = 385.0f; 
283 
s>mul_bias = 1.0f; 
284 
} else {

285 
s>add_bias = 0.0f; 
286 
s>mul_bias = 32767.0f; 
287 
} 
288  
289 
/* allow downmixing to stereo or mono */

290 
if (avctx>channels > 0 && avctx>request_channels > 0 && 
291 
avctx>request_channels < avctx>channels && 
292 
avctx>request_channels <= 2) {

293 
avctx>channels = avctx>request_channels; 
294 
} 
295 
s>downmixed = 1;

296  
297 
return 0; 
298 
} 
299  
300 
/**

301 
* Parse the 'sync info' and 'bit stream info' from the AC3 bitstream.

302 
* GetBitContext within AC3DecodeContext must point to

303 
* start of the synchronized ac3 bitstream.

304 
*/

305 
static int ac3_parse_header(AC3DecodeContext *s) 
306 
{ 
307 
AC3HeaderInfo hdr; 
308 
GetBitContext *gbc = &s>gbc; 
309 
int err, i;

310  
311 
err = ff_ac3_parse_header(gbc>buffer, &hdr); 
312 
if(err)

313 
return err;

314  
315 
if(hdr.bitstream_id > 10) 
316 
return AC3_PARSE_ERROR_BSID;

317  
318 
/* get decoding parameters from header info */

319 
s>bit_alloc_params.sr_code = hdr.sr_code; 
320 
s>channel_mode = hdr.channel_mode; 
321 
s>lfe_on = hdr.lfe_on; 
322 
s>bit_alloc_params.sr_shift = hdr.sr_shift; 
323 
s>sample_rate = hdr.sample_rate; 
324 
s>bit_rate = hdr.bit_rate; 
325 
s>channels = hdr.channels; 
326 
s>fbw_channels = s>channels  s>lfe_on; 
327 
s>lfe_ch = s>fbw_channels + 1;

328 
s>frame_size = hdr.frame_size; 
329  
330 
/* set default output to all source channels */

331 
s>out_channels = s>channels; 
332 
s>output_mode = s>channel_mode; 
333 
if(s>lfe_on)

334 
s>output_mode = AC3_OUTPUT_LFEON; 
335  
336 
/* set default mix levels */

337 
s>center_mix_level = 3; // 4.5dB 
338 
s>surround_mix_level = 4; // 6.0dB 
339  
340 
/* skip over portion of header which has already been read */

341 
skip_bits(gbc, 16); // skip the sync_word 
342 
skip_bits(gbc, 16); // skip crc1 
343 
skip_bits(gbc, 8); // skip fscod and frmsizecod 
344 
skip_bits(gbc, 11); // skip bsid, bsmod, and acmod 
345 
if(s>channel_mode == AC3_CHMODE_STEREO) {

346 
skip_bits(gbc, 2); // skip dsurmod 
347 
} else {

348 
if((s>channel_mode & 1) && s>channel_mode != AC3_CHMODE_MONO) 
349 
s>center_mix_level = center_levels[get_bits(gbc, 2)];

350 
if(s>channel_mode & 4) 
351 
s>surround_mix_level = surround_levels[get_bits(gbc, 2)];

352 
} 
353 
skip_bits1(gbc); // skip lfeon

354  
355 
/* read the rest of the bsi. read twice for dual mono mode. */

356 
i = !(s>channel_mode); 
357 
do {

358 
skip_bits(gbc, 5); // skip dialog normalization 
359 
if (get_bits1(gbc))

360 
skip_bits(gbc, 8); //skip compression 
361 
if (get_bits1(gbc))

362 
skip_bits(gbc, 8); //skip language code 
363 
if (get_bits1(gbc))

364 
skip_bits(gbc, 7); //skip audio production information 
365 
} while (i);

366  
367 
skip_bits(gbc, 2); //skip copyright bit and original bitstream bit 
368  
369 
/* skip the timecodes (or extra bitstream information for Alternate Syntax)

370 
TODO: read & use the xbsi1 downmix levels */

371 
if (get_bits1(gbc))

372 
skip_bits(gbc, 14); //skip timecode1 / xbsi1 
373 
if (get_bits1(gbc))

374 
skip_bits(gbc, 14); //skip timecode2 / xbsi2 
375  
376 
/* skip additional bitstream info */

377 
if (get_bits1(gbc)) {

378 
i = get_bits(gbc, 6);

379 
do {

380 
skip_bits(gbc, 8);

381 
} while(i);

382 
} 
383  
384 
return 0; 
385 
} 
386  
387 
/**

388 
* Set stereo downmixing coefficients based on frame header info.

389 
* reference: Section 7.8.2 Downmixing Into Two Channels

390 
*/

391 
static void set_downmix_coeffs(AC3DecodeContext *s) 
392 
{ 
393 
int i;

394 
float cmix = gain_levels[s>center_mix_level];

395 
float smix = gain_levels[s>surround_mix_level];

396  
397 
for(i=0; i<s>fbw_channels; i++) { 
398 
s>downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s>channel_mode][i][0]]; 
399 
s>downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s>channel_mode][i][1]]; 
400 
} 
401 
if(s>channel_mode > 1 && s>channel_mode & 1) { 
402 
s>downmix_coeffs[1][0] = s>downmix_coeffs[1][1] = cmix; 
403 
} 
404 
if(s>channel_mode == AC3_CHMODE_2F1R  s>channel_mode == AC3_CHMODE_3F1R) {

405 
int nf = s>channel_mode  2; 
406 
s>downmix_coeffs[nf][0] = s>downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB; 
407 
} 
408 
if(s>channel_mode == AC3_CHMODE_2F2R  s>channel_mode == AC3_CHMODE_3F2R) {

409 
int nf = s>channel_mode  4; 
410 
s>downmix_coeffs[nf][0] = s>downmix_coeffs[nf+1][1] = smix; 
411 
} 
412  
413 
/* calculate adjustment needed for each channel to avoid clipping */

414 
s>downmix_coeff_adjust[0] = s>downmix_coeff_adjust[1] = 0.0f; 
415 
for(i=0; i<s>fbw_channels; i++) { 
416 
s>downmix_coeff_adjust[0] += s>downmix_coeffs[i][0]; 
417 
s>downmix_coeff_adjust[1] += s>downmix_coeffs[i][1]; 
418 
} 
419 
s>downmix_coeff_adjust[0] = 1.0f / s>downmix_coeff_adjust[0]; 
420 
s>downmix_coeff_adjust[1] = 1.0f / s>downmix_coeff_adjust[1]; 
421 
} 
422  
423 
/**

424 
* Decode the grouped exponents according to exponent strategy.

425 
* reference: Section 7.1.3 Exponent Decoding

426 
*/

427 
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, 
428 
uint8_t absexp, int8_t *dexps) 
429 
{ 
430 
int i, j, grp, group_size;

431 
int dexp[256]; 
432 
int expacc, prevexp;

433  
434 
/* unpack groups */

435 
group_size = exp_strategy + (exp_strategy == EXP_D45); 
436 
for(grp=0,i=0; grp<ngrps; grp++) { 
437 
expacc = get_bits(gbc, 7);

438 
dexp[i++] = exp_ungroup_tab[expacc][0];

439 
dexp[i++] = exp_ungroup_tab[expacc][1];

440 
dexp[i++] = exp_ungroup_tab[expacc][2];

441 
} 
442  
443 
/* convert to absolute exps and expand groups */

444 
prevexp = absexp; 
445 
for(i=0; i<ngrps*3; i++) { 
446 
prevexp = av_clip(prevexp + dexp[i]2, 0, 24); 
447 
for(j=0; j<group_size; j++) { 
448 
dexps[(i*group_size)+j] = prevexp; 
449 
} 
450 
} 
451 
} 
452  
453 
/**

454 
* Generate transform coefficients for each coupled channel in the coupling

455 
* range using the coupling coefficients and coupling coordinates.

456 
* reference: Section 7.4.3 Coupling Coordinate Format

457 
*/

458 
static void uncouple_channels(AC3DecodeContext *s) 
459 
{ 
460 
int i, j, ch, bnd, subbnd;

461  
462 
subbnd = 1;

463 
i = s>start_freq[CPL_CH]; 
464 
for(bnd=0; bnd<s>num_cpl_bands; bnd++) { 
465 
do {

466 
subbnd++; 
467 
for(j=0; j<12; j++) { 
468 
for(ch=1; ch<=s>fbw_channels; ch++) { 
469 
if(s>channel_in_cpl[ch]) {

470 
s>fixed_coeffs[ch][i] = ((int64_t)s>fixed_coeffs[CPL_CH][i] * (int64_t)s>cpl_coords[ch][bnd]) >> 23;

471 
if (ch == 2 && s>phase_flags[bnd]) 
472 
s>fixed_coeffs[ch][i] = s>fixed_coeffs[ch][i]; 
473 
} 
474 
} 
475 
i++; 
476 
} 
477 
} while(s>cpl_band_struct[subbnd]);

478 
} 
479 
} 
480  
481 
/**

482 
* Grouped mantissas for 3level 5level and 11level quantization

483 
*/

484 
typedef struct { 
485 
int b1_mant[3]; 
486 
int b2_mant[3]; 
487 
int b4_mant[2]; 
488 
int b1ptr;

489 
int b2ptr;

490 
int b4ptr;

491 
} mant_groups; 
492  
493 
/**

494 
* Get the transform coefficients for a particular channel

495 
* reference: Section 7.3 Quantization and Decoding of Mantissas

496 
*/

497 
static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) 
498 
{ 
499 
GetBitContext *gbc = &s>gbc; 
500 
int i, gcode, tbap, start, end;

501 
uint8_t *exps; 
502 
uint8_t *bap; 
503 
int *coeffs;

504  
505 
exps = s>dexps[ch_index]; 
506 
bap = s>bap[ch_index]; 
507 
coeffs = s>fixed_coeffs[ch_index]; 
508 
start = s>start_freq[ch_index]; 
509 
end = s>end_freq[ch_index]; 
510  
511 
for (i = start; i < end; i++) {

512 
tbap = bap[i]; 
513 
switch (tbap) {

514 
case 0: 
515 
coeffs[i] = (av_random(&s>dith_state) & 0x7FFFFF)  4194304; 
516 
break;

517  
518 
case 1: 
519 
if(m>b1ptr > 2) { 
520 
gcode = get_bits(gbc, 5);

521 
m>b1_mant[0] = b1_mantissas[gcode][0]; 
522 
m>b1_mant[1] = b1_mantissas[gcode][1]; 
523 
m>b1_mant[2] = b1_mantissas[gcode][2]; 
524 
m>b1ptr = 0;

525 
} 
526 
coeffs[i] = m>b1_mant[m>b1ptr++]; 
527 
break;

528  
529 
case 2: 
530 
if(m>b2ptr > 2) { 
531 
gcode = get_bits(gbc, 7);

532 
m>b2_mant[0] = b2_mantissas[gcode][0]; 
533 
m>b2_mant[1] = b2_mantissas[gcode][1]; 
534 
m>b2_mant[2] = b2_mantissas[gcode][2]; 
535 
m>b2ptr = 0;

536 
} 
537 
coeffs[i] = m>b2_mant[m>b2ptr++]; 
538 
break;

539  
540 
case 3: 
541 
coeffs[i] = b3_mantissas[get_bits(gbc, 3)];

542 
break;

543  
544 
case 4: 
545 
if(m>b4ptr > 1) { 
546 
gcode = get_bits(gbc, 7);

547 
m>b4_mant[0] = b4_mantissas[gcode][0]; 
548 
m>b4_mant[1] = b4_mantissas[gcode][1]; 
549 
m>b4ptr = 0;

550 
} 
551 
coeffs[i] = m>b4_mant[m>b4ptr++]; 
552 
break;

553  
554 
case 5: 
555 
coeffs[i] = b5_mantissas[get_bits(gbc, 4)];

556 
break;

557  
558 
default: {

559 
/* asymmetric dequantization */

560 
int qlevel = quantization_tab[tbap];

561 
coeffs[i] = get_sbits(gbc, qlevel) << (24  qlevel);

562 
break;

563 
} 
564 
} 
565 
coeffs[i] >>= exps[i]; 
566 
} 
567  
568 
return 0; 
569 
} 
570  
571 
/**

572 
* Remove random dithering from coefficients with zerobit mantissas

573 
* reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)

574 
*/

575 
static void remove_dithering(AC3DecodeContext *s) { 
576 
int ch, i;

577 
int end=0; 
578 
int *coeffs;

579 
uint8_t *bap; 
580  
581 
for(ch=1; ch<=s>fbw_channels; ch++) { 
582 
if(!s>dither_flag[ch]) {

583 
coeffs = s>fixed_coeffs[ch]; 
584 
bap = s>bap[ch]; 
585 
if(s>channel_in_cpl[ch])

586 
end = s>start_freq[CPL_CH]; 
587 
else

588 
end = s>end_freq[ch]; 
589 
for(i=0; i<end; i++) { 
590 
if(!bap[i])

591 
coeffs[i] = 0;

592 
} 
593 
if(s>channel_in_cpl[ch]) {

594 
bap = s>bap[CPL_CH]; 
595 
for(; i<s>end_freq[CPL_CH]; i++) {

596 
if(!bap[i])

597 
coeffs[i] = 0;

598 
} 
599 
} 
600 
} 
601 
} 
602 
} 
603  
604 
/**

605 
* Get the transform coefficients.

606 
*/

607 
static int get_transform_coeffs(AC3DecodeContext *s) 
608 
{ 
609 
int ch, end;

610 
int got_cplchan = 0; 
611 
mant_groups m; 
612  
613 
m.b1ptr = m.b2ptr = m.b4ptr = 3;

614  
615 
for (ch = 1; ch <= s>channels; ch++) { 
616 
/* transform coefficients for fullbandwidth channel */

617 
if (get_transform_coeffs_ch(s, ch, &m))

618 
return 1; 
619 
/* tranform coefficients for coupling channel come right after the

620 
coefficients for the first coupled channel*/

621 
if (s>channel_in_cpl[ch]) {

622 
if (!got_cplchan) {

623 
if (get_transform_coeffs_ch(s, CPL_CH, &m)) {

624 
av_log(s>avctx, AV_LOG_ERROR, "error in decoupling channels\n");

625 
return 1; 
626 
} 
627 
uncouple_channels(s); 
628 
got_cplchan = 1;

629 
} 
630 
end = s>end_freq[CPL_CH]; 
631 
} else {

632 
end = s>end_freq[ch]; 
633 
} 
634 
do

635 
s>transform_coeffs[ch][end] = 0;

636 
while(++end < 256); 
637 
} 
638  
639 
/* if any channel doesn't use dithering, zero appropriate coefficients */

640 
if(!s>dither_all)

641 
remove_dithering(s); 
642  
643 
return 0; 
644 
} 
645  
646 
/**

647 
* Stereo rematrixing.

648 
* reference: Section 7.5.4 Rematrixing : Decoding Technique

649 
*/

650 
static void do_rematrixing(AC3DecodeContext *s) 
651 
{ 
652 
int bnd, i;

653 
int end, bndend;

654 
int tmp0, tmp1;

655  
656 
end = FFMIN(s>end_freq[1], s>end_freq[2]); 
657  
658 
for(bnd=0; bnd<s>num_rematrixing_bands; bnd++) { 
659 
if(s>rematrixing_flags[bnd]) {

660 
bndend = FFMIN(end, rematrix_band_tab[bnd+1]);

661 
for(i=rematrix_band_tab[bnd]; i<bndend; i++) {

662 
tmp0 = s>fixed_coeffs[1][i];

663 
tmp1 = s>fixed_coeffs[2][i];

664 
s>fixed_coeffs[1][i] = tmp0 + tmp1;

665 
s>fixed_coeffs[2][i] = tmp0  tmp1;

666 
} 
667 
} 
668 
} 
669 
} 
670  
671 
/**

672 
* Perform the 256point IMDCT

673 
*/

674 
static void do_imdct_256(AC3DecodeContext *s, int chindex) 
675 
{ 
676 
int i, k;

677 
DECLARE_ALIGNED_16(float, x[128]); 
678 
FFTComplex z[2][64]; 
679 
float *o_ptr = s>tmp_output;

680  
681 
for(i=0; i<2; i++) { 
682 
/* deinterleave coefficients */

683 
for(k=0; k<128; k++) { 
684 
x[k] = s>transform_coeffs[chindex][2*k+i];

685 
} 
686  
687 
/* run standard IMDCT */

688 
s>imdct_256.fft.imdct_calc(&s>imdct_256, o_ptr, x, s>tmp_imdct); 
689  
690 
/* reverse the postrotation & reordering from standard IMDCT */

691 
for(k=0; k<32; k++) { 
692 
z[i][32+k].re = o_ptr[128+2*k]; 
693 
z[i][32+k].im = o_ptr[2*k]; 
694 
z[i][31k].re = o_ptr[2*k+1]; 
695 
z[i][31k].im = o_ptr[128+2*k+1]; 
696 
} 
697 
} 
698  
699 
/* apply AC3 postrotation & reordering */

700 
for(k=0; k<64; k++) { 
701 
o_ptr[ 2*k ] = z[0][ k].im; 
702 
o_ptr[ 2*k+1] = z[0][63k].re; 
703 
o_ptr[128+2*k ] = z[0][ k].re; 
704 
o_ptr[128+2*k+1] = z[0][63k].im; 
705 
o_ptr[256+2*k ] = z[1][ k].re; 
706 
o_ptr[256+2*k+1] = z[1][63k].im; 
707 
o_ptr[384+2*k ] = z[1][ k].im; 
708 
o_ptr[384+2*k+1] = z[1][63k].re; 
709 
} 
710 
} 
711  
712 
/**

713 
* Inverse MDCT Transform.

714 
* Convert frequency domain coefficients to timedomain audio samples.

715 
* reference: Section 7.9.4 Transformation Equations

716 
*/

717 
static inline void do_imdct(AC3DecodeContext *s, int channels) 
718 
{ 
719 
int ch;

720  
721 
for (ch=1; ch<=channels; ch++) { 
722 
if (s>block_switch[ch]) {

723 
do_imdct_256(s, ch); 
724 
} else {

725 
s>imdct_512.fft.imdct_calc(&s>imdct_512, s>tmp_output, 
726 
s>transform_coeffs[ch], s>tmp_imdct); 
727 
} 
728 
/* For the first half of the block, apply the window, add the delay

729 
from the previous block, and send to output */

730 
s>dsp.vector_fmul_add_add(s>output[ch1], s>tmp_output,

731 
s>window, s>delay[ch1], 0, 256, 1); 
732 
/* For the second half of the block, apply the window and store the

733 
samples to delay, to be combined with the next block */

734 
s>dsp.vector_fmul_reverse(s>delay[ch1], s>tmp_output+256, 
735 
s>window, 256);

736 
} 
737 
} 
738  
739 
/**

740 
* Downmix the output to mono or stereo.

741 
*/

742 
static void ac3_downmix(AC3DecodeContext *s, 
743 
float samples[AC3_MAX_CHANNELS][256], int ch_offset) 
744 
{ 
745 
int i, j;

746 
float v0, v1;

747  
748 
for(i=0; i<256; i++) { 
749 
v0 = v1 = 0.0f; 
750 
for(j=0; j<s>fbw_channels; j++) { 
751 
v0 += samples[j+ch_offset][i] * s>downmix_coeffs[j][0];

752 
v1 += samples[j+ch_offset][i] * s>downmix_coeffs[j][1];

753 
} 
754 
v0 *= s>downmix_coeff_adjust[0];

755 
v1 *= s>downmix_coeff_adjust[1];

756 
if(s>output_mode == AC3_CHMODE_MONO) {

757 
samples[ch_offset][i] = (v0 + v1) * LEVEL_MINUS_3DB; 
758 
} else if(s>output_mode == AC3_CHMODE_STEREO) { 
759 
samples[ ch_offset][i] = v0; 
760 
samples[1+ch_offset][i] = v1;

761 
} 
762 
} 
763 
} 
764  
765 
/**

766 
* Upmix delay samples from stereo to original channel layout.

767 
*/

768 
static void ac3_upmix_delay(AC3DecodeContext *s) 
769 
{ 
770 
int channel_data_size = sizeof(s>delay[0]); 
771 
switch(s>channel_mode) {

772 
case AC3_CHMODE_DUALMONO:

773 
case AC3_CHMODE_STEREO:

774 
/* upmix mono to stereo */

775 
memcpy(s>delay[1], s>delay[0], channel_data_size); 
776 
break;

777 
case AC3_CHMODE_2F2R:

778 
memset(s>delay[3], 0, channel_data_size); 
779 
case AC3_CHMODE_2F1R:

780 
memset(s>delay[2], 0, channel_data_size); 
781 
break;

782 
case AC3_CHMODE_3F2R:

783 
memset(s>delay[4], 0, channel_data_size); 
784 
case AC3_CHMODE_3F1R:

785 
memset(s>delay[3], 0, channel_data_size); 
786 
case AC3_CHMODE_3F:

787 
memcpy(s>delay[2], s>delay[1], channel_data_size); 
788 
memset(s>delay[1], 0, channel_data_size); 
789 
break;

790 
} 
791 
} 
792  
793 
/**

794 
* Parse an audio block from AC3 bitstream.

795 
*/

796 
static int ac3_parse_audio_block(AC3DecodeContext *s, int blk) 
797 
{ 
798 
int fbw_channels = s>fbw_channels;

799 
int channel_mode = s>channel_mode;

800 
int i, bnd, seg, ch;

801 
int different_transforms;

802 
int downmix_output;

803 
GetBitContext *gbc = &s>gbc; 
804 
uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; 
805  
806 
memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

807  
808 
/* block switch flags */

809 
different_transforms = 0;

810 
for (ch = 1; ch <= fbw_channels; ch++) { 
811 
s>block_switch[ch] = get_bits1(gbc); 
812 
if(ch > 1 && s>block_switch[ch] != s>block_switch[1]) 
813 
different_transforms = 1;

814 
} 
815  
816 
/* dithering flags */

817 
s>dither_all = 1;

818 
for (ch = 1; ch <= fbw_channels; ch++) { 
819 
s>dither_flag[ch] = get_bits1(gbc); 
820 
if(!s>dither_flag[ch])

821 
s>dither_all = 0;

822 
} 
823  
824 
/* dynamic range */

825 
i = !(s>channel_mode); 
826 
do {

827 
if(get_bits1(gbc)) {

828 
s>dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]1.0) * 
829 
s>avctx>drc_scale)+1.0; 
830 
} else if(blk == 0) { 
831 
s>dynamic_range[i] = 1.0f; 
832 
} 
833 
} while(i);

834  
835 
/* coupling strategy */

836 
if (get_bits1(gbc)) {

837 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

838 
s>cpl_in_use = get_bits1(gbc); 
839 
if (s>cpl_in_use) {

840 
/* coupling in use */

841 
int cpl_begin_freq, cpl_end_freq;

842  
843 
/* determine which channels are coupled */

844 
for (ch = 1; ch <= fbw_channels; ch++) 
845 
s>channel_in_cpl[ch] = get_bits1(gbc); 
846  
847 
/* phase flags in use */

848 
if (channel_mode == AC3_CHMODE_STEREO)

849 
s>phase_flags_in_use = get_bits1(gbc); 
850  
851 
/* coupling frequency range and band structure */

852 
cpl_begin_freq = get_bits(gbc, 4);

853 
cpl_end_freq = get_bits(gbc, 4);

854 
if (3 + cpl_end_freq  cpl_begin_freq < 0) { 
855 
av_log(s>avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq); 
856 
return 1; 
857 
} 
858 
s>num_cpl_bands = s>num_cpl_subbands = 3 + cpl_end_freq  cpl_begin_freq;

859 
s>start_freq[CPL_CH] = cpl_begin_freq * 12 + 37; 
860 
s>end_freq[CPL_CH] = cpl_end_freq * 12 + 73; 
861 
for (bnd = 0; bnd < s>num_cpl_subbands  1; bnd++) { 
862 
if (get_bits1(gbc)) {

863 
s>cpl_band_struct[bnd] = 1;

864 
s>num_cpl_bands; 
865 
} 
866 
} 
867 
s>cpl_band_struct[s>num_cpl_subbands1] = 0; 
868 
} else {

869 
/* coupling not in use */

870 
for (ch = 1; ch <= fbw_channels; ch++) 
871 
s>channel_in_cpl[ch] = 0;

872 
} 
873 
} 
874  
875 
/* coupling coordinates */

876 
if (s>cpl_in_use) {

877 
int cpl_coords_exist = 0; 
878  
879 
for (ch = 1; ch <= fbw_channels; ch++) { 
880 
if (s>channel_in_cpl[ch]) {

881 
if (get_bits1(gbc)) {

882 
int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;

883 
cpl_coords_exist = 1;

884 
master_cpl_coord = 3 * get_bits(gbc, 2); 
885 
for (bnd = 0; bnd < s>num_cpl_bands; bnd++) { 
886 
cpl_coord_exp = get_bits(gbc, 4);

887 
cpl_coord_mant = get_bits(gbc, 4);

888 
if (cpl_coord_exp == 15) 
889 
s>cpl_coords[ch][bnd] = cpl_coord_mant << 22;

890 
else

891 
s>cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21; 
892 
s>cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord); 
893 
} 
894 
} 
895 
} 
896 
} 
897 
/* phase flags */

898 
if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {

899 
for (bnd = 0; bnd < s>num_cpl_bands; bnd++) { 
900 
s>phase_flags[bnd] = s>phase_flags_in_use? get_bits1(gbc) : 0;

901 
} 
902 
} 
903 
} 
904  
905 
/* stereo rematrixing strategy and band structure */

906 
if (channel_mode == AC3_CHMODE_STEREO) {

907 
if (get_bits1(gbc)) {

908 
s>num_rematrixing_bands = 4;

909 
if(s>cpl_in_use && s>start_freq[CPL_CH] <= 61) 
910 
s>num_rematrixing_bands = 1 + (s>start_freq[CPL_CH] == 37); 
911 
for(bnd=0; bnd<s>num_rematrixing_bands; bnd++) 
912 
s>rematrixing_flags[bnd] = get_bits1(gbc); 
913 
} 
914 
} 
915  
916 
/* exponent strategies for each channel */

917 
s>exp_strategy[CPL_CH] = EXP_REUSE; 
918 
s>exp_strategy[s>lfe_ch] = EXP_REUSE; 
919 
for (ch = !s>cpl_in_use; ch <= s>channels; ch++) {

920 
if(ch == s>lfe_ch)

921 
s>exp_strategy[ch] = get_bits(gbc, 1);

922 
else

923 
s>exp_strategy[ch] = get_bits(gbc, 2);

924 
if(s>exp_strategy[ch] != EXP_REUSE)

925 
bit_alloc_stages[ch] = 3;

926 
} 
927  
928 
/* channel bandwidth */

929 
for (ch = 1; ch <= fbw_channels; ch++) { 
930 
s>start_freq[ch] = 0;

931 
if (s>exp_strategy[ch] != EXP_REUSE) {

932 
int prev = s>end_freq[ch];

933 
if (s>channel_in_cpl[ch])

934 
s>end_freq[ch] = s>start_freq[CPL_CH]; 
935 
else {

936 
int bandwidth_code = get_bits(gbc, 6); 
937 
if (bandwidth_code > 60) { 
938 
av_log(s>avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);

939 
return 1; 
940 
} 
941 
s>end_freq[ch] = bandwidth_code * 3 + 73; 
942 
} 
943 
if(blk > 0 && s>end_freq[ch] != prev) 
944 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

945 
} 
946 
} 
947 
s>start_freq[s>lfe_ch] = 0;

948 
s>end_freq[s>lfe_ch] = 7;

949  
950 
/* decode exponents for each channel */

951 
for (ch = !s>cpl_in_use; ch <= s>channels; ch++) {

952 
if (s>exp_strategy[ch] != EXP_REUSE) {

953 
int group_size, num_groups;

954 
group_size = 3 << (s>exp_strategy[ch]  1); 
955 
if(ch == CPL_CH)

956 
num_groups = (s>end_freq[ch]  s>start_freq[ch]) / group_size; 
957 
else if(ch == s>lfe_ch) 
958 
num_groups = 2;

959 
else

960 
num_groups = (s>end_freq[ch] + group_size  4) / group_size;

961 
s>dexps[ch][0] = get_bits(gbc, 4) << !ch; 
962 
decode_exponents(gbc, s>exp_strategy[ch], num_groups, s>dexps[ch][0],

963 
&s>dexps[ch][s>start_freq[ch]+!!ch]); 
964 
if(ch != CPL_CH && ch != s>lfe_ch)

965 
skip_bits(gbc, 2); /* skip gainrng */ 
966 
} 
967 
} 
968  
969 
/* bit allocation information */

970 
if (get_bits1(gbc)) {

971 
s>bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s>bit_alloc_params.sr_shift;

972 
s>bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s>bit_alloc_params.sr_shift;

973 
s>bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];

974 
s>bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];

975 
s>bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];

976 
for(ch=!s>cpl_in_use; ch<=s>channels; ch++) {

977 
bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

978 
} 
979 
} 
980  
981 
/* signaltonoise ratio offsets and fast gains (signaltomask ratios) */

982 
if (get_bits1(gbc)) {

983 
int csnr;

984 
csnr = (get_bits(gbc, 6)  15) << 4; 
985 
for (ch = !s>cpl_in_use; ch <= s>channels; ch++) { /* snr offset and fast gain */ 
986 
s>snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2; 
987 
s>fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];

988 
} 
989 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

990 
} 
991  
992 
/* coupling leak information */

993 
if (s>cpl_in_use && get_bits1(gbc)) {

994 
s>bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);

995 
s>bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);

996 
bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);

997 
} 
998  
999 
/* delta bit allocation information */

1000 
if (get_bits1(gbc)) {

1001 
/* delta bit allocation exists (strategy) */

1002 
for (ch = !s>cpl_in_use; ch <= fbw_channels; ch++) {

1003 
s>dba_mode[ch] = get_bits(gbc, 2);

1004 
if (s>dba_mode[ch] == DBA_RESERVED) {

1005 
av_log(s>avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");

1006 
return 1; 
1007 
} 
1008 
bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

1009 
} 
1010 
/* channel delta offset, len and bit allocation */

1011 
for (ch = !s>cpl_in_use; ch <= fbw_channels; ch++) {

1012 
if (s>dba_mode[ch] == DBA_NEW) {

1013 
s>dba_nsegs[ch] = get_bits(gbc, 3);

1014 
for (seg = 0; seg <= s>dba_nsegs[ch]; seg++) { 
1015 
s>dba_offsets[ch][seg] = get_bits(gbc, 5);

1016 
s>dba_lengths[ch][seg] = get_bits(gbc, 4);

1017 
s>dba_values[ch][seg] = get_bits(gbc, 3);

1018 
} 
1019 
} 
1020 
} 
1021 
} else if(blk == 0) { 
1022 
for(ch=0; ch<=s>channels; ch++) { 
1023 
s>dba_mode[ch] = DBA_NONE; 
1024 
} 
1025 
} 
1026  
1027 
/* Bit allocation */

1028 
for(ch=!s>cpl_in_use; ch<=s>channels; ch++) {

1029 
if(bit_alloc_stages[ch] > 2) { 
1030 
/* Exponent mapping into PSD and PSD integration */

1031 
ff_ac3_bit_alloc_calc_psd(s>dexps[ch], 
1032 
s>start_freq[ch], s>end_freq[ch], 
1033 
s>psd[ch], s>band_psd[ch]); 
1034 
} 
1035 
if(bit_alloc_stages[ch] > 1) { 
1036 
/* Compute excitation function, Compute masking curve, and

1037 
Apply delta bit allocation */

1038 
ff_ac3_bit_alloc_calc_mask(&s>bit_alloc_params, s>band_psd[ch], 
1039 
s>start_freq[ch], s>end_freq[ch], 
1040 
s>fast_gain[ch], (ch == s>lfe_ch), 
1041 
s>dba_mode[ch], s>dba_nsegs[ch], 
1042 
s>dba_offsets[ch], s>dba_lengths[ch], 
1043 
s>dba_values[ch], s>mask[ch]); 
1044 
} 
1045 
if(bit_alloc_stages[ch] > 0) { 
1046 
/* Compute bit allocation */

1047 
ff_ac3_bit_alloc_calc_bap(s>mask[ch], s>psd[ch], 
1048 
s>start_freq[ch], s>end_freq[ch], 
1049 
s>snr_offset[ch], 
1050 
s>bit_alloc_params.floor, 
1051 
s>bap[ch]); 
1052 
} 
1053 
} 
1054  
1055 
/* unused dummy data */

1056 
if (get_bits1(gbc)) {

1057 
int skipl = get_bits(gbc, 9); 
1058 
while(skipl)

1059 
skip_bits(gbc, 8);

1060 
} 
1061  
1062 
/* unpack the transform coefficients

1063 
this also uncouples channels if coupling is in use. */

1064 
if (get_transform_coeffs(s)) {

1065 
av_log(s>avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");

1066 
return 1; 
1067 
} 
1068  
1069 
/* recover coefficients if rematrixing is in use */

1070 
if(s>channel_mode == AC3_CHMODE_STEREO)

1071 
do_rematrixing(s); 
1072  
1073 
/* apply scaling to coefficients (headroom, dynrng) */

1074 
for(ch=1; ch<=s>channels; ch++) { 
1075 
float gain = s>mul_bias / 4194304.0f; 
1076 
if(s>channel_mode == AC3_CHMODE_DUALMONO) {

1077 
gain *= s>dynamic_range[ch1];

1078 
} else {

1079 
gain *= s>dynamic_range[0];

1080 
} 
1081 
for(i=0; i<256; i++) { 
1082 
s>transform_coeffs[ch][i] = s>fixed_coeffs[ch][i] * gain; 
1083 
} 
1084 
} 
1085  
1086 
/* downmix and MDCT. order depends on whether block switching is used for

1087 
any channel in this block. this is because coefficients for the long

1088 
and short transforms cannot be mixed. */

1089 
downmix_output = s>channels != s>out_channels && 
1090 
!((s>output_mode & AC3_OUTPUT_LFEON) && 
1091 
s>fbw_channels == s>out_channels); 
1092 
if(different_transforms) {

1093 
/* the delay samples have already been downmixed, so we upmix the delay

1094 
samples in order to reconstruct all channels before downmixing. */

1095 
if(s>downmixed) {

1096 
s>downmixed = 0;

1097 
ac3_upmix_delay(s); 
1098 
} 
1099  
1100 
do_imdct(s, s>channels); 
1101  
1102 
if(downmix_output) {

1103 
ac3_downmix(s, s>output, 0);

1104 
} 
1105 
} else {

1106 
if(downmix_output) {

1107 
ac3_downmix(s, s>transform_coeffs, 1);

1108 
} 
1109  
1110 
if(!s>downmixed) {

1111 
s>downmixed = 1;

1112 
ac3_downmix(s, s>delay, 0);

1113 
} 
1114  
1115 
do_imdct(s, s>out_channels); 
1116 
} 
1117  
1118 
/* convert float to 16bit integer */

1119 
for(ch=0; ch<s>out_channels; ch++) { 
1120 
for(i=0; i<256; i++) { 
1121 
s>output[ch][i] += s>add_bias; 
1122 
} 
1123 
s>dsp.float_to_int16(s>int_output[ch], s>output[ch], 256);

1124 
} 
1125  
1126 
return 0; 
1127 
} 
1128  
1129 
/**

1130 
* Decode a single AC3 frame.

1131 
*/

1132 
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, 
1133 
const uint8_t *buf, int buf_size) 
1134 
{ 
1135 
AC3DecodeContext *s = avctx>priv_data; 
1136 
int16_t *out_samples = (int16_t *)data; 
1137 
int i, blk, ch, err;

1138  
1139 
/* initialize the GetBitContext with the start of valid AC3 Frame */

1140 
if(avctx>error_resilience >= FF_ER_CAREFUL) {

1141 
/* copy input buffer to decoder context to avoid reading past the end

1142 
of the buffer, which can be caused by a damaged input stream. */

1143 
memcpy(s>input_buffer, buf, FFMIN(buf_size, AC3_MAX_FRAME_SIZE)); 
1144 
init_get_bits(&s>gbc, s>input_buffer, buf_size * 8);

1145 
} else {

1146 
init_get_bits(&s>gbc, buf, buf_size * 8);

1147 
} 
1148  
1149 
/* parse the syncinfo */

1150 
err = ac3_parse_header(s); 
1151 
if(err) {

1152 
switch(err) {

1153 
case AC3_PARSE_ERROR_SYNC:

1154 
av_log(avctx, AV_LOG_ERROR, "frame sync error\n");

1155 
break;

1156 
case AC3_PARSE_ERROR_BSID:

1157 
av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");

1158 
break;

1159 
case AC3_PARSE_ERROR_SAMPLE_RATE:

1160 
av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");

1161 
break;

1162 
case AC3_PARSE_ERROR_FRAME_SIZE:

1163 
av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");

1164 
break;

1165 
case AC3_PARSE_ERROR_STREAM_TYPE:

1166 
av_log(avctx, AV_LOG_ERROR, "invalid stream type\n");

1167 
break;

1168 
default:

1169 
av_log(avctx, AV_LOG_ERROR, "invalid header\n");

1170 
break;

1171 
} 
1172 
return 1; 
1173 
} 
1174  
1175 
/* check that reported frame size fits in input buffer */

1176 
if(s>frame_size > buf_size) {

1177 
av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");

1178 
return 1; 
1179 
} 
1180  
1181 
/* check for crc mismatch */

1182 
if(avctx>error_resilience >= FF_ER_CAREFUL) {

1183 
if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s>frame_size2)) { 
1184 
av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");

1185 
return 1; 
1186 
} 
1187 
/* TODO: error concealment */

1188 
} 
1189  
1190 
avctx>sample_rate = s>sample_rate; 
1191 
avctx>bit_rate = s>bit_rate; 
1192  
1193 
/* channel config */

1194 
s>out_channels = s>channels; 
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; 
1201  
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 
} 
1207  
1208 
/* parse the audio blocks */

1209 
for (blk = 0; blk < NB_BLOCKS; blk++) { 
1210 
if (ac3_parse_audio_block(s, blk)) {

1211 
av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");

1212 
*data_size = 0;

1213 
return s>frame_size;

1214 
} 
1215 
for (i = 0; i < 256; i++) 
1216 
for (ch = 0; ch < s>out_channels; ch++) 
1217 
*(out_samples++) = s>int_output[ch][i]; 
1218 
} 
1219 
*data_size = NB_BLOCKS * 256 * avctx>channels * sizeof (int16_t); 
1220 
return s>frame_size;

1221 
} 
1222  
1223 
/**

1224 
* Uninitialize the AC3 decoder.

1225 
*/

1226 
static av_cold int ac3_decode_end(AVCodecContext *avctx) 
1227 
{ 
1228 
AC3DecodeContext *s = avctx>priv_data; 
1229 
ff_mdct_end(&s>imdct_512); 
1230 
ff_mdct_end(&s>imdct_256); 
1231  
1232 
return 0; 
1233 
} 
1234  
1235 
AVCodec ac3_decoder = { 
1236 
.name = "ac3",

1237 
.type = CODEC_TYPE_AUDIO, 
1238 
.id = CODEC_ID_AC3, 
1239 
.priv_data_size = sizeof (AC3DecodeContext),

1240 
.init = ac3_decode_init, 
1241 
.close = ac3_decode_end, 
1242 
.decode = ac3_decode_frame, 
1243 
}; 