ffmpeg / libavcodec / ac3dec.c @ 3abe5fbd
History  View  Annotate  Download (39.9 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 cpl_band_struct[18]; ///< coupling band structure 
137 
int rematrixing_strategy; ///< rematrixing strategy 
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 
float downmix_coeffs[AC3_MAX_CHANNELS][2]; ///< stereo downmix coefficients 
161 
float dynamic_range[2]; ///< dynamic range 
162 
float 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 
DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); ///< transform coefficients 
176  
177 
/* For IMDCT. */

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

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

180 
DSPContext dsp; ///< for optimization

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

192 
GetBitContext gbc; ///< bitstream reader

193 
AVRandomState dith_state; ///< for dither generation

194 
AVCodecContext *avctx; ///< parent context

195 
} AC3DecodeContext; 
196  
197 
/**

198 
* Generate a KaiserBessel Derived Window.

199 
*/

200 
static void ac3_window_init(float *window) 
201 
{ 
202 
int i, j;

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

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

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

222 
* Symmetrical Dequantization

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

224 
* Tables 7.19 to 7.23

225 
*/

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

233 
* Initialize tables at runtime.

234 
*/

235 
static void ac3_tables_init(void) 
236 
{ 
237 
int i;

238  
239 
/* generate grouped mantissa tables

240 
reference: Section 7.3.5 Ungrouping of Mantissas */

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

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

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

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

258 
reference: Tables 7.21 and 7.23 */

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

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

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

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

266 
} 
267  
268 
/* generate dynamic range table

269 
reference: Section 7.7.1 Dynamic Range Control */

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

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

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

281 
reference: Section 7.1.3 Exponent Decoding */

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

291 
* AVCodec initialization

292 
*/

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

305  
306 
/* set bias values for float to int16 conversion */

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

308 
s>add_bias = 385.0f; 
309 
s>mul_bias = 1.0f; 
310 
} else {

311 
s>add_bias = 0.0f; 
312 
s>mul_bias = 32767.0f; 
313 
} 
314  
315 
return 0; 
316 
} 
317  
318 
/**

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

320 
* GetBitContext within AC3DecodeContext must point to

321 
* start of the synchronized ac3 bitstream.

322 
*/

