ffmpeg / libavcodec / ac3dec.c @ f0b3a7ba
History  View  Annotate  Download (40.7 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 
/**

43 
* Table of bin locations for rematrixing bands

44 
* reference: Section 7.5.2 Rematrixing : Frequency Band Definitions

45 
*/

46 
static const uint8_t rematrix_band_tab[5] = { 13, 25, 37, 61, 253 }; 
47  
48 
/**

49 
* table for exponent to scale_factor mapping

50 
* scale_factors[i] = 2 ^ i

51 
*/

52 
static float scale_factors[25]; 
53  
54 
/** table for grouping exponents */

55 
static uint8_t exp_ungroup_tab[128][3]; 
56  
57  
58 
/** tables for ungrouping mantissas */

59 
static float b1_mantissas[32][3]; 
60 
static float b2_mantissas[128][3]; 
61 
static float b3_mantissas[8]; 
62 
static float b4_mantissas[128][2]; 
63 
static float b5_mantissas[16]; 
64  
65 
/**

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

67 
* reference: Table 7.18 Mapping of bap to Quantizer

68 
*/

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

75 
static float dynamic_range_tab[256]; 
76  
77 
/** Adjustments in dB gain */

78 
#define LEVEL_MINUS_3DB 0.7071067811865476 
79 
#define LEVEL_MINUS_4POINT5DB 0.5946035575013605 
80 
#define LEVEL_MINUS_6DB 0.5000000000000000 
81 
#define LEVEL_MINUS_9DB 0.3535533905932738 
82 
#define LEVEL_ZERO 0.0000000000000000 
83 
#define LEVEL_ONE 1.0000000000000000 
84  
85 
static const float gain_levels[6] = { 
86 
LEVEL_ZERO, 
87 
LEVEL_ONE, 
88 
LEVEL_MINUS_3DB, 
89 
LEVEL_MINUS_4POINT5DB, 
90 
LEVEL_MINUS_6DB, 
91 
LEVEL_MINUS_9DB 
92 
}; 
93  
94 
/**

95 
* Table for center mix levels

96 
* reference: Section 5.4.2.4 cmixlev

97 
*/

98 
static const uint8_t center_levels[4] = { 2, 3, 4, 3 }; 
99  
100 
/**

101 
* Table for surround mix levels

102 
* reference: Section 5.4.2.5 surmixlev

103 
*/

104 
static const uint8_t surround_levels[4] = { 2, 4, 0, 4 }; 
105  
106 
/**

107 
* Table for default stereo downmixing coefficients

108 
* reference: Section 7.8.2 Downmixing Into Two Channels

109 
*/

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

122 
#undef AC3_MAX_CHANNELS

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

170  
171 
int8_t dexps[AC3_MAX_CHANNELS][256]; ///< decoded exponents 
172 
uint8_t bap[AC3_MAX_CHANNELS][256]; ///< bit allocation pointers 
173 
int16_t psd[AC3_MAX_CHANNELS][256]; ///< scaled exponents 
174 
int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents 
175 
int16_t mask[AC3_MAX_CHANNELS][50]; ///< masking curve values 
176  
177 
DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); ///< transform coefficients 
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_CHANNELS1][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_CHANNELS1][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 
} AC3DecodeContext; 
198  
199 
/**

200 
* Generate a KaiserBessel Derived Window.

201 
*/

202 
static void ac3_window_init(float *window) 
203 
{ 
204 
int i, j;

205 
double sum = 0.0, bessel, tmp; 
206 
double local_window[256]; 
207 
double alpha2 = (5.0 * M_PI / 256.0) * (5.0 * M_PI / 256.0); 
208  
209 
for (i = 0; i < 256; i++) { 
210 
tmp = i * (256  i) * alpha2;

211 
bessel = 1.0; 
212 
for (j = 100; j > 0; j) /* default to 100 iterations */ 
213 
bessel = bessel * tmp / (j * j) + 1;

214 
sum += bessel; 
215 
local_window[i] = sum; 
216 
} 
217  
218 
sum++; 
219 
for (i = 0; i < 256; i++) 
220 
window[i] = sqrt(local_window[i] / sum); 
221 
} 
222  
223 
/**

224 
* Symmetrical Dequantization

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

226 
* Tables 7.19 to 7.23

227 
*/

228 
static inline float 
229 
symmetric_dequant(int code, int levels) 
230 
{ 
231 
return (code  (levels >> 1)) * (2.0f / levels); 
232 
} 
233  
234 
/*

235 
* Initialize tables at runtime.

236 
*/

237 
static void ac3_tables_init(void) 
238 
{ 
239 
int i;

240  
241 
/* generate grouped mantissa tables

242 
reference: Section 7.3.5 Ungrouping of Mantissas */

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

245 
b1_mantissas[i][0] = symmetric_dequant( i / 9 , 3); 
246 
b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3); 
247 
b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3); 
248 
} 
249 
for(i=0; i<128; i++) { 
250 
/* bap=2 mantissas */

251 
b2_mantissas[i][0] = symmetric_dequant( i / 25 , 5); 
252 
b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5); 
253 
b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5); 
254  
255 
/* bap=4 mantissas */

