ffmpeg / libavcodec / ac3dec.c @ d802d7ca
History  View  Annotate  Download (39.8 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 "dsputil.h" 
39 
#include "random.h" 
40  
41 
/**

42 
* Table of bin locations for rematrixing bands

43 
* reference: Section 7.5.2 Rematrixing : Frequency Band Definitions

44 
*/

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

48 
* table for exponent to scale_factor mapping

49 
* scale_factors[i] = 2 ^ i

50 
*/

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

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

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

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

66 
* reference: Table 7.18 Mapping of bap to Quantizer

67 
*/

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

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

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

94 
* Table for center mix levels

95 
* reference: Section 5.4.2.4 cmixlev

96 
*/

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

100 
* Table for surround mix levels

101 
* reference: Section 5.4.2.5 surmixlev

102 
*/

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

106 
* Table for default stereo downmixing coefficients

107 
* reference: Section 7.8.2 Downmixing Into Two Channels

108 
*/

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

121 
#undef AC3_MAX_CHANNELS

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

167  
168 
int8_t dexps[AC3_MAX_CHANNELS][256]; ///< decoded exponents 
169 
uint8_t bap[AC3_MAX_CHANNELS][256]; ///< bit allocation pointers 
170 
int16_t psd[AC3_MAX_CHANNELS][256]; ///< scaled exponents 
171 
int16_t band_psd[AC3_MAX_CHANNELS][50]; ///< interpolated exponents 
172 
int16_t mask[AC3_MAX_CHANNELS][50]; ///< masking curve values 
173  
174 
DECLARE_ALIGNED_16(float, transform_coeffs[AC3_MAX_CHANNELS][256]); ///< transform coefficients 
175  
176 
/* For IMDCT. */

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

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

179 
DSPContext dsp; ///< for optimization

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

191 
GetBitContext gbc; ///< bitstream reader

192 
AVRandomState dith_state; ///< for dither generation

193 
AVCodecContext *avctx; ///< parent context

194 
} AC3DecodeContext; 
195  
196 
/**

197 
* Generate a KaiserBessel Derived Window.

198 
*/

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

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

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

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

221 
* Symmetrical Dequantization

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

223 
* Tables 7.19 to 7.23

224 
*/

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

232 
* Initialize tables at runtime.

233 
*/

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

237  
238 
/* generate grouped mantissa tables

239 
reference: Section 7.3.5 Ungrouping of Mantissas */

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

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

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

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

257 
reference: Tables 7.21 and 7.23 */

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

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

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

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

265 
} 
266  
267 
/* generate dynamic range table

268 
reference: Section 7.7.1 Dynamic Range Control */

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

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

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

280 
reference: Section 7.1.3 Exponent Decoding */

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

290 
* AVCodec initialization

291 
*/

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

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

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

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

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

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

319 
* GetBitContext within AC3DecodeContext must point to

320 
* start of the synchronized ac3 bitstream.

321 
*/

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

327 
int err, i;

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

331 
return err;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

384 
if (get_bits1(gbc))

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

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

390 
if (get_bits1(gbc)) {

391 
i = get_bits(gbc, 6);

392 
do {

393 
skip_bits(gbc, 8);

394 
} while(i);

395 
} 
396  
397 
/* set stereo downmixing coefficients

398 
reference: Section 7.8.2 Downmixing Into Two Channels */

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

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

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

419 
* Decode the grouped exponents according to exponent strategy.

420 
* reference: Section 7.1.3 Exponent Decoding

421 
*/

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

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

428  
429 
/* unpack groups */

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

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

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

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

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

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

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

450 
* range using the coupling coefficients and coupling coordinates.

451 
* reference: Section 7.4.3 Coupling Coordinate Format

452 
*/

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

456  
457 
subbnd = 1;

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

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

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

470 
} 
471 
} 
472  
473 
/**

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

475 
*/

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

481 
int b2ptr;

482 
int b4ptr;

483 
} mant_groups; 
484  
485 
/**

486 
* Get the transform coefficients for a particular channel

487 
* reference: Section 7.3 Quantization and Decoding of Mantissas

488 
*/

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

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

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

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

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

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

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

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

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

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

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

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

534 
break;

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

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

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

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

548 
break;

549  
550 
default:

551 
/* asymmetric dequantization */

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

553 
break;

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