323 
static int ac3_parse_header(AC3DecodeContext *s) 
324 
{ 
325 
AC3HeaderInfo hdr; 
326 
GetBitContext *gbc = &s>gbc; 
327 
float center_mix_level, surround_mix_level;

328 
int err, i;

329  
330 
err = ff_ac3_parse_header(gbc>buffer, &hdr); 
331 
if(err)

332 
return err;

333  
334 
/* get decoding parameters from header info */

335 
s>bit_alloc_params.sr_code = hdr.sr_code; 
336 
s>channel_mode = hdr.channel_mode; 
337 
center_mix_level = gain_levels[center_levels[hdr.center_mix_level]]; 
338 
surround_mix_level = gain_levels[surround_levels[hdr.surround_mix_level]]; 
339 
s>lfe_on = hdr.lfe_on; 
340 
s>bit_alloc_params.sr_shift = hdr.sr_shift; 
341 
s>sample_rate = hdr.sample_rate; 
342 
s>bit_rate = hdr.bit_rate; 
343 
s>channels = hdr.channels; 
344 
s>fbw_channels = s>channels  s>lfe_on; 
345 
s>lfe_ch = s>fbw_channels + 1;

346 
s>frame_size = hdr.frame_size; 
347  
348 
/* set default output to all source channels */

349 
s>out_channels = s>channels; 
350 
s>output_mode = s>channel_mode; 
351 
if(s>lfe_on)

352 
s>output_mode = AC3_OUTPUT_LFEON; 
353  
354 
/* skip over portion of header which has already been read */

355 
skip_bits(gbc, 16); // skip the sync_word 
356 
skip_bits(gbc, 16); // skip crc1 
357 
skip_bits(gbc, 8); // skip fscod and frmsizecod 
358 
skip_bits(gbc, 11); // skip bsid, bsmod, and acmod 
359 
if(s>channel_mode == AC3_CHMODE_STEREO) {

360 
skip_bits(gbc, 2); // skip dsurmod 
361 
} else {

362 
if((s>channel_mode & 1) && s>channel_mode != AC3_CHMODE_MONO) 
363 
skip_bits(gbc, 2); // skip cmixlev 
364 
if(s>channel_mode & 4) 
365 
skip_bits(gbc, 2); // skip surmixlev 
366 
} 
367 
skip_bits1(gbc); // skip lfeon

368  
369 
/* read the rest of the bsi. read twice for dual mono mode. */

370 
i = !(s>channel_mode); 
371 
do {

372 
skip_bits(gbc, 5); // skip dialog normalization 
373 
if (get_bits1(gbc))

374 
skip_bits(gbc, 8); //skip compression 
375 
if (get_bits1(gbc))

376 
skip_bits(gbc, 8); //skip language code 
377 
if (get_bits1(gbc))

378 
skip_bits(gbc, 7); //skip audio production information 
379 
} while (i);

380  
381 
skip_bits(gbc, 2); //skip copyright bit and original bitstream bit 
382  
383 
/* skip the timecodes (or extra bitstream information for Alternate Syntax)

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

385 
if (get_bits1(gbc))

386 
skip_bits(gbc, 14); //skip timecode1 / xbsi1 
387 
if (get_bits1(gbc))

388 
skip_bits(gbc, 14); //skip timecode2 / xbsi2 
389  
390 
/* skip additional bitstream info */

391 
if (get_bits1(gbc)) {

392 
i = get_bits(gbc, 6);

393 
do {

394 
skip_bits(gbc, 8);

395 
} while(i);

396 
} 
397  
398 
/* set stereo downmixing coefficients

399 
reference: Section 7.8.2 Downmixing Into Two Channels */

400 
for(i=0; i<s>fbw_channels; i++) { 
401 
s>downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s>channel_mode][i][0]]; 
402 
s>downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s>channel_mode][i][1]]; 
403 
} 
404 
if(s>channel_mode > 1 && s>channel_mode & 1) { 
405 
s>downmix_coeffs[1][0] = s>downmix_coeffs[1][1] = center_mix_level; 
406 
} 
407 
if(s>channel_mode == AC3_CHMODE_2F1R  s>channel_mode == AC3_CHMODE_3F1R) {

408 
int nf = s>channel_mode  2; 
409 
s>downmix_coeffs[nf][0] = s>downmix_coeffs[nf][1] = surround_mix_level * LEVEL_MINUS_3DB; 
410 
} 
411 
if(s>channel_mode == AC3_CHMODE_2F2R  s>channel_mode == AC3_CHMODE_3F2R) {

412 
int nf = s>channel_mode  4; 
413 
s>downmix_coeffs[nf][0] = s>downmix_coeffs[nf+1][1] = surround_mix_level; 
414 
} 
415  
416 
return 0; 
417 
} 
418  
419 
/**

420 
* Decode the grouped exponents according to exponent strategy.

421 
* reference: Section 7.1.3 Exponent Decoding

422 
*/