256 
b4_mantissas[i][0] = symmetric_dequant(i / 11, 11); 
257 
b4_mantissas[i][1] = symmetric_dequant(i % 11, 11); 
258 
} 
259 
/* generate ungrouped mantissa tables

260 
reference: Tables 7.21 and 7.23 */

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

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

264 
} 
265 
for(i=0; i<15; i++) { 
266 
/* bap=5 mantissas */

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

268 
} 
269  
270 
/* generate dynamic range table

271 
reference: Section 7.7.1 Dynamic Range Control */

272 
for(i=0; i<256; i++) { 
273 
int v = (i >> 5)  ((i >> 7) << 3)  5; 
274 
dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F)  0x20); 
275 
} 
276  
277 
/* generate scale factors for exponents and asymmetrical dequantization

278 
reference: Section 7.3.2 Expansion of Mantissas for Asymmetric Quantization */

279 
for (i = 0; i < 25; i++) 
280 
scale_factors[i] = pow(2.0, i); 
281  
282 
/* generate exponent tables

283 
reference: Section 7.1.3 Exponent Decoding */

284 
for(i=0; i<128; i++) { 
285 
exp_ungroup_tab[i][0] = i / 25; 
286 
exp_ungroup_tab[i][1] = (i % 25) / 5; 
287 
exp_ungroup_tab[i][2] = (i % 25) % 5; 
288 
} 
289 
} 
290  
291  
292 
/**

293 
* AVCodec initialization

294 
*/

295 
static int ac3_decode_init(AVCodecContext *avctx) 
296 
{ 
297 
AC3DecodeContext *s = avctx>priv_data; 
298 
s>avctx = avctx; 
299  
300 
ac3_common_init(); 
301 
ac3_tables_init(); 
302 
ff_mdct_init(&s>imdct_256, 8, 1); 
303 
ff_mdct_init(&s>imdct_512, 9, 1); 
304 
ac3_window_init(s>window); 
305 
dsputil_init(&s>dsp, avctx); 
306 
av_init_random(0, &s>dith_state);

307  
308 
/* set bias values for float to int16 conversion */

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

310 
s>add_bias = 385.0f; 
311 
s>mul_bias = 1.0f; 
312 
} else {

313 
s>add_bias = 0.0f; 
314 
s>mul_bias = 32767.0f; 
315 
} 
316  
317 
/* allow downmixing to stereo or mono */

318 
if (avctx>channels > 0 && avctx>request_channels > 0 && 
319 
avctx>request_channels < avctx>channels && 
320 
avctx>request_channels <= 2) {

321 
avctx>channels = avctx>request_channels; 
322 
} 
323  
324 
return 0; 
325 
} 
326  
327 
/**

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

329 
* GetBitContext within AC3DecodeContext must point to

330 
* start of the synchronized ac3 bitstream.

331 
*/

332 
static int ac3_parse_header(AC3DecodeContext *s) 
333 
{ 
334 
AC3HeaderInfo hdr; 
335 
GetBitContext *gbc = &s>gbc; 
336 
int err, i;

337  
338 
err = ff_ac3_parse_header(gbc>buffer, &hdr); 
339 
if(err)

340 
return err;

341  
342 
if(hdr.bitstream_id > 10) 
343 
return AC3_PARSE_ERROR_BSID;

344  
345 
/* get decoding parameters from header info */

346 
s>bit_alloc_params.sr_code = hdr.sr_code; 
347 
s>channel_mode = hdr.channel_mode; 
348 
s>lfe_on = hdr.lfe_on; 
349 
s>bit_alloc_params.sr_shift = hdr.sr_shift; 
350 
s>sample_rate = hdr.sample_rate; 
351 
s>bit_rate = hdr.bit_rate; 
352 
s>channels = hdr.channels; 
353 
s>fbw_channels = s>channels  s>lfe_on; 
354 
s>lfe_ch = s>fbw_channels + 1;

355 
s>frame_size = hdr.frame_size; 
356  
357 
/* set default output to all source channels */

358 
s>out_channels = s>channels; 
359 
s>output_mode = s>channel_mode; 
360 
if(s>lfe_on)

361 
s>output_mode = AC3_OUTPUT_LFEON; 
362  
363 
/* set default mix levels */

364 
s>center_mix_level = 3; // 4.5dB 
365 
s>surround_mix_level = 4; // 6.0dB 
366  
367 
/* skip over portion of header which has already been read */

368 
skip_bits(gbc, 16); // skip the sync_word 
369 
skip_bits(gbc, 16); // skip crc1 
370 
skip_bits(gbc, 8); // skip fscod and frmsizecod 
371 
skip_bits(gbc, 11); // skip bsid, bsmod, and acmod 
372 
if(s>channel_mode == AC3_CHMODE_STEREO) {

373 
skip_bits(gbc, 2); // skip dsurmod 
374 
} else {

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

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

379 
} 
380 
skip_bits1(gbc); // skip lfeon

381  
382 
/* read the rest of the bsi. read twice for dual mono mode. */

383 
i = !(s>channel_mode); 
384 
do {

385 
skip_bits(gbc, 5); // skip dialog normalization 
386 
if (get_bits1(gbc))

387 
skip_bits(gbc, 8); //skip compression 
388 
if (get_bits1(gbc))

389 
skip_bits(gbc, 8); //skip language code 
390 
if (get_bits1(gbc))

391 
skip_bits(gbc, 7); //skip audio production information 
392 
} while (i);

393  
394 
skip_bits(gbc, 2); //skip copyright bit and original bitstream bit 
395  
396 
/* skip the timecodes (or extra bitstream information for Alternate Syntax)

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

398 
if (get_bits1(gbc))

399 
skip_bits(gbc, 14); //skip timecode1 / xbsi1 
400 
if (get_bits1(gbc))

401 
skip_bits(gbc, 14); //skip timecode2 / xbsi2 
402  
403 
/* skip additional bitstream info */

404 
if (get_bits1(gbc)) {

405 
i = get_bits(gbc, 6);

406 
do {

407 
skip_bits(gbc, 8);

408 
} while(i);

409 
} 
410  
411 
return 0; 
412 
} 
413  
414 
/**

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

416 
* reference: Section 7.8.2 Downmixing Into Two Channels

417 
*/

