3 * This code is developed as part of Google Summer of Code 2006 Program.
5 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
6 * Copyright (c) 2007 Justin Ruggles
8 * Portions of this code are derived from liba52
9 * http://liba52.sourceforge.net
10 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
11 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
13 * This file is part of FFmpeg.
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.
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.
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 02110-1301 USA
36 #include "ac3_parser.h"
37 #include "bitstream.h"
42 * Table of bin locations for rematrixing bands
43 * reference: Section 7.5.2 Rematrixing : Frequency Band Definitions
45 static const uint8_t rematrix_band_tab
[5] = { 13, 25, 37, 61, 253 };
48 * table for exponent to scale_factor mapping
49 * scale_factors[i] = 2 ^ -i
51 static float scale_factors
[25];
53 /** table for grouping exponents */
54 static uint8_t exp_ungroup_tab
[128][3];
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];
65 * Quantization table: levels for symmetric. bits for asymmetric.
66 * reference: Table 7.18 Mapping of bap to Quantizer
68 static const uint8_t quantization_tab
[16] = {
70 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
73 /** dynamic range table. converts codes to scale factors. */
74 static float dynamic_range_tab
[256];
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
84 static const float gain_levels
[6] = {
88 LEVEL_MINUS_4POINT5DB
,
94 * Table for center mix levels
95 * reference: Section 5.4.2.4 cmixlev
97 static const uint8_t center_levels
[4] = { 2, 3, 4, 3 };
100 * Table for surround mix levels
101 * reference: Section 5.4.2.5 surmixlev
103 static const uint8_t surround_levels
[4] = { 2, 4, 0, 4 };
106 * Table for default stereo downmixing coefficients
107 * reference: Section 7.8.2 Downmixing Into Two Channels
109 static const uint8_t ac3_default_coeffs
[8][5][2] = {
110 { { 1, 0 }, { 0, 1 }, },
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 }, },
120 /* override ac3.h to include coupling channel */
121 #undef AC3_MAX_CHANNELS
122 #define AC3_MAX_CHANNELS 7
125 #define AC3_OUTPUT_LFEON 8
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
]; ///< signal-to-noise ratio offsets
141 int fast_gain
[AC3_MAX_CHANNELS
]; ///< fast gain values (signal-to-mask 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
148 int sample_rate
; ///< sample frequency, in Hz
149 int bit_rate
; ///< stream bit rate, in bits-per-second
150 int frame_size
; ///< current frame size, in bytes
152 int channels
; ///< number of total channels
153 int fbw_channels
; ///< number of full-bandwidth 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
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
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
174 DECLARE_ALIGNED_16(float, transform_coeffs
[AC3_MAX_CHANNELS
][256]); ///< transform coefficients
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
183 DECLARE_ALIGNED_16(float, output
[AC3_MAX_CHANNELS
-1][256]); ///< output after imdct transform and windowing
184 DECLARE_ALIGNED_16(short, int_output
[AC3_MAX_CHANNELS
-1][256]); ///< final 16-bit integer output
185 DECLARE_ALIGNED_16(float, delay
[AC3_MAX_CHANNELS
-1][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
191 GetBitContext gbc
; ///< bitstream reader
192 AVRandomState dith_state
; ///< for dither generation
193 AVCodecContext
*avctx
; ///< parent context
197 * Generate a Kaiser-Bessel Derived Window.
199 static void ac3_window_init(float *window
)
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);
206 for (i
= 0; i
< 256; i
++) {
207 tmp
= i
* (256 - i
) * alpha2
;
209 for (j
= 100; j
> 0; j
--) /* default to 100 iterations */
210 bessel
= bessel
* tmp
/ (j
* j
) + 1;
212 local_window
[i
] = sum
;
216 for (i
= 0; i
< 256; i
++)
217 window
[i
] = sqrt(local_window
[i
] / sum
);
221 * Symmetrical Dequantization
222 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
223 * Tables 7.19 to 7.23
226 symmetric_dequant(int code
, int levels
)
228 return (code
- (levels
>> 1)) * (2.0f
/ levels
);
232 * Initialize tables at runtime.
234 static void ac3_tables_init(void)
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);
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);
252 /* bap=4 mantissas */
253 b4_mantissas
[i
][0] = symmetric_dequant(i
/ 11, 11);
254 b4_mantissas
[i
][1] = symmetric_dequant(i
% 11, 11);
256 /* generate ungrouped mantissa tables
257 reference: Tables 7.21 and 7.23 */
259 /* bap=3 mantissas */
260 b3_mantissas
[i
] = symmetric_dequant(i
, 7);
262 for(i
=0; i
<15; i
++) {
263 /* bap=5 mantissas */
264 b5_mantissas
[i
] = symmetric_dequant(i
, 15);
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);
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
);
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;
290 * AVCodec initialization
292 static int ac3_decode_init(AVCodecContext
*avctx
)
294 AC3DecodeContext
*s
= avctx
->priv_data
;
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
);
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
;
311 s
->mul_bias
= 32767.0f
;
318 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
319 * GetBitContext within AC3DecodeContext must point to
320 * start of the synchronized ac3 bitstream.
322 static int ac3_parse_header(AC3DecodeContext
*s
)
325 GetBitContext
*gbc
= &s
->gbc
;
326 float center_mix_level
, surround_mix_level
;
329 err
= ff_ac3_parse_header(gbc
->buffer
, &hdr
);
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
->sample_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
;
347 /* set default output to all source channels */
348 s
->out_channels
= s
->channels
;
349 s
->output_mode
= s
->channel_mode
;
351 s
->output_mode
|= AC3_OUTPUT_LFEON
;
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
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
366 skip_bits1(gbc
); // skip lfeon
368 /* read the rest of the bsi. read twice for dual mono mode. */
369 i
= !(s
->channel_mode
);
371 skip_bits(gbc
, 5); // skip dialog normalization
373 skip_bits(gbc
, 8); //skip compression
375 skip_bits(gbc
, 8); //skip language code
377 skip_bits(gbc
, 7); //skip audio production information
380 skip_bits(gbc
, 2); //skip copyright bit and original bitstream bit
382 /* skip the timecodes (or extra bitstream information for Alternate Syntax)
383 TODO: read & use the xbsi1 downmix levels */
385 skip_bits(gbc
, 14); //skip timecode1 / xbsi1
387 skip_bits(gbc
, 14); //skip timecode2 / xbsi2
389 /* skip additional bitstream info */
390 if (get_bits1(gbc
)) {
391 i
= get_bits(gbc
, 6);
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]];
403 if(s
->channel_mode
> 1 && s
->channel_mode
& 1) {
404 s
->downmix_coeffs
[1][0] = s
->downmix_coeffs
[1][1] = center_mix_level
;
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
;
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
;
419 * Decode the grouped exponents according to exponent strategy.
420 * reference: Section 7.1.3 Exponent Decoding
422 static void decode_exponents(GetBitContext
*gbc
, int exp_strategy
, int ngrps
,
423 uint8_t absexp
, int8_t *dexps
)
425 int i
, j
, grp
, group_size
;
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];
438 /* convert to absolute exps and expand groups */
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
;
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
453 static void uncouple_channels(AC3DecodeContext
*s
)
455 int i
, j
, ch
, bnd
, subbnd
;
458 i
= s
->start_freq
[CPL_CH
];
459 for(bnd
=0; bnd
<s
->num_cpl_bands
; bnd
++) {
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
;
469 } while(s
->cpl_band_struct
[subbnd
]);
474 * Grouped mantissas for 3-level 5-level and 11-level quantization
486 * Get the transform coefficients for a particular channel
487 * reference: Section 7.3 Quantization and Decoding of Mantissas
489 static int get_transform_coeffs_ch(AC3DecodeContext
*s
, int ch_index
, mant_groups
*m
)
491 GetBitContext
*gbc
= &s
->gbc
;
492 int i
, gcode
, tbap
, start
, end
;
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
];
503 for (i
= start
; i
< end
; i
++) {
507 coeffs
[i
] = ((av_random(&s
->dith_state
) & 0xFFFF) / 65535.0f
) - 0.5f
;
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];
518 coeffs
[i
] = m
->b1_mant
[m
->b1ptr
++];
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];
529 coeffs
[i
] = m
->b2_mant
[m
->b2ptr
++];
533 coeffs
[i
] = b3_mantissas
[get_bits(gbc
, 3)];
538 gcode
= get_bits(gbc
, 7);
539 m
->b4_mant
[0] = b4_mantissas
[gcode
][0];
540 m
->b4_mant
[1] = b4_mantissas
[gcode
][1];
543 coeffs
[i
] = m
->b4_mant
[m
->b4ptr
++];
547 coeffs
[i
] = b5_mantissas
[get_bits(gbc
, 4)];
551 /* asymmetric dequantization */
552 coeffs
[i
] = get_sbits(gbc
, quantization_tab
[tbap
]) * scale_factors
[quantization_tab
[tbap
]-1];
555 coeffs
[i
] *= scale_factors
[exps
[i
]];
562 * Remove random dithering from coefficients with zero-bit mantissas
563 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
565 static void remove_dithering(AC3DecodeContext
*s
) {
571 for(ch
=1; ch
<=s
->fbw_channels
; ch
++) {
572 if(!s
->dither_flag
[ch
]) {
573 coeffs
= s
->transform_coeffs
[ch
];
575 if(s
->channel_in_cpl
[ch
])
576 end
= s
->start_freq
[CPL_CH
];
578 end
= s
->end_freq
[ch
];
579 for(i
=0; i
<end
; i
++) {
583 if(s
->channel_in_cpl
[ch
]) {
584 bap
= s
->bap
[CPL_CH
];
585 for(; i
<s
->end_freq
[CPL_CH
]; i
++) {
595 * Get the transform coefficients.
597 static int get_transform_coeffs(AC3DecodeContext
*s
)
603 m
.b1ptr
= m
.b2ptr
= m
.b4ptr
= 3;
605 for (ch
= 1; ch
<= s
->channels
; ch
++) {
606 /* transform coefficients for full-bandwidth channel */
607 if (get_transform_coeffs_ch(s
, ch
, &m
))
609 /* tranform coefficients for coupling channel come right after the
610 coefficients for the first coupled channel*/
611 if (s
->channel_in_cpl
[ch
]) {
613 if (get_transform_coeffs_ch(s
, CPL_CH
, &m
)) {
614 av_log(s
->avctx
, AV_LOG_ERROR
, "error in decoupling channels\n");
617 uncouple_channels(s
);
620 end
= s
->end_freq
[CPL_CH
];
622 end
= s
->end_freq
[ch
];
625 s
->transform_coeffs
[ch
][end
] = 0;
629 /* if any channel doesn't use dithering, zero appropriate coefficients */
637 * Stereo rematrixing.
638 * reference: Section 7.5.4 Rematrixing : Decoding Technique
640 static void do_rematrixing(AC3DecodeContext
*s
)
646 end
= FFMIN(s
->end_freq
[1], s
->end_freq
[2]);
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
;
662 * Perform the 256-point IMDCT
664 static void do_imdct_256(AC3DecodeContext
*s
, int chindex
)
667 DECLARE_ALIGNED_16(float, x
[128]);
669 float *o_ptr
= s
->tmp_output
;
672 /* de-interleave coefficients */
673 for(k
=0; k
<128; k
++) {
674 x
[k
] = s
->transform_coeffs
[chindex
][2*k
+i
];
677 /* run standard IMDCT */
678 s
->imdct_256
.fft
.imdct_calc(&s
->imdct_256
, o_ptr
, x
, s
->tmp_imdct
);
680 /* reverse the post-rotation & 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
][31-k
].re
= o_ptr
[2*k
+1];
685 z
[i
][31-k
].im
= o_ptr
[128+2*k
+1];
689 /* apply AC-3 post-rotation & 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][63-k
].re
;
693 o_ptr
[128+2*k
] = -z
[0][ k
].re
;
694 o_ptr
[128+2*k
+1] = z
[0][63-k
].im
;
695 o_ptr
[256+2*k
] = -z
[1][ k
].re
;
696 o_ptr
[256+2*k
+1] = z
[1][63-k
].im
;
697 o_ptr
[384+2*k
] = z
[1][ k
].im
;
698 o_ptr
[384+2*k
+1] = -z
[1][63-k
].re
;
703 * Inverse MDCT Transform.
704 * Convert frequency domain coefficients to time-domain audio samples.
705 * reference: Section 7.9.4 Transformation Equations
707 static inline void do_imdct(AC3DecodeContext
*s
)
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
)
717 for (ch
=1; ch
<=channels
; ch
++) {
718 if (s
->block_switch
[ch
]) {
721 s
->imdct_512
.fft
.imdct_calc(&s
->imdct_512
, s
->tmp_output
,
722 s
->transform_coeffs
[ch
], s
->tmp_imdct
);
724 /* For the first half of the block, apply the window, add the delay
725 from the previous block, and send to output */
726 s
->dsp
.vector_fmul_add_add(s
->output
[ch
-1], s
->tmp_output
,
727 s
->window
, s
->delay
[ch
-1], 0, 256, 1);
728 /* For the second half of the block, apply the window and store the
729 samples to delay, to be combined with the next block */
730 s
->dsp
.vector_fmul_reverse(s
->delay
[ch
-1], s
->tmp_output
+256,
736 * Downmix the output to mono or stereo.
738 static void ac3_downmix(AC3DecodeContext
*s
)
741 float v0
, v1
, s0
, s1
;
743 for(i
=0; i
<256; i
++) {
744 v0
= v1
= s0
= s1
= 0.0f
;
745 for(j
=0; j
<s
->fbw_channels
; j
++) {
746 v0
+= s
->output
[j
][i
] * s
->downmix_coeffs
[j
][0];
747 v1
+= s
->output
[j
][i
] * s
->downmix_coeffs
[j
][1];
748 s0
+= s
->downmix_coeffs
[j
][0];
749 s1
+= s
->downmix_coeffs
[j
][1];
753 if(s
->output_mode
== AC3_CHMODE_MONO
) {
754 s
->output
[0][i
] = (v0
+ v1
) * LEVEL_MINUS_3DB
;
755 } else if(s
->output_mode
== AC3_CHMODE_STEREO
) {
756 s
->output
[0][i
] = v0
;
757 s
->output
[1][i
] = v1
;
763 * Parse an audio block from AC-3 bitstream.
765 static int ac3_parse_audio_block(AC3DecodeContext
*s
, int blk
)
767 int fbw_channels
= s
->fbw_channels
;
768 int channel_mode
= s
->channel_mode
;
770 GetBitContext
*gbc
= &s
->gbc
;
771 uint8_t bit_alloc_stages
[AC3_MAX_CHANNELS
];
773 memset(bit_alloc_stages
, 0, AC3_MAX_CHANNELS
);
775 /* block switch flags */
776 for (ch
= 1; ch
<= fbw_channels
; ch
++)
777 s
->block_switch
[ch
] = get_bits1(gbc
);
779 /* dithering flags */
781 for (ch
= 1; ch
<= fbw_channels
; ch
++) {
782 s
->dither_flag
[ch
] = get_bits1(gbc
);
783 if(!s
->dither_flag
[ch
])
788 i
= !(s
->channel_mode
);
791 s
->dynamic_range
[i
] = ((dynamic_range_tab
[get_bits(gbc
, 8)]-1.0) *
792 s
->avctx
->drc_scale
)+1.0;
793 } else if(blk
== 0) {
794 s
->dynamic_range
[i
] = 1.0f
;
798 /* coupling strategy */
799 if (get_bits1(gbc
)) {
800 memset(bit_alloc_stages
, 3, AC3_MAX_CHANNELS
);
801 s
->cpl_in_use
= get_bits1(gbc
);
803 /* coupling in use */
804 int cpl_begin_freq
, cpl_end_freq
;
806 /* determine which channels are coupled */
807 for (ch
= 1; ch
<= fbw_channels
; ch
++)
808 s
->channel_in_cpl
[ch
] = get_bits1(gbc
);
810 /* phase flags in use */
811 if (channel_mode
== AC3_CHMODE_STEREO
)
812 s
->phase_flags_in_use
= get_bits1(gbc
);
814 /* coupling frequency range and band structure */
815 cpl_begin_freq
= get_bits(gbc
, 4);
816 cpl_end_freq
= get_bits(gbc
, 4);
817 if (3 + cpl_end_freq
- cpl_begin_freq
< 0) {
818 av_log(s
->avctx
, AV_LOG_ERROR
, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq
, cpl_begin_freq
);
821 s
->num_cpl_bands
= s
->num_cpl_subbands
= 3 + cpl_end_freq
- cpl_begin_freq
;
822 s
->start_freq
[CPL_CH
] = cpl_begin_freq
* 12 + 37;
823 s
->end_freq
[CPL_CH
] = cpl_end_freq
* 12 + 73;
824 for (bnd
= 0; bnd
< s
->num_cpl_subbands
- 1; bnd
++) {
825 if (get_bits1(gbc
)) {
826 s
->cpl_band_struct
[bnd
] = 1;
831 /* coupling not in use */
832 for (ch
= 1; ch
<= fbw_channels
; ch
++)
833 s
->channel_in_cpl
[ch
] = 0;
837 /* coupling coordinates */
839 int cpl_coords_exist
= 0;
841 for (ch
= 1; ch
<= fbw_channels
; ch
++) {
842 if (s
->channel_in_cpl
[ch
]) {
843 if (get_bits1(gbc
)) {
844 int master_cpl_coord
, cpl_coord_exp
, cpl_coord_mant
;
845 cpl_coords_exist
= 1;
846 master_cpl_coord
= 3 * get_bits(gbc
, 2);
847 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
848 cpl_coord_exp
= get_bits(gbc
, 4);
849 cpl_coord_mant
= get_bits(gbc
, 4);
850 if (cpl_coord_exp
== 15)
851 s
->cpl_coords
[ch
][bnd
] = cpl_coord_mant
/ 16.0f
;
853 s
->cpl_coords
[ch
][bnd
] = (cpl_coord_mant
+ 16.0f
) / 32.0f
;
854 s
->cpl_coords
[ch
][bnd
] *= scale_factors
[cpl_coord_exp
+ master_cpl_coord
];
860 if (channel_mode
== AC3_CHMODE_STEREO
&& s
->phase_flags_in_use
&& cpl_coords_exist
) {
861 for (bnd
= 0; bnd
< s
->num_cpl_bands
; bnd
++) {
863 s
->cpl_coords
[2][bnd
] = -s
->cpl_coords
[2][bnd
];
868 /* stereo rematrixing strategy and band structure */
869 if (channel_mode
== AC3_CHMODE_STEREO
) {
870 s
->rematrixing_strategy
= get_bits1(gbc
);
871 if (s
->rematrixing_strategy
) {
872 s
->num_rematrixing_bands
= 4;
873 if(s
->cpl_in_use
&& s
->start_freq
[CPL_CH
] <= 61)
874 s
->num_rematrixing_bands
-= 1 + (s
->start_freq
[CPL_CH
] == 37);
875 for(bnd
=0; bnd
<s
->num_rematrixing_bands
; bnd
++)
876 s
->rematrixing_flags
[bnd
] = get_bits1(gbc
);
880 /* exponent strategies for each channel */
881 s
->exp_strategy
[CPL_CH
] = EXP_REUSE
;
882 s
->exp_strategy
[s
->lfe_ch
] = EXP_REUSE
;
883 for (ch
= !s
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
885 s
->exp_strategy
[ch
] = get_bits(gbc
, 1);
887 s
->exp_strategy
[ch
] = get_bits(gbc
, 2);
888 if(s
->exp_strategy
[ch
] != EXP_REUSE
)
889 bit_alloc_stages
[ch
] = 3;
892 /* channel bandwidth */
893 for (ch
= 1; ch
<= fbw_channels
; ch
++) {
894 s
->start_freq
[ch
] = 0;
895 if (s
->exp_strategy
[ch
] != EXP_REUSE
) {
896 int prev
= s
->end_freq
[ch
];
897 if (s
->channel_in_cpl
[ch
])
898 s
->end_freq
[ch
] = s
->start_freq
[CPL_CH
];
900 int bandwidth_code
= get_bits(gbc
, 6);
901 if (bandwidth_code
> 60) {
902 av_log(s
->avctx
, AV_LOG_ERROR
, "bandwidth code = %d > 60", bandwidth_code
);
905 s
->end_freq
[ch
] = bandwidth_code
* 3 + 73;
907 if(blk
> 0 && s
->end_freq
[ch
] != prev
)
908 memset(bit_alloc_stages
, 3, AC3_MAX_CHANNELS
);
911 s
->start_freq
[s
->lfe_ch
] = 0;
912 s
->end_freq
[s
->lfe_ch
] = 7;
914 /* decode exponents for each channel */
915 for (ch
= !s
->cpl_in_use
; ch
<= s
->channels
; ch
++) {
916 if (s
->exp_strategy
[ch
] != EXP_REUSE
) {
917 int group_size
, num_groups
;
918 group_size
= 3 << (s
->exp_strategy
[ch
] - 1);
920 num_groups
= (s
->end_freq
[ch
] - s
->start_freq
[ch
]) / group_size
;
921 else if(ch
== s
->lfe_ch
)
924 num_groups
= (s
->end_freq
[ch
] + group_size
- 4) / group_size
;
925 s
->dexps
[ch
][0] = get_bits(gbc
, 4) << !ch
;
926 decode_exponents(gbc
, s
->exp_strategy
[ch
], num_groups
, s
->dexps
[ch
][0],
927 &s
->dexps
[ch
][s
->start_freq
[ch
]+!!ch
]);
928 if(ch
!= CPL_CH
&& ch
!= s
->lfe_ch
)
929 skip_bits(gbc
, 2); /* skip gainrng */
933 /* bit allocation information */
934 if (get_bits1(gbc
)) {
935 s
->bit_alloc_params
.slow_decay
= ff_ac3_slow_decay_tab
[get_bits(gbc
, 2)] >> s
->bit_alloc_params
.sr_shift
;
936 s
->bit_alloc_params
.fast_decay
= ff_ac3_fast_decay_tab
[get_bits(gbc
, 2)] >> s
->bit_alloc_params
.sr_shift
;
937 s
->bit_alloc_params
.slow_gain
= ff_ac3_slow_gain_tab
[get_bits(gbc
, 2)];
938 s
->bit_alloc_params
.db_per_bit
= ff_ac3_db_per_bit_tab
[get_bits(gbc
, 2)];
939 s
->bit_alloc_params
.floor
= ff_ac3_floor_tab
[get_bits(gbc
, 3)];
940 for(ch
=!s
->cpl_in_use
; ch
<=s
->channels
; ch
++) {
941 bit_alloc_stages
[ch
] = FFMAX(bit_alloc_stages
[ch
], 2);
945 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
946 if (get_bits1(gbc
)) {
948 csnr
= (get_bits(gbc
, 6) - 15) << 4;
949 for (ch
= !s
->cpl_in_use
; ch
<= s
->channels
; ch
++) { /* snr offset and fast gain */
950 s
->snr_offset
[ch
] = (csnr
+ get_bits(gbc
, 4)) << 2;
951 s
->fast_gain
[ch
] = ff_ac3_fast_gain_tab
[get_bits(gbc
, 3)];
953 memset(bit_alloc_stages
, 3, AC3_MAX_CHANNELS
);
956 /* coupling leak information */
957 if (s
->cpl_in_use
&& get_bits1(gbc
)) {
958 s
->bit_alloc_params
.cpl_fast_leak
= get_bits(gbc
, 3);
959 s
->bit_alloc_params
.cpl_slow_leak
= get_bits(gbc
, 3);
960 bit_alloc_stages
[CPL_CH
] = FFMAX(bit_alloc_stages
[CPL_CH
], 2);
963 /* delta bit allocation information */
964 if (get_bits1(gbc
)) {
965 /* delta bit allocation exists (strategy) */
966 for (ch
= !s
->cpl_in_use
; ch
<= fbw_channels
; ch
++) {
967 s
->dba_mode
[ch
] = get_bits(gbc
, 2);
968 if (s
->dba_mode
[ch
] == DBA_RESERVED
) {
969 av_log(s
->avctx
, AV_LOG_ERROR
, "delta bit allocation strategy reserved\n");
972 bit_alloc_stages
[ch
] = FFMAX(bit_alloc_stages
[ch
], 2);
974 /* channel delta offset, len and bit allocation */
975 for (ch
= !s
->cpl_in_use
; ch
<= fbw_channels
; ch
++) {
976 if (s
->dba_mode
[ch
] == DBA_NEW
) {
977 s
->dba_nsegs
[ch
] = get_bits(gbc
, 3);
978 for (seg
= 0; seg
<= s
->dba_nsegs
[ch
]; seg
++) {
979 s
->dba_offsets
[ch
][seg
] = get_bits(gbc
, 5);
980 s
->dba_lengths
[ch
][seg
] = get_bits(gbc
, 4);
981 s
->dba_values
[ch
][seg
] = get_bits(gbc
, 3);
985 } else if(blk
== 0) {
986 for(ch
=0; ch
<=s
->channels
; ch
++) {
987 s
->dba_mode
[ch
] = DBA_NONE
;
992 for(ch
=!s
->cpl_in_use
; ch
<=s
->channels
; ch
++) {
993 if(bit_alloc_stages
[ch
] > 2) {
994 /* Exponent mapping into PSD and PSD integration */
995 ff_ac3_bit_alloc_calc_psd(s
->dexps
[ch
],
996 s
->start_freq
[ch
], s
->end_freq
[ch
],
997 s
->psd
[ch
], s
->band_psd
[ch
]);
999 if(bit_alloc_stages
[ch
] > 1) {
1000 /* Compute excitation function, Compute masking curve, and
1001 Apply delta bit allocation */
1002 ff_ac3_bit_alloc_calc_mask(&s
->bit_alloc_params
, s
->band_psd
[ch
],
1003 s
->start_freq
[ch
], s
->end_freq
[ch
],
1004 s
->fast_gain
[ch
], (ch
== s
->lfe_ch
),
1005 s
->dba_mode
[ch
], s
->dba_nsegs
[ch
],
1006 s
->dba_offsets
[ch
], s
->dba_lengths
[ch
],
1007 s
->dba_values
[ch
], s
->mask
[ch
]);
1009 if(bit_alloc_stages
[ch
] > 0) {
1010 /* Compute bit allocation */
1011 ff_ac3_bit_alloc_calc_bap(s
->mask
[ch
], s
->psd
[ch
],
1012 s
->start_freq
[ch
], s
->end_freq
[ch
],
1014 s
->bit_alloc_params
.floor
,
1019 /* unused dummy data */
1020 if (get_bits1(gbc
)) {
1021 int skipl
= get_bits(gbc
, 9);
1026 /* unpack the transform coefficients
1027 this also uncouples channels if coupling is in use. */
1028 if (get_transform_coeffs(s
)) {
1029 av_log(s
->avctx
, AV_LOG_ERROR
, "Error in routine get_transform_coeffs\n");
1033 /* recover coefficients if rematrixing is in use */
1034 if(s
->channel_mode
== AC3_CHMODE_STEREO
)
1037 /* apply scaling to coefficients (headroom, dynrng) */
1038 for(ch
=1; ch
<=s
->channels
; ch
++) {
1039 float gain
= 2.0f
* s
->mul_bias
;
1040 if(s
->channel_mode
== AC3_CHMODE_DUALMONO
) {
1041 gain
*= s
->dynamic_range
[ch
-1];
1043 gain
*= s
->dynamic_range
[0];
1045 for(i
=0; i
<s
->end_freq
[ch
]; i
++) {
1046 s
->transform_coeffs
[ch
][i
] *= gain
;
1052 /* downmix output if needed */
1053 if(s
->channels
!= s
->out_channels
&& !((s
->output_mode
& AC3_OUTPUT_LFEON
) &&
1054 s
->fbw_channels
== s
->out_channels
)) {
1058 /* convert float to 16-bit integer */
1059 for(ch
=0; ch
<s
->out_channels
; ch
++) {
1060 for(i
=0; i
<256; i
++) {
1061 s
->output
[ch
][i
] += s
->add_bias
;
1063 s
->dsp
.float_to_int16(s
->int_output
[ch
], s
->output
[ch
], 256);
1070 * Decode a single AC-3 frame.
1072 static int ac3_decode_frame(AVCodecContext
* avctx
, void *data
, int *data_size
, uint8_t *buf
, int buf_size
)
1074 AC3DecodeContext
*s
= avctx
->priv_data
;
1075 int16_t *out_samples
= (int16_t *)data
;
1076 int i
, blk
, ch
, err
;
1078 /* initialize the GetBitContext with the start of valid AC-3 Frame */
1079 init_get_bits(&s
->gbc
, buf
, buf_size
* 8);
1081 /* parse the syncinfo */
1082 err
= ac3_parse_header(s
);
1085 case AC3_PARSE_ERROR_SYNC
:
1086 av_log(avctx
, AV_LOG_ERROR
, "frame sync error\n");
1088 case AC3_PARSE_ERROR_BSID
:
1089 av_log(avctx
, AV_LOG_ERROR
, "invalid bitstream id\n");
1091 case AC3_PARSE_ERROR_SAMPLE_RATE
:
1092 av_log(avctx
, AV_LOG_ERROR
, "invalid sample rate\n");
1094 case AC3_PARSE_ERROR_FRAME_SIZE
:
1095 av_log(avctx
, AV_LOG_ERROR
, "invalid frame size\n");
1098 av_log(avctx
, AV_LOG_ERROR
, "invalid header\n");
1104 avctx
->sample_rate
= s
->sample_rate
;
1105 avctx
->bit_rate
= s
->bit_rate
;
1107 /* check that reported frame size fits in input buffer */
1108 if(s
->frame_size
> buf_size
) {
1109 av_log(avctx
, AV_LOG_ERROR
, "incomplete frame\n");
1113 /* channel config */
1114 s
->out_channels
= s
->channels
;
1115 if (avctx
->request_channels
> 0 && avctx
->request_channels
<= 2 &&
1116 avctx
->request_channels
< s
->channels
) {
1117 s
->out_channels
= avctx
->request_channels
;
1118 s
->output_mode
= avctx
->request_channels
== 1 ? AC3_CHMODE_MONO
: AC3_CHMODE_STEREO
;
1120 avctx
->channels
= s
->out_channels
;
1122 /* parse the audio blocks */
1123 for (blk
= 0; blk
< NB_BLOCKS
; blk
++) {
1124 if (ac3_parse_audio_block(s
, blk
)) {
1125 av_log(avctx
, AV_LOG_ERROR
, "error parsing the audio block\n");
1127 return s
->frame_size
;
1129 for (i
= 0; i
< 256; i
++)
1130 for (ch
= 0; ch
< s
->out_channels
; ch
++)
1131 *(out_samples
++) = s
->int_output
[ch
][i
];
1133 *data_size
= NB_BLOCKS
* 256 * avctx
->channels
* sizeof (int16_t);
1134 return s
->frame_size
;
1138 * Uninitialize the AC-3 decoder.
1140 static int ac3_decode_end(AVCodecContext
*avctx
)
1142 AC3DecodeContext
*s
= avctx
->priv_data
;
1143 ff_mdct_end(&s
->imdct_512
);
1144 ff_mdct_end(&s
->imdct_256
);
1149 AVCodec ac3_decoder
= {
1151 .type
= CODEC_TYPE_AUDIO
,
1153 .priv_data_size
= sizeof (AC3DecodeContext
),
1154 .init
= ac3_decode_init
,
1155 .close
= ac3_decode_end
,
1156 .decode
= ac3_decode_frame
,