423 
static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, 
424 
uint8_t absexp, int8_t *dexps) 
425 
{ 
426 
int i, j, grp, group_size;

427 
int dexp[256]; 
428 
int expacc, prevexp;

429  
430 
/* unpack groups */

431 
group_size = exp_strategy + (exp_strategy == EXP_D45); 
432 
for(grp=0,i=0; grp<ngrps; grp++) { 
433 
expacc = get_bits(gbc, 7);

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

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

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

437 
} 
438  
439 
/* convert to absolute exps and expand groups */

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

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

451 
* range using the coupling coefficients and coupling coordinates.

452 
* reference: Section 7.4.3 Coupling Coordinate Format

453 
*/

454 
static void uncouple_channels(AC3DecodeContext *s) 
455 
{ 
456 
int i, j, ch, bnd, subbnd;

457  
458 
subbnd = 1;

459 
i = s>start_freq[CPL_CH]; 
460 
for(bnd=0; bnd<s>num_cpl_bands; bnd++) { 
461 
do {

462 
subbnd++; 
463 
for(j=0; j<12; j++) { 
464 
for(ch=1; ch<=s>fbw_channels; ch++) { 
465 
if(s>channel_in_cpl[ch])

466 
s>transform_coeffs[ch][i] = s>transform_coeffs[CPL_CH][i] * s>cpl_coords[ch][bnd] * 8.0f; 
467 
} 
468 
i++; 
469 
} 
470 
} while(s>cpl_band_struct[subbnd]);

471 
} 
472 
} 
473  
474 
/**

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

476 
*/

477 
typedef struct { 
478 
float b1_mant[3]; 
479 
float b2_mant[3]; 
480 
float b4_mant[2]; 
481 
int b1ptr;

482 
int b2ptr;

483 
int b4ptr;

484 
} mant_groups; 
485  
486 
/**

487 
* Get the transform coefficients for a particular channel

488 
* reference: Section 7.3 Quantization and Decoding of Mantissas

489 
*/

490 
static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) 
491 
{ 
492 
GetBitContext *gbc = &s>gbc; 
493 
int i, gcode, tbap, start, end;

494 
uint8_t *exps; 
495 
uint8_t *bap; 
496 
float *coeffs;

497  
498 
exps = s>dexps[ch_index]; 
499 
bap = s>bap[ch_index]; 
500 
coeffs = s>transform_coeffs[ch_index]; 
501 
start = s>start_freq[ch_index]; 
502 
end = s>end_freq[ch_index]; 
503  
504 
for (i = start; i < end; i++) {

505 
tbap = bap[i]; 
506 
switch (tbap) {

507 
case 0: 
508 
coeffs[i] = ((av_random(&s>dith_state) & 0xFFFF) / 65535.0f)  0.5f; 
509 
break;

510  
511 
case 1: 
512 
if(m>b1ptr > 2) { 
513 
gcode = get_bits(gbc, 5);

514 
m>b1_mant[0] = b1_mantissas[gcode][0]; 
515 
m>b1_mant[1] = b1_mantissas[gcode][1]; 
516 
m>b1_mant[2] = b1_mantissas[gcode][2]; 
517 
m>b1ptr = 0;

518 
} 
519 
coeffs[i] = m>b1_mant[m>b1ptr++]; 
520 
break;

521  
522 
case 2: 
523 
if(m>b2ptr > 2) { 
524 
gcode = get_bits(gbc, 7);

525 
m>b2_mant[0] = b2_mantissas[gcode][0]; 
526 
m>b2_mant[1] = b2_mantissas[gcode][1]; 
527 
m>b2_mant[2] = b2_mantissas[gcode][2]; 
528 
m>b2ptr = 0;

529 
} 
530 
coeffs[i] = m>b2_mant[m>b2ptr++]; 
531 
break;

532  
533 
case 3: 
534 
coeffs[i] = b3_mantissas[get_bits(gbc, 3)];

535 
break;

536  
537 
case 4: 
538 
if(m>b4ptr > 1) { 
539 
gcode = get_bits(gbc, 7);

540 
m>b4_mant[0] = b4_mantissas[gcode][0]; 
541 
m>b4_mant[1] = b4_mantissas[gcode][1]; 
542 
m>b4ptr = 0;

543 
} 
544 
coeffs[i] = m>b4_mant[m>b4ptr++]; 
545 
break;

546  
547 
case 5: 
548 
coeffs[i] = b5_mantissas[get_bits(gbc, 4)];

549 
break;

550  
551 
default:

552 
/* asymmetric dequantization */

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

554 
break;

555 
} 
556 
coeffs[i] *= scale_factors[exps[i]]; 
557 
} 
558  
559 
return 0; 
560 
} 
561  
562 
/**

563 
* Remove random dithering from coefficients with zerobit mantissas

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

565 
*/