418 
static void set_downmix_coeffs(AC3DecodeContext *s) 
419 
{ 
420 
int i;

421 
float cmix = gain_levels[s>center_mix_level];

422 
float smix = gain_levels[s>surround_mix_level];

423  
424 
for(i=0; i<s>fbw_channels; i++) { 
425 
s>downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s>channel_mode][i][0]]; 
426 
s>downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s>channel_mode][i][1]]; 
427 
} 
428 
if(s>channel_mode > 1 && s>channel_mode & 1) { 
429 
s>downmix_coeffs[1][0] = s>downmix_coeffs[1][1] = cmix; 
430 
} 
431 
if(s>channel_mode == AC3_CHMODE_2F1R  s>channel_mode == AC3_CHMODE_3F1R) {

432 
int nf = s>channel_mode  2; 
433 
s>downmix_coeffs[nf][0] = s>downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB; 
434 
} 
435 
if(s>channel_mode == AC3_CHMODE_2F2R  s>channel_mode == AC3_CHMODE_3F2R) {

436 
int nf = s>channel_mode  4; 
437 
s>downmix_coeffs[nf][0] = s>downmix_coeffs[nf+1][1] = smix; 
438 
} 
439 
} 
440  
441 
/**

442 
* Decode the grouped exponents according to exponent strategy.

443 
* reference: Section 7.1.3 Exponent Decoding

444 
*/

445 
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, 
446 
uint8_t absexp, int8_t *dexps) 
447 
{ 
448 
int i, j, grp, group_size;

449 
int dexp[256]; 
450 
int expacc, prevexp;

451  
452 
/* unpack groups */

453 
group_size = exp_strategy + (exp_strategy == EXP_D45); 
454 
for(grp=0,i=0; grp<ngrps; grp++) { 
455 
expacc = get_bits(gbc, 7);

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

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

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

459 
} 
460  
461 
/* convert to absolute exps and expand groups */

462 
prevexp = absexp; 
463 
for(i=0; i<ngrps*3; i++) { 
464 
prevexp = av_clip(prevexp + dexp[i]2, 0, 24); 
465 
for(j=0; j<group_size; j++) { 
466 
dexps[(i*group_size)+j] = prevexp; 
467 
} 
468 
} 
469 
} 
470  
471 
/**

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

473 
* range using the coupling coefficients and coupling coordinates.

474 
* reference: Section 7.4.3 Coupling Coordinate Format

475 
*/

476 
static void uncouple_channels(AC3DecodeContext *s) 
477 
{ 
478 
int i, j, ch, bnd, subbnd;

479  
480 
subbnd = 1;

481 
i = s>start_freq[CPL_CH]; 
482 
for(bnd=0; bnd<s>num_cpl_bands; bnd++) { 
483 
do {

484 
subbnd++; 
485 
for(j=0; j<12; j++) { 
486 
for(ch=1; ch<=s>fbw_channels; ch++) { 
487 
if(s>channel_in_cpl[ch]) {

488 
s>transform_coeffs[ch][i] = s>transform_coeffs[CPL_CH][i] * s>cpl_coords[ch][bnd] * 8.0f; 
489 
if (ch == 2 && s>phase_flags[bnd]) 
490 
s>transform_coeffs[ch][i] = s>transform_coeffs[ch][i]; 
491 
} 
492 
} 
493 
i++; 
494 
} 
495 
} while(s>cpl_band_struct[subbnd]);

496 
} 
497 
} 
498  
499 
/**

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

501 
*/