562 
* Remove random dithering from coefficients with zerobit mantissas

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

564 
*/

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

567 
int end=0; 
568 
float *coeffs;

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

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

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

578 
end = s>end_freq[ch]; 
579 
for(i=0; i<end; i++) { 
580 
if(bap[i] == 0) 
581 
coeffs[i] = 0.0f; 
582 
} 
583 
if(s>channel_in_cpl[ch]) {

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

586 
if(bap[i] == 0) 
587 
coeffs[i] = 0.0f; 
588 
} 
589 
} 
590 
} 
591 
} 
592 
} 
593  
594 
/**

595 
* Get the transform coefficients.

596 
*/

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

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

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

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

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

610 
coefficients for the first coupled channel*/

611 
if (s>channel_in_cpl[ch]) {

612 
if (!got_cplchan) {

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

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

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

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

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

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

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

630 
if(!s>dither_all)

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

637 
* Stereo rematrixing.

638 
* reference: Section 7.5.4 Rematrixing : Decoding Technique

639 
*/

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

643 
int end, bndend;

644 
float tmp0, tmp1;

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

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

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

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

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

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

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

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

662 
* Perform the 256point IMDCT

663 
*/

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

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

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

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

675 
} 
676  
677 
/* run standard IMDCT */

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

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

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

703 
* Inverse MDCT Transform.

704 
* Convert frequency domain coefficients to timedomain audio samples.

705 
* reference: Section 7.9.4 Transformation Equations

706 
*/

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

710 
int channels;

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

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

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

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

721 
s>imdct_512.fft.imdct_calc(&s>imdct_512, s>tmp_output, 
722 
s>transform_coeffs[ch], 
723 
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(float samples[AC3_MAX_CHANNELS][256], int fbw_channels, 
740 
int output_mode, float coef[AC3_MAX_CHANNELS][2]) 
741 
{ 
742 
int i, j;

743 
float v0, v1, s0, s1;

744  
745 
for(i=0; i<256; i++) { 
746 
v0 = v1 = s0 = s1 = 0.0f; 
747 
for(j=0; j<fbw_channels; j++) { 
748 
v0 += samples[j][i] * coef[j][0];

749 
v1 += samples[j][i] * coef[j][1];

750 
s0 += coef[j][0];

751 
s1 += coef[j][1];

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

756 
samples[0][i] = (v0 + v1) * LEVEL_MINUS_3DB;

757 
} else if(output_mode == AC3_CHMODE_STEREO) { 
758 
samples[0][i] = v0;

759 
samples[1][i] = v1;

760 
} 
761 
} 
762 
} 
763  
764 
/**

765 
* Parse an audio block from AC3 bitstream.

766 
*/

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

770 
int channel_mode = s>channel_mode;

771 
int i, bnd, seg, ch;

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

776  
777 
/* block switch flags */

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

782 
s>dither_all = 1;

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

786 
s>dither_all = 0;

787 
} 
788  
789 
/* dynamic range */

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

792 
if(get_bits1(gbc)) {

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

799  
800 
/* coupling strategy */

801 
if (get_bits1(gbc)) {

802 
memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

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

805 
/* coupling in use */

806 
int cpl_begin_freq, cpl_end_freq;

807  
808 
/* determine which channels are coupled */

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

813 
if (channel_mode == AC3_CHMODE_STEREO)

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

817 
cpl_begin_freq = get_bits(gbc, 4);

818 
cpl_end_freq = get_bits(gbc, 4);

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

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

828 
s>cpl_band_struct[bnd] = 1;

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

833 
/* coupling not in use */

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

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

840 
if (s>cpl_in_use) {

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

845 
if (get_bits1(gbc)) {

846 
int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;

847 
cpl_coords_exist = 1;

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

851 
cpl_coord_mant = get_bits(gbc, 4);

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

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

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

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

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

871 
if (channel_mode == AC3_CHMODE_STEREO) {

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

874 
s>num_rematrixing_bands = 4;

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

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

886 
if(ch == s>lfe_ch)

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

888 
else

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

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

891 
bit_alloc_stages[ch] = 3;

892 
} 
893  
894 
/* channel bandwidth */

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

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

898 
int prev = s>end_freq[ch];

899 
if (s>channel_in_cpl[ch])

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

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

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

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

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

915  
916 
/* decode exponents for each channel */

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

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

919 
int group_size, num_groups;

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

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

925 
else

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

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

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

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

936 
if (get_bits1(gbc)) {

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

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

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

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

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

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

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

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

948 
if (get_bits1(gbc)) {

949 
int csnr;

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

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

956 
} 
957  
958 
/* coupling leak information */

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

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

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

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

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

966 
if (get_bits1(gbc)) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1003 
Apply delta bit allocation */

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

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

1022 
if (get_bits1(gbc)) {

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

1025 
skip_bits(gbc, 8);

1026 
} 
1027  
1028 
/* unpack the transform coefficients

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

1030 
if (get_transform_coeffs(s)) {

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

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

1036 
if(s>channel_mode == AC3_CHMODE_STEREO)

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

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

1043 
gain *= s>dynamic_range[ch1];

1044 
} else {

1045 
gain *= s>dynamic_range[0];

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

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

1056 
s>fbw_channels == s>out_channels)) { 
1057 
ac3_downmix(s>output, s>fbw_channels, s>output_mode, 
1058 
s>downmix_coeffs); 
1059 
} 
1060  
1061 
/* convert float to 16bit integer */

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

1067 
} 
1068  
1069 
return 0; 
1070 
} 
1071  
1072 
/**

1073 
* Decode a single AC3 frame.

1074 
*/

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

1080  
1081 
/* initialize the GetBitContext with the start of valid AC3 Frame */

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

1083  
1084 
/* parse the syncinfo */

1085 
err = ac3_parse_header(s); 
1086 
if(err) {

1087 
switch(err) {

1088 
case AC3_PARSE_ERROR_SYNC:

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

1090 
break;

1091 
case AC3_PARSE_ERROR_BSID:

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

1093 
break;

1094 
case AC3_PARSE_ERROR_SAMPLE_RATE:

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

1096 
break;

1097 
case AC3_PARSE_ERROR_FRAME_SIZE:

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

1099 
break;

1100 
default:

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

1102 
break;

1103 
} 
1104 
return 1; 
1105 
} 
1106  
1107 
avctx>sample_rate = s>sampling_rate; 
1108 
avctx>bit_rate = s>bit_rate; 
1109  
1110 
/* check that reported frame size fits in input buffer */

1111 
if(s>frame_size > buf_size) {

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

1113 
return 1; 
1114 
} 
1115  
1116 
/* channel config */

1117 
s>out_channels = s>channels; 
1118 
if (avctx>request_channels > 0 && avctx>request_channels <= 2 && 
1119 
avctx>request_channels < s>channels) { 
1120 
s>out_channels = avctx>request_channels; 
1121 
s>output_mode = avctx>request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;

1122 
} 
1123 
avctx>channels = s>out_channels; 
1124  
1125 
/* parse the audio blocks */

1126 
for (blk = 0; blk < NB_BLOCKS; blk++) { 
1127 
if (ac3_parse_audio_block(s, blk)) {

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

1129 
*data_size = 0;

1130 
return s>frame_size;

1131 
} 
1132 
for (i = 0; i < 256; i++) 
1133 
for (ch = 0; ch < s>out_channels; ch++) 
1134 
*(out_samples++) = s>int_output[ch][i]; 
1135 
} 
1136 
*data_size = NB_BLOCKS * 256 * avctx>channels * sizeof (int16_t); 
1137 
return s>frame_size;

1138 
} 
1139  
1140 
/**

1141 
* Uninitialize the AC3 decoder.

1142 
*/

1143 
static int ac3_decode_end(AVCodecContext *avctx) 
1144 
{ 
1145 
AC3DecodeContext *s = (AC3DecodeContext *)avctx>priv_data; 
1146 
ff_mdct_end(&s>imdct_512); 
1147 
ff_mdct_end(&s>imdct_256); 
1148  
1149 
return 0; 
1150 
} 
1151  
1152 
AVCodec ac3_decoder = { 
1153 
.name = "ac3",

1154 
.type = CODEC_TYPE_AUDIO, 
1155 
.id = CODEC_ID_AC3, 
1156 
.priv_data_size = sizeof (AC3DecodeContext),

1157 
.init = ac3_decode_init, 
1158 
.close = ac3_decode_end, 
1159 
.decode = ac3_decode_frame, 
1160 
}; 