566 
static void remove_dithering(AC3DecodeContext *s) { 
567 
int ch, i;

568 
int end=0; 
569 
float *coeffs;

570 
uint8_t *bap; 
571  
572 
for(ch=1; ch<=s>fbw_channels; ch++) { 
573 
if(!s>dither_flag[ch]) {

574 
coeffs = s>transform_coeffs[ch]; 
575 
bap = s>bap[ch]; 
576 
if(s>channel_in_cpl[ch])

577 
end = s>start_freq[CPL_CH]; 
578 
else

579 
end = s>end_freq[ch]; 
580 
for(i=0; i<end; i++) { 
581 
if(!bap[i])

582 
coeffs[i] = 0.0f; 
583 
} 
584 
if(s>channel_in_cpl[ch]) {

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

587 
if(!bap[i])

588 
coeffs[i] = 0.0f; 
589 
} 
590 
} 
591 
} 
592 
} 
593 
} 
594  
595 
/**

596 
* Get the transform coefficients.

597 
*/

598 
static int get_transform_coeffs(AC3DecodeContext *s) 
599 
{ 
600 
int ch, end;

601 
int got_cplchan = 0; 
602 
mant_groups m; 
603  
604 
m.b1ptr = m.b2ptr = m.b4ptr = 3;

605  
606 
for (ch = 1; ch <= s>channels; ch++) { 
607 
/* transform coefficients for fullbandwidth channel */

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

609 
return 1; 
610 
/* tranform coefficients for coupling channel come right after the

611 
coefficients for the first coupled channel*/

612 
if (s>channel_in_cpl[ch]) {

613 
if (!got_cplchan) {

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

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

616 
return 1; 
617 
} 
618 
uncouple_channels(s); 
619 
got_cplchan = 1;

620 
} 
621 
end = s>end_freq[CPL_CH]; 
622 
} else {

623 
end = s>end_freq[ch]; 
624 
} 
625 
do

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

627 
while(++end < 256); 
628 
} 
629  
630 
/* if any channel doesn't use dithering, zero appropriate coefficients */

631 
if(!s>dither_all)

632 
remove_dithering(s); 
633  
634 
return 0; 
635 
} 
636  
637 
/**

638 
* Stereo rematrixing.

639 
* reference: Section 7.5.4 Rematrixing : Decoding Technique

640 
*/

641 
static void do_rematrixing(AC3DecodeContext *s) 
642 
{ 
643 
int bnd, i;

644 
int end, bndend;

645 
float tmp0, tmp1;

646  
647 
end = FFMIN(s>end_freq[1], s>end_freq[2]); 
648  
649 
for(bnd=0; bnd<s>num_rematrixing_bands; bnd++) { 
650 
if(s>rematrixing_flags[bnd]) {

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

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

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

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

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

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

657 
} 
658 
} 
659 
} 
660 
} 
661  
662 
/**

663 
* Perform the 256point IMDCT

664 
*/

665 
static void do_imdct_256(AC3DecodeContext *s, int chindex) 
666 
{ 
667 
int i, k;

668 
DECLARE_ALIGNED_16(float, x[128]); 
669 
FFTComplex z[2][64]; 
670 
float *o_ptr = s>tmp_output;

671  
672 
for(i=0; i<2; i++) { 
673 
/* deinterleave coefficients */

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

676 
} 
677  
678 
/* run standard IMDCT */

679 
s>imdct_256.fft.imdct_calc(&s>imdct_256, o_ptr, x, s>tmp_imdct); 
680  
681 
/* reverse the postrotation & reordering from standard IMDCT */

682 
for(k=0; k<32; k++) { 
683 
z[i][32+k].re = o_ptr[128+2*k]; 
684 
z[i][32+k].im = o_ptr[2*k]; 
685 
z[i][31k].re = o_ptr[2*k+1]; 
686 
z[i][31k].im = o_ptr[128+2*k+1]; 
687 
} 
688 
} 
689  
690 
/* apply AC3 postrotation & reordering */