502 
typedef struct { 
503 
float b1_mant[3]; 
504 
float b2_mant[3]; 
505 
float b4_mant[2]; 
506 
int b1ptr;

507 
int b2ptr;

508 
int b4ptr;

509 
} mant_groups; 
510  
511 
/**

512 
* Get the transform coefficients for a particular channel

513 
* reference: Section 7.3 Quantization and Decoding of Mantissas

514 
*/

515 
static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) 
516 
{ 
517 
GetBitContext *gbc = &s>gbc; 
518 
int i, gcode, tbap, start, end;

519 
uint8_t *exps; 
520 
uint8_t *bap; 
521 
float *coeffs;

522  
523 
exps = s>dexps[ch_index]; 
524 
bap = s>bap[ch_index]; 
525 
coeffs = s>transform_coeffs[ch_index]; 
526 
start = s>start_freq[ch_index]; 
527 
end = s>end_freq[ch_index]; 
528  
529 
for (i = start; i < end; i++) {

530 
tbap = bap[i]; 
531 
switch (tbap) {

532 
case 0: 
533 
coeffs[i] = ((av_random(&s>dith_state) & 0xFFFF) / 65535.0f)  0.5f; 
534 
break;

535  
536 
case 1: 
537 
if(m>b1ptr > 2) { 
538 
gcode = get_bits(gbc, 5);

539 
m>b1_mant[0] = b1_mantissas[gcode][0]; 
540 
m>b1_mant[1] = b1_mantissas[gcode][1]; 
541 
m>b1_mant[2] = b1_mantissas[gcode][2]; 
542 
m>b1ptr = 0;

543 
} 
544 
coeffs[i] = m>b1_mant[m>b1ptr++]; 
545 
break;

546  
547 
case 2: 
548 
if(m>b2ptr > 2) { 
549 
gcode = get_bits(gbc, 7);

550 
m>b2_mant[0] = b2_mantissas[gcode][0]; 
551 
m>b2_mant[1] = b2_mantissas[gcode][1]; 
552 
m>b2_mant[2] = b2_mantissas[gcode][2]; 
553 
m>b2ptr = 0;

554 
} 
555 
coeffs[i] = m>b2_mant[m>b2ptr++]; 
556 
break;

557  
558 
case 3: 
559 
coeffs[i] = b3_mantissas[get_bits(gbc, 3)];

560 
break;

561  
562 
case 4: 
563 
if(m>b4ptr > 1) { 
564 
gcode = get_bits(gbc, 7);

565 
m>b4_mant[0] = b4_mantissas[gcode][0]; 
566 
m>b4_mant[1] = b4_mantissas[gcode][1]; 
567 
m>b4ptr = 0;

568 
} 
569 
coeffs[i] = m>b4_mant[m>b4ptr++]; 
570 
break;

571  
572 
case 5: 
573 
coeffs[i] = b5_mantissas[get_bits(gbc, 4)];

574 
break;

575  
576 
default:

577 
/* asymmetric dequantization */

578 
coeffs[i] = get_sbits(gbc, quantization_tab[tbap]) * scale_factors[quantization_tab[tbap]1];

579 
break;

580 
} 
581 
coeffs[i] *= scale_factors[exps[i]]; 
582 
} 
583  
584 
return 0; 
585 
} 
586  
587 
/**

588 
* Remove random dithering from coefficients with zerobit mantissas

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

590 
*/

591 
static void remove_dithering(AC3DecodeContext *s) { 
592 
int ch, i;

593 
int end=0; 
594 
float *coeffs;

595 
uint8_t *bap; 
596  
597 
for(ch=1; ch<=s>fbw_channels; ch++) { 
598 
if(!s>dither_flag[ch]) {

599 
coeffs = s>transform_coeffs[ch]; 
600 
bap = s>bap[ch]; 
601 
if(s>channel_in_cpl[ch])

602 
end = s>start_freq[CPL_CH]; 
603 
else

604 
end = s>end_freq[ch]; 
605 
for(i=0; i<end; i++) { 
606 
if(!bap[i])

607 
coeffs[i] = 0.0f; 
608 
} 
609 
if(s>channel_in_cpl[ch]) {

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

612 
if(!bap[i])

613 
coeffs[i] = 0.0f; 
614 
} 
615 
} 
616 
} 
617 
} 
618 
} 
619  
620 
/**

621 
* Get the transform coefficients.

622 
*/