691 
for(k=0; k<64; k++) { 
692 
o_ptr[ 2*k ] = z[0][ k].im; 
693 
o_ptr[ 2*k+1] = z[0][63k].re; 
694 
o_ptr[128+2*k ] = z[0][ k].re; 
695 
o_ptr[128+2*k+1] = z[0][63k].im; 
696 
o_ptr[256+2*k ] = z[1][ k].re; 
697 
o_ptr[256+2*k+1] = z[1][63k].im; 
698 
o_ptr[384+2*k ] = z[1][ k].im; 
699 
o_ptr[384+2*k+1] = z[1][63k].re; 
700 
} 
701 
} 
702  
703 
/**

704 
* Inverse MDCT Transform.

705 
* Convert frequency domain coefficients to timedomain audio samples.

706 
* reference: Section 7.9.4 Transformation Equations

707 
*/

708 
static inline void do_imdct(AC3DecodeContext *s) 
709 
{ 
710 
int ch;

711 
int channels;

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

714 
channels = s>fbw_channels; 
715 
if(s>output_mode & AC3_OUTPUT_LFEON)

716 
channels++; 
717  
718 
for (ch=1; ch<=channels; ch++) { 
719 
if (s>block_switch[ch]) {

720 
do_imdct_256(s, ch); 
721 
} else {

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

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

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

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

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

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

733 
} 
734 
} 
735  
736 
/**

737 
* Downmix the output to mono or stereo.

738 
*/

739 
static void ac3_downmix(AC3DecodeContext *s) 
740 
{ 
741 
int i, j;

742 
float v0, v1, s0, s1;

743  
744 
for(i=0; i<256; i++) { 
745 
v0 = v1 = s0 = s1 = 0.0f; 
746 
for(j=0; j<s>fbw_channels; j++) { 
747 
v0 += s>output[j][i] * s>downmix_coeffs[j][0];

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

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

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

751 
} 
752 
v0 /= s0; 
753 
v1 /= s1; 
754 
if(s>output_mode == AC3_CHMODE_MONO) {

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

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

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

759 
} 
760 
} 
761 
} 
762  
763 
/**

764 
* Parse an audio block from AC3 bitstream.

765 
*/

766 
static int ac3_parse_audio_block(AC3DecodeContext *s, int blk) 
767 
{ 
768 
int fbw_channels = s>fbw_channels;

769 
int channel_mode = s>channel_mode;

770 
int i, bnd, seg, ch;

771 
GetBitContext *gbc = &s>gbc; 
772 
uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; 
773  
774 
memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);

775  
776 
/* block switch flags */

777 
for (ch = 1; ch <= fbw_channels; ch++) 
778 
s>block_switch[ch] = get_bits1(gbc); 
779  
780 
/* dithering flags */

781 
s>dither_all = 1;

782 
for (ch = 1; ch <= fbw_channels; ch++) { 
783 
s>dither_flag[ch] = get_bits1(gbc); 
784 
if(!s>dither_flag[ch])

785 
s>dither_all = 0;

786 
} 
787  
788 
/* dynamic range */

789 
i = !(s>channel_mode); 
790 
do {

791 
if(get_bits1(gbc)) {

792 
s>dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]1.0) * 
793 
s>avctx>drc_scale)+1.0; 
794 
} else if(blk == 0) { 
795 
s>dynamic_range[i] = 1.0f; 
796 
} 
797 
} while(i);

798  
799 
/* coupling strategy */

800 
if (get_bits1(gbc)) {

801 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

802 
s>cpl_in_use = get_bits1(gbc); 
803 
if (s>cpl_in_use) {

804 
/* coupling in use */

805 
int cpl_begin_freq, cpl_end_freq;

806  
807 
/* determine which channels are coupled */

808 
for (ch = 1; ch <= fbw_channels; ch++) 
809 
s>channel_in_cpl[ch] = get_bits1(gbc); 
810  
811 
/* phase flags in use */

812 
if (channel_mode == AC3_CHMODE_STEREO)

813 
s>phase_flags_in_use = get_bits1(gbc); 
814  
815 
/* coupling frequency range and band structure */

816 
cpl_begin_freq = get_bits(gbc, 4);

817 
cpl_end_freq = get_bits(gbc, 4);

818 
if (3 + cpl_end_freq  cpl_begin_freq < 0) { 
819 
av_log(s>avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq); 
820 
return 1; 
821 
} 
822 
s>num_cpl_bands = s>num_cpl_subbands = 3 + cpl_end_freq  cpl_begin_freq;

823 
s>start_freq[CPL_CH] = cpl_begin_freq * 12 + 37; 
824 
s>end_freq[CPL_CH] = cpl_end_freq * 12 + 73; 
825 
for (bnd = 0; bnd < s>num_cpl_subbands  1; bnd++) { 
826 
if (get_bits1(gbc)) {

827 
s>cpl_band_struct[bnd] = 1;

828 
s>num_cpl_bands; 
829 
} 
830 
} 
831 
} else {

832 
/* coupling not in use */

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

835 
} 
836 
} 
837  
838 
/* coupling coordinates */

839 
if (s>cpl_in_use) {

840 
int cpl_coords_exist = 0; 
841  
842 
for (ch = 1; ch <= fbw_channels; ch++) { 
843 
if (s>channel_in_cpl[ch]) {

844 
if (get_bits1(gbc)) {

845 
int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;

846 
cpl_coords_exist = 1;

847 
master_cpl_coord = 3 * get_bits(gbc, 2); 
848 
for (bnd = 0; bnd < s>num_cpl_bands; bnd++) { 
849 
cpl_coord_exp = get_bits(gbc, 4);

850 
cpl_coord_mant = get_bits(gbc, 4);

851 
if (cpl_coord_exp == 15) 
852 
s>cpl_coords[ch][bnd] = cpl_coord_mant / 16.0f; 
853 
else

854 
s>cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f; 
855 
s>cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord]; 
856 
} 
857 
} 
858 
} 
859 
} 
860 
/* phase flags */

861 
if (channel_mode == AC3_CHMODE_STEREO && s>phase_flags_in_use && cpl_coords_exist) {

862 
for (bnd = 0; bnd < s>num_cpl_bands; bnd++) { 
863 
if (get_bits1(gbc))

864 
s>cpl_coords[2][bnd] = s>cpl_coords[2][bnd]; 
865 
} 
866 
} 
867 
} 
868  
869 
/* stereo rematrixing strategy and band structure */

870 
if (channel_mode == AC3_CHMODE_STEREO) {

871 
s>rematrixing_strategy = get_bits1(gbc); 
872 
if (s>rematrixing_strategy) {

873 
s>num_rematrixing_bands = 4;

874 
if(s>cpl_in_use && s>start_freq[CPL_CH] <= 61) 
875 
s>num_rematrixing_bands = 1 + (s>start_freq[CPL_CH] == 37); 
876 
for(bnd=0; bnd<s>num_rematrixing_bands; bnd++) 
877 
s>rematrixing_flags[bnd] = get_bits1(gbc); 
878 
} 
879 
} 
880  
881 
/* exponent strategies for each channel */

882 
s>exp_strategy[CPL_CH] = EXP_REUSE; 
883 
s>exp_strategy[s>lfe_ch] = EXP_REUSE; 
884 
for (ch = !s>cpl_in_use; ch <= s>channels; ch++) {

885 
if(ch == s>lfe_ch)

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

887 
else

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

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

890 
bit_alloc_stages[ch] = 3;

891 
} 
892  
893 
/* channel bandwidth */

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

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

897 
int prev = s>end_freq[ch];

898 
if (s>channel_in_cpl[ch])

899 
s>end_freq[ch] = s>start_freq[CPL_CH]; 
900 
else {

901 
int bandwidth_code = get_bits(gbc, 6); 
902 
if (bandwidth_code > 60) { 
903 
av_log(s>avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);

904 
return 1; 
905 
} 
906 
s>end_freq[ch] = bandwidth_code * 3 + 73; 
907 
} 
908 
if(blk > 0 && s>end_freq[ch] != prev) 
909 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