623 
static int get_transform_coeffs(AC3DecodeContext *s) 
624 
{ 
625 
int ch, end;

626 
int got_cplchan = 0; 
627 
mant_groups m; 
628  
629 
m.b1ptr = m.b2ptr = m.b4ptr = 3;

630  
631 
for (ch = 1; ch <= s>channels; ch++) { 
632 
/* transform coefficients for fullbandwidth channel */

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

634 
return 1; 
635 
/* tranform coefficients for coupling channel come right after the

636 
coefficients for the first coupled channel*/

637 
if (s>channel_in_cpl[ch]) {

638 
if (!got_cplchan) {

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

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

641 
return 1; 
642 
} 
643 
uncouple_channels(s); 
644 
got_cplchan = 1;

645 
} 
646 
end = s>end_freq[CPL_CH]; 
647 
} else {

648 
end = s>end_freq[ch]; 
649 
} 
650 
do

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

652 
while(++end < 256); 
653 
} 
654  
655 
/* if any channel doesn't use dithering, zero appropriate coefficients */

656 
if(!s>dither_all)

657 
remove_dithering(s); 
658  
659 
return 0; 
660 
} 
661  
662 
/**

663 
* Stereo rematrixing.

664 
* reference: Section 7.5.4 Rematrixing : Decoding Technique

665 
*/

666 
static void do_rematrixing(AC3DecodeContext *s) 
667 
{ 
668 
int bnd, i;

669 
int end, bndend;

670 
float tmp0, tmp1;

671  
672 
end = FFMIN(s>end_freq[1], s>end_freq[2]); 
673  
674 
for(bnd=0; bnd<s>num_rematrixing_bands; bnd++) { 
675 
if(s>rematrixing_flags[bnd]) {

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

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

678 
tmp0 = s>transform_coeffs[1][i];

679 
tmp1 = s>transform_coeffs[2][i];

680 
s>transform_coeffs[1][i] = tmp0 + tmp1;

681 
s>transform_coeffs[2][i] = tmp0  tmp1;

682 
} 
683 
} 
684 
} 
685 
} 
686  
687 
/**

688 
* Perform the 256point IMDCT

689 
*/

690 
static void do_imdct_256(AC3DecodeContext *s, int chindex) 
691 
{ 
692 
int i, k;

693 
DECLARE_ALIGNED_16(float, x[128]); 
694 
FFTComplex z[2][64]; 
695 
float *o_ptr = s>tmp_output;

696  
697 
for(i=0; i<2; i++) { 
698 
/* deinterleave coefficients */

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

701 
} 
702  
703 
/* run standard IMDCT */

704 
s>imdct_256.fft.imdct_calc(&s>imdct_256, o_ptr, x, s>tmp_imdct); 
705  
706 
/* reverse the postrotation & reordering from standard IMDCT */

707 
for(k=0; k<32; k++) { 
708 
z[i][32+k].re = o_ptr[128+2*k]; 
709 
z[i][32+k].im = o_ptr[2*k]; 
710 
z[i][31k].re = o_ptr[2*k+1]; 
711 
z[i][31k].im = o_ptr[128+2*k+1]; 
712 
} 
713 
} 
714  
715 
/* apply AC3 postrotation & reordering */

716 
for(k=0; k<64; k++) { 
717 
o_ptr[ 2*k ] = z[0][ k].im; 
718 
o_ptr[ 2*k+1] = z[0][63k].re; 
719 
o_ptr[128+2*k ] = z[0][ k].re; 
720 
o_ptr[128+2*k+1] = z[0][63k].im; 
721 
o_ptr[256+2*k ] = z[1][ k].re; 
722 
o_ptr[256+2*k+1] = z[1][63k].im; 
723 
o_ptr[384+2*k ] = z[1][ k].im; 
724 
o_ptr[384+2*k+1] = z[1][63k].re; 
725 
} 
726 
} 
727  
728 
/**

729 
* Inverse MDCT Transform.

730 
* Convert frequency domain coefficients to timedomain audio samples.

731 
* reference: Section 7.9.4 Transformation Equations

732 
*/

733 
static inline void do_imdct(AC3DecodeContext *s) 
734 
{ 
735 
int ch;

736 
int channels;

737  
738 
/* Don't perform the IMDCT on the LFE channel unless it's used in the output */

739 
channels = s>fbw_channels; 
740 
if(s>output_mode & AC3_OUTPUT_LFEON)

741 
channels++; 
742  
743 
for (ch=1; ch<=channels; ch++) { 
744 
if (s>block_switch[ch]) {

745 
do_imdct_256(s, ch); 
746 
} else {

747 
s>imdct_512.fft.imdct_calc(&s>imdct_512, s>tmp_output, 
748 
s>transform_coeffs[ch], s>tmp_imdct); 
749 
} 
750 
/* For the first half of the block, apply the window, add the delay

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

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

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

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

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

758 
} 
759 
} 
760  
761 
/**

762 
* Downmix the output to mono or stereo.

763 
*/

764 
static void ac3_downmix(AC3DecodeContext *s) 
765 
{ 
766 
int i, j;

767 
float v0, v1, s0, s1;

768  
769 
for(i=0; i<256; i++) { 
770 
v0 = v1 = s0 = s1 = 0.0f; 
771 
for(j=0; j<s>fbw_channels; j++) { 
772 
v0 += s>output[j][i] * s>downmix_coeffs[j][0];

773 
v1 += s>output[j][i] * s>downmix_coeffs[j][1];

774 
s0 += s>downmix_coeffs[j][0];

775 
s1 += s>downmix_coeffs[j][1];

776 
} 
777 
v0 /= s0; 
778 
v1 /= s1; 
779 
if(s>output_mode == AC3_CHMODE_MONO) {

780 
s>output[0][i] = (v0 + v1) * LEVEL_MINUS_3DB;

781 
} else if(s>output_mode == AC3_CHMODE_STEREO) { 
782 
s>output[0][i] = v0;

783 
s>output[1][i] = v1;

784 
} 
785 
} 
786 
} 
787  
788 
/**

789 
* Parse an audio block from AC3 bitstream.

790 
*/

791 
static int ac3_parse_audio_block(AC3DecodeContext *s, int blk) 
792 
{ 
793 
int fbw_channels = s>fbw_channels;

794 
int channel_mode = s>channel_mode;

795 
int i, bnd, seg, ch;

796 
GetBitContext *gbc = &s>gbc; 
797 
uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; 
798  
799 
memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

800  
801 
/* block switch flags */

802 
for (ch = 1; ch <= fbw_channels; ch++) 
803 
s>block_switch[ch] = get_bits1(gbc); 
804  
805 
/* dithering flags */

806 
s>dither_all = 1;

807 
for (ch = 1; ch <= fbw_channels; ch++) { 
808 
s>dither_flag[ch] = get_bits1(gbc); 
809 
if(!s>dither_flag[ch])

810 
s>dither_all = 0;

811 
} 
812  
813 
/* dynamic range */

814 
i = !(s>channel_mode); 
815 
do {

816 
if(get_bits1(gbc)) {

817 
s>dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]1.0) * 
818 
s>avctx>drc_scale)+1.0; 
819 
} else if(blk == 0) { 
820 
s>dynamic_range[i] = 1.0f; 
821 
} 
822 
} while(i);

823  
824 
/* coupling strategy */

825 
if (get_bits1(gbc)) {

826 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

827 
s>cpl_in_use = get_bits1(gbc); 
828 
if (s>cpl_in_use) {

829 
/* coupling in use */

830 
int cpl_begin_freq, cpl_end_freq;

831  
832 
/* determine which channels are coupled */

833 
for (ch = 1; ch <= fbw_channels; ch++) 
834 
s>channel_in_cpl[ch] = get_bits1(gbc); 
835  
836 
/* phase flags in use */

837 
if (channel_mode == AC3_CHMODE_STEREO)

838 
s>phase_flags_in_use = get_bits1(gbc); 
839  
840 
/* coupling frequency range and band structure */

841 
cpl_begin_freq = get_bits(gbc, 4);

842 
cpl_end_freq = get_bits(gbc, 4);

843 
if (3 + cpl_end_freq  cpl_begin_freq < 0) { 
844 
av_log(s>avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq); 
845 
return 1; 
846 
} 
847 
s>num_cpl_bands = s>num_cpl_subbands = 3 + cpl_end_freq  cpl_begin_freq;

848 
s>start_freq[CPL_CH] = cpl_begin_freq * 12 + 37; 
849 
s>end_freq[CPL_CH] = cpl_end_freq * 12 + 73; 
850 
for (bnd = 0; bnd < s>num_cpl_subbands  1; bnd++) { 
851 
if (get_bits1(gbc)) {

852 
s>cpl_band_struct[bnd] = 1;

853 
s>num_cpl_bands; 
854 
} 
855 
} 
856 
s>cpl_band_struct[s>num_cpl_subbands1] = 0; 
857 
} else {

858 
/* coupling not in use */

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

861 
} 
862 
} 
863  
864 
/* coupling coordinates */

865 
if (s>cpl_in_use) {

866 
int cpl_coords_exist = 0; 
867  
868 
for (ch = 1; ch <= fbw_channels; ch++) { 
869 
if (s>channel_in_cpl[ch]) {

870 
if (get_bits1(gbc)) {

871 
int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;

872 
cpl_coords_exist = 1;

873 
master_cpl_coord = 3 * get_bits(gbc, 2); 
874 
for (bnd = 0; bnd < s>num_cpl_bands; bnd++) { 
875 
cpl_coord_exp = get_bits(gbc, 4);

876 
cpl_coord_mant = get_bits(gbc, 4);

877 
if (cpl_coord_exp == 15) 
878 
s>cpl_coords[ch][bnd] = cpl_coord_mant / 16.0f; 
879 
else

880 
s>cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f; 
881 
s>cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord]; 
882 
} 
883 
} 
884 
} 
885 
} 
886 
/* phase flags */

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

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