910 
} 
911 
} 
912 
s>start_freq[s>lfe_ch] = 0;

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

914  
915 
/* decode exponents for each channel */

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

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

918 
int group_size, num_groups;

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

921 
num_groups = (s>end_freq[ch]  s>start_freq[ch]) / group_size; 
922 
else if(ch == s>lfe_ch) 
923 
num_groups = 2;

924 
else

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

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

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

930 
skip_bits(gbc, 2); /* skip gainrng */ 
931 
} 
932 
} 
933  
934 
/* bit allocation information */

935 
if (get_bits1(gbc)) {

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

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

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

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

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

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

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

943 
} 
944 
} 
945  
946 
/* signaltonoise ratio offsets and fast gains (signaltomask ratios) */

947 
if (get_bits1(gbc)) {

948 
int csnr;

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

953 
} 
954 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

955 
} 
956  
957 
/* coupling leak information */

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

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

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

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

962 
} 
963  
964 
/* delta bit allocation information */

965 
if (get_bits1(gbc)) {

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

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

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

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

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

971 
return 1; 
972 
} 
973 
bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

974 
} 
975 
/* channel delta offset, len and bit allocation */

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

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

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

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

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

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

983 
} 
984 
} 
985 
} 
986 
} else if(blk == 0) { 
987 
for(ch=0; ch<=s>channels; ch++) { 
988 
s>dba_mode[ch] = DBA_NONE; 
989 
} 
990 
} 
991  
992 
/* Bit allocation */

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

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

996 
ff_ac3_bit_alloc_calc_psd(s>dexps[ch], 
997 
s>start_freq[ch], s>end_freq[ch], 
998 
s>psd[ch], s>band_psd[ch]); 
999 
} 
1000 
if(bit_alloc_stages[ch] > 1) { 
1001 
/* Compute excitation function, Compute masking curve, and

1002 
Apply delta bit allocation */

1003 
ff_ac3_bit_alloc_calc_mask(&s>bit_alloc_params, s>band_psd[ch], 
1004 
s>start_freq[ch], s>end_freq[ch], 
1005 
s>fast_gain[ch], (ch == s>lfe_ch), 
1006 
s>dba_mode[ch], s>dba_nsegs[ch], 
1007 
s>dba_offsets[ch], s>dba_lengths[ch], 
1008 
s>dba_values[ch], s>mask[ch]); 
1009 
} 
1010 
if(bit_alloc_stages[ch] > 0) { 
1011 
/* Compute bit allocation */

1012 
ff_ac3_bit_alloc_calc_bap(s>mask[ch], s>psd[ch], 
1013 
s>start_freq[ch], s>end_freq[ch], 
1014 
s>snr_offset[ch], 
1015 
s>bit_alloc_params.floor, 
1016 
s>bap[ch]); 
1017 
} 
1018 
} 
1019  
1020 
/* unused dummy data */

1021 
if (get_bits1(gbc)) {

1022 
int skipl = get_bits(gbc, 9); 
1023 
while(skipl)

1024 
skip_bits(gbc, 8);

1025 
} 
1026  
1027 
/* unpack the transform coefficients

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

1029 
if (get_transform_coeffs(s)) {

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

1031 
return 1; 
1032 
} 
1033  
1034 
/* recover coefficients if rematrixing is in use */

1035 
if(s>channel_mode == AC3_CHMODE_STEREO)

1036 
do_rematrixing(s); 
1037  
1038 
/* apply scaling to coefficients (headroom, dynrng) */

1039 
for(ch=1; ch<=s>channels; ch++) { 
1040 
float gain = 2.0f * s>mul_bias; 
1041 
if(s>channel_mode == AC3_CHMODE_DUALMONO) {

1042 
gain *= s>dynamic_range[ch1];

1043 
} else {

1044 
gain *= s>dynamic_range[0];

1045 
} 
1046 
for(i=0; i<s>end_freq[ch]; i++) { 
1047 
s>transform_coeffs[ch][i] *= gain; 
1048 
} 
1049 
} 
1050  
1051 
do_imdct(s); 
1052  
1053 
/* downmix output if needed */

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