890 
} 
891 
} 
892 
} 
893  
894 
/* stereo rematrixing strategy and band structure */

895 
if (channel_mode == AC3_CHMODE_STEREO) {

896 
if (get_bits1(gbc)) {

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); 
902 
} 
903 
} 
904  
905 
/* exponent strategies for each channel */

906 
s>exp_strategy[CPL_CH] = EXP_REUSE; 
907 
s>exp_strategy[s>lfe_ch] = EXP_REUSE; 
908 
for (ch = !s>cpl_in_use; ch <= s>channels; ch++) {

909 
if(ch == s>lfe_ch)

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

911 
else

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

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

914 
bit_alloc_stages[ch] = 3;

915 
} 
916  
917 
/* channel bandwidth */

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

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

921 
int prev = s>end_freq[ch];

922 
if (s>channel_in_cpl[ch])

923 
s>end_freq[ch] = s>start_freq[CPL_CH]; 
924 
else {

925 
int bandwidth_code = get_bits(gbc, 6); 
926 
if (bandwidth_code > 60) { 
927 
av_log(s>avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);

928 
return 1; 
929 
} 
930 
s>end_freq[ch] = bandwidth_code * 3 + 73; 
931 
} 
932 
if(blk > 0 && s>end_freq[ch] != prev) 
933 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

934 
} 
935 
} 
936 
s>start_freq[s>lfe_ch] = 0;

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

938  
939 
/* decode exponents for each channel */

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

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

942 
int group_size, num_groups;

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

945 
num_groups = (s>end_freq[ch]  s>start_freq[ch]) / group_size; 
946 
else if(ch == s>lfe_ch) 
947 
num_groups = 2;

948 
else

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

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

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

954 
skip_bits(gbc, 2); /* skip gainrng */ 
955 
} 
956 
} 
957  
958 
/* bit allocation information */

959 
if (get_bits1(gbc)) {

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

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

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

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

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

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

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

967 
} 
968 
} 
969  
970 
/* signaltonoise ratio offsets and fast gains (signaltomask ratios) */

971 
if (get_bits1(gbc)) {

972 
int csnr;

973 
csnr = (get_bits(gbc, 6)  15) << 4; 
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)];

977 
} 
978 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

979 
} 
980  
981 
/* coupling leak information */

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

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

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

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

986 
} 
987  
988 
/* delta bit allocation information */

989 
if (get_bits1(gbc)) {

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

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

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

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

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

995 
return 1; 
996 
} 
997 
bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

998 
} 
999 
/* channel delta offset, len and bit allocation */

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

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

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

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

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

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

1007 
} 
1008 
} 
1009 
} 
1010 
} else if(blk == 0) { 
1011 
for(ch=0; ch<=s>channels; ch++) { 
1012 
s>dba_mode[ch] = DBA_NONE; 
1013 
} 
1014 
} 
1015  
1016 
/* Bit allocation */

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

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

1020 
ff_ac3_bit_alloc_calc_psd(s>dexps[ch], 
1021 
s>start_freq[ch], s>end_freq[ch], 
1022 
s>psd[ch], s>band_psd[ch]); 
1023 
} 
1024 
if(bit_alloc_stages[ch] > 1) { 
1025 
/* Compute excitation function, Compute masking curve, and

1026 
Apply delta bit allocation */

1027 
ff_ac3_bit_alloc_calc_mask(&s>bit_alloc_params, s>band_psd[ch], 
1028 
s>start_freq[ch], s>end_freq[ch], 
1029 
s>fast_gain[ch], (ch == s>lfe_ch), 
1030 
s>dba_mode[ch], s>dba_nsegs[ch], 
1031 
s>dba_offsets[ch], s>dba_lengths[ch], 
1032 
s>dba_values[ch], s>mask[ch]); 
1033 
} 
1034 
if(bit_alloc_stages[ch] > 0) { 
1035 
/* Compute bit allocation */

1036 
ff_ac3_bit_alloc_calc_bap(s>mask[ch], s>psd[ch], 
1037 
s>start_freq[ch], s>end_freq[ch], 
1038 
s>snr_offset[ch], 
1039 
s>bit_alloc_params.floor, 
1040 
s>bap[ch]); 
1041 
} 
1042 
} 
1043  
1044 
/* unused dummy data */

1045 
if (get_bits1(gbc)) {

1046 
int skipl = get_bits(gbc, 9); 
1047 
while(skipl)

1048 
skip_bits(gbc, 8);

1049 
} 
1050  
1051 
/* unpack the transform coefficients

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

1053 
if (get_transform_coeffs(s)) {

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

1055 
return 1; 
1056 
} 
1057  
1058 
/* recover coefficients if rematrixing is in use */

1059 
if(s>channel_mode == AC3_CHMODE_STEREO)

1060 
do_rematrixing(s); 
1061  
1062 
/* apply scaling to coefficients (headroom, dynrng) */

1063 
for(ch=1; ch<=s>channels; ch++) { 
1064 
float gain = 2.0f * s>mul_bias; 
1065 
if(s>channel_mode == AC3_CHMODE_DUALMONO) {

1066 
gain *= s>dynamic_range[ch1];

1067 
} else {

1068 
gain *= s>dynamic_range[0];

1069 
} 
1070 
for(i=0; i<s>end_freq[ch]; i++) { 
1071 
s>transform_coeffs[ch][i] *= gain; 
1072 
} 
1073 
} 
1074  
1075 
do_imdct(s); 
1076  
1077 
/* downmix output if needed */

1078 
if(s>channels != s>out_channels && !((s>output_mode & AC3_OUTPUT_LFEON) &&

1079 
s>fbw_channels == s>out_channels)) { 
1080 
ac3_downmix(s); 
1081 
} 
1082  
1083 
/* convert float to 16bit integer */

1084 
for(ch=0; ch<s>out_channels; ch++) { 
1085 
for(i=0; i<256; i++) { 
1086 
s>output[ch][i] += s>add_bias; 
1087 
} 
1088 
s>dsp.float_to_int16(s>int_output[ch], s>output[ch], 256);

1089 
} 
1090  
1091 
return 0; 
1092 
} 
1093  
1094 
/**

1095 
* Decode a single AC3 frame.

1096 
*/

1097 
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size) 
1098 
{ 
1099 
AC3DecodeContext *s = avctx>priv_data; 
1100 
int16_t *out_samples = (int16_t *)data; 
1101 
int i, blk, ch, err;

1102  
1103 
/* initialize the GetBitContext with the start of valid AC3 Frame */

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

1105  
1106 
/* parse the syncinfo */

1107 
err = ac3_parse_header(s); 
1108 
if(err) {

1109 
switch(err) {

1110 
case AC3_PARSE_ERROR_SYNC:

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

1112 
break;

1113 
case AC3_PARSE_ERROR_BSID:

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

1115 
break;

1116 
case AC3_PARSE_ERROR_SAMPLE_RATE:

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

1118 
break;

1119 
case AC3_PARSE_ERROR_FRAME_SIZE:

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

1121 
break;

1122 
default:

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

1124 
break;

1125 
} 
1126 
return 1; 
1127 
} 
1128  
1129 
/* check that reported frame size fits in input buffer */

1130 
if(s>frame_size > buf_size) {

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

1132 
return 1; 
1133 
} 
1134  
1135 
/* check for crc mismatch */

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

1139 
return 1; 
1140 
} 
1141 
/* TODO: error concealment */

1142 
} 
1143  
1144 
avctx>sample_rate = s>sample_rate; 
1145 
avctx>bit_rate = s>bit_rate; 
1146  
1147 
/* channel config */

1148 
s>out_channels = s>channels; 
1149 
if (avctx>request_channels > 0 && avctx>request_channels <= 2 && 
1150 
avctx>request_channels < s>channels) { 
1151 
s>out_channels = avctx>request_channels; 
1152 
s>output_mode = avctx>request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;

1153 
} 
1154 
avctx>channels = s>out_channels; 
1155  
1156 
/* set downmixing coefficients if needed */

1157 
if(s>channels != s>out_channels && !((s>output_mode & AC3_OUTPUT_LFEON) &&

1158 
s>fbw_channels == s>out_channels)) { 
1159 
set_downmix_coeffs(s); 
1160 
} 
1161  
1162 
/* parse the audio blocks */

1163 
for (blk = 0; blk < NB_BLOCKS; blk++) { 
1164 
if (ac3_parse_audio_block(s, blk)) {

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

1166 
*data_size = 0;

1167 
return s>frame_size;

1168 
} 
1169 
for (i = 0; i < 256; i++) 
1170 
for (ch = 0; ch < s>out_channels; ch++) 
1171 
*(out_samples++) = s>int_output[ch][i]; 
1172 
} 
1173 
*data_size = NB_BLOCKS * 256 * avctx>channels * sizeof (int16_t); 
1174 
return s>frame_size;

1175 
} 
1176  
1177 
/**

1178 
* Uninitialize the AC3 decoder.

1179 
*/

1180 
static int ac3_decode_end(AVCodecContext *avctx) 
1181 
{ 
1182 
AC3DecodeContext *s = avctx>priv_data; 
1183 
ff_mdct_end(&s>imdct_512); 
1184 
ff_mdct_end(&s>imdct_256); 
1185  
1186 
return 0; 
1187 
} 
1188  
1189 
AVCodec ac3_decoder = { 
1190 
.name = "ac3",

1191 
.type = CODEC_TYPE_AUDIO, 
1192 
.id = CODEC_ID_AC3, 
1193 
.priv_data_size = sizeof (AC3DecodeContext),

1194 
.init = ac3_decode_init, 
1195 
.close = ac3_decode_end, 
1196 
.decode = ac3_decode_frame, 
1197 
}; 