1055 
s>fbw_channels == s>out_channels)) { 
1056 
ac3_downmix(s); 
1057 
} 
1058  
1059 
/* convert float to 16bit integer */

1060 
for(ch=0; ch<s>out_channels; ch++) { 
1061 
for(i=0; i<256; i++) { 
1062 
s>output[ch][i] += s>add_bias; 
1063 
} 
1064 
s>dsp.float_to_int16(s>int_output[ch], s>output[ch], 256);

1065 
} 
1066  
1067 
return 0; 
1068 
} 
1069  
1070 
/**

1071 
* Decode a single AC3 frame.

1072 
*/

1073 
static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size) 
1074 
{ 
1075 
AC3DecodeContext *s = avctx>priv_data; 
1076 
int16_t *out_samples = (int16_t *)data; 
1077 
int i, blk, ch, err;

1078  
1079 
/* initialize the GetBitContext with the start of valid AC3 Frame */

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

1081  
1082 
/* parse the syncinfo */

1083 
err = ac3_parse_header(s); 
1084 
if(err) {

1085 
switch(err) {

1086 
case AC3_PARSE_ERROR_SYNC:

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

1088 
break;

1089 
case AC3_PARSE_ERROR_BSID:

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

1091 
break;

1092 
case AC3_PARSE_ERROR_SAMPLE_RATE:

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

1094 
break;

1095 
case AC3_PARSE_ERROR_FRAME_SIZE:

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

1097 
break;

1098 
default:

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

1100 
break;

1101 
} 
1102 
return 1; 
1103 
} 
1104  
1105 
/* check that reported frame size fits in input buffer */

1106 
if(s>frame_size > buf_size) {

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

1108 
return 1; 
1109 
} 
1110  
1111 
/* check for crc mismatch */

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

1115 
return 1; 
1116 
} 
1117 
/* TODO: error concealment */

1118 
} 
1119  
1120 
avctx>sample_rate = s>sample_rate; 
1121 
avctx>bit_rate = s>bit_rate; 
1122  
1123 
/* channel config */

1124 
s>out_channels = s>channels; 
1125 
if (avctx>request_channels > 0 && avctx>request_channels <= 2 && 
1126 
avctx>request_channels < s>channels) { 
1127 
s>out_channels = avctx>request_channels; 
1128 
s>output_mode = avctx>request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;

1129 
} 
1130 
avctx>channels = s>out_channels; 
1131  
1132 
/* parse the audio blocks */

1133 
for (blk = 0; blk < NB_BLOCKS; blk++) { 
1134 
if (ac3_parse_audio_block(s, blk)) {

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

1136 
*data_size = 0;

1137 
return s>frame_size;

1138 
} 
1139 
for (i = 0; i < 256; i++) 
1140 
for (ch = 0; ch < s>out_channels; ch++) 
1141 
*(out_samples++) = s>int_output[ch][i]; 
1142 
} 
1143 
*data_size = NB_BLOCKS * 256 * avctx>channels * sizeof (int16_t); 
1144 
return s>frame_size;

1145 
} 
1146  
1147 
/**

1148 
* Uninitialize the AC3 decoder.

1149 
*/

1150 
static int ac3_decode_end(AVCodecContext *avctx) 
1151 
{ 
1152 
AC3DecodeContext *s = avctx>priv_data; 
1153 
ff_mdct_end(&s>imdct_512); 
1154 
ff_mdct_end(&s>imdct_256); 
1155  
1156 
return 0; 
1157 
} 
1158  
1159 
AVCodec ac3_decoder = { 
1160 
.name = "ac3",

1161 
.type = CODEC_TYPE_AUDIO, 
1162 
.id = CODEC_ID_AC3, 
1163 
.priv_data_size = sizeof (AC3DecodeContext),

1164 
.init = ac3_decode_init, 
1165 
.close = ac3_decode_end, 
1166 
.decode = ac3_decode_frame, 
1167 
}; 