3 * Copyright (c) 2007 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
4 * Copyright (c) 2008 Justin Ruggles
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "ac3_parser.h"
28 #include "ac3dec_data.h"
30 /** gain adaptive quantization mode */
38 #define EAC3_SR_CODE_REDUCED 3
40 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
41 #define COEFF_0 10273905LL
43 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
44 #define COEFF_1 11863283LL
46 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
47 #define COEFF_2 3070444LL
50 * Calculate 6-point IDCT of the pre-mantissas.
51 * All calculations are 24-bit fixed-point.
53 static void idct6(int pre_mant[6])
56 int even0, even1, even2, odd0, odd1, odd2;
58 odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
60 even2 = ( pre_mant[2] * COEFF_0) >> 23;
61 tmp = ( pre_mant[4] * COEFF_1) >> 23;
62 odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
64 even0 = pre_mant[0] + (tmp >> 1);
65 even1 = pre_mant[0] - tmp;
72 odd0 = tmp + pre_mant[1] + pre_mant[3];
73 odd2 = tmp + pre_mant[5] - pre_mant[3];
75 pre_mant[0] = even0 + odd0;
76 pre_mant[1] = even1 + odd1;
77 pre_mant[2] = even2 + odd2;
78 pre_mant[3] = even2 - odd2;
79 pre_mant[4] = even1 - odd1;
80 pre_mant[5] = even0 - odd0;
83 void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
86 int end_bap, gaq_mode;
87 GetBitContext *gbc = &s->gbc;
88 int gaq_gain[AC3_MAX_COEFS];
90 gaq_mode = get_bits(gbc, 2);
91 end_bap = (gaq_mode < 2) ? 12 : 17;
93 /* if GAQ gain is used, decode gain codes for bins with hebap between
96 if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
97 /* read 1-bit GAQ gain codes */
98 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
99 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
100 gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
102 } else if (gaq_mode == EAC3_GAQ_124) {
103 /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
105 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
106 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
108 int group_code = get_bits(gbc, 5);
109 if (group_code > 26) {
110 av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
113 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
114 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
115 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
123 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
124 int hebap = s->bap[ch][bin];
125 int bits = ff_eac3_bits_vs_hebap[hebap];
127 /* zero-mantissa dithering */
128 for (blk = 0; blk < 6; blk++) {
129 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
131 } else if (hebap < 8) {
132 /* Vector Quantization */
133 int v = get_bits(gbc, bits);
134 for (blk = 0; blk < 6; blk++) {
135 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
138 /* Gain Adaptive Quantization */
140 if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
141 log_gain = gaq_gain[gs++];
145 gbits = bits - log_gain;
147 for (blk = 0; blk < 6; blk++) {
148 int mant = get_sbits(gbc, gbits);
149 if (mant == -(1 << (gbits-1))) {
152 mant = get_sbits(gbc, bits-2+log_gain) << (26-log_gain-bits);
153 /* remap mantissa value to correct for asymmetric quantization */
155 b = 32768 >> (log_gain+8);
157 b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1];
158 mant += (ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (mant>>8) + b) >> 7;
160 /* small mantissa, no GAQ, or Gk=1 */
163 /* remap mantissa value for no GAQ or Gk=1 */
164 mant += (ff_eac3_gaq_remap_1[hebap-8] * (mant>>8)) >> 7;
167 s->pre_mantissa[ch][bin][blk] = mant;
170 idct6(s->pre_mantissa[ch][bin]);
174 int ff_eac3_parse_header(AC3DecodeContext *s)
177 int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
178 int parse_transient_proc_info;
180 GetBitContext *gbc = &s->gbc;
182 /* An E-AC-3 stream can have multiple independent streams which the
183 application can select from. each independent stream can also contain
184 dependent streams which are used to add or replace channels. */
185 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
186 ff_log_missing_feature(s->avctx, "Dependent substream decoding", 1);
187 return AC3_PARSE_ERROR_FRAME_TYPE;
188 } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
189 av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
190 return AC3_PARSE_ERROR_FRAME_TYPE;
193 /* The substream id indicates which substream this frame belongs to. each
194 independent stream has its own substream id, and the dependent streams
195 associated to an independent stream have matching substream id's. */
196 if (s->substreamid) {
197 /* only decode substream with id=0. skip any additional substreams. */
198 ff_log_missing_feature(s->avctx, "Additional substreams", 1);
199 return AC3_PARSE_ERROR_FRAME_TYPE;
202 if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {
203 /* The E-AC-3 specification does not tell how to handle reduced sample
204 rates in bit allocation. The best assumption would be that it is
205 handled like AC-3 DolbyNet, but we cannot be sure until we have a
206 sample which utilizes this feature. */
207 ff_log_missing_feature(s->avctx, "Reduced sampling rates", 1);
210 skip_bits(gbc, 5); // skip bitstream id
212 /* volume control params */
213 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
214 skip_bits(gbc, 5); // skip dialog normalization
215 if (get_bits1(gbc)) {
216 skip_bits(gbc, 8); // skip compression gain word
220 /* dependent stream channel map */
221 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) {
222 if (get_bits1(gbc)) {
223 skip_bits(gbc, 16); // skip custom channel map
227 /* mixing metadata */
228 if (get_bits1(gbc)) {
229 /* center and surround mix levels */
230 if (s->channel_mode > AC3_CHMODE_STEREO) {
231 skip_bits(gbc, 2); // skip preferred stereo downmix mode
232 if (s->channel_mode & 1) {
233 /* if three front channels exist */
234 skip_bits(gbc, 3); //skip Lt/Rt center mix level
235 s->center_mix_level = get_bits(gbc, 3);
237 if (s->channel_mode & 4) {
238 /* if a surround channel exists */
239 skip_bits(gbc, 3); //skip Lt/Rt surround mix level
240 s->surround_mix_level = get_bits(gbc, 3);
245 if (s->lfe_on && get_bits1(gbc)) {
246 // TODO: use LFE mix level
247 skip_bits(gbc, 5); // skip LFE mix level code
250 /* info for mixing with other streams and substreams */
251 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
252 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
253 // TODO: apply program scale factor
254 if (get_bits1(gbc)) {
255 skip_bits(gbc, 6); // skip program scale factor
258 if (get_bits1(gbc)) {
259 skip_bits(gbc, 6); // skip external program scale factor
261 /* skip mixing parameter data */
262 switch(get_bits(gbc, 2)) {
263 case 1: skip_bits(gbc, 5); break;
264 case 2: skip_bits(gbc, 12); break;
266 int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
267 skip_bits_long(gbc, mix_data_size);
271 /* skip pan information for mono or dual mono source */
272 if (s->channel_mode < AC3_CHMODE_STEREO) {
273 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
274 if (get_bits1(gbc)) {
275 /* note: this is not in the ATSC A/52B specification
276 reference: ETSI TS 102 366 V1.1.1
277 section: E.1.3.1.25 */
278 skip_bits(gbc, 8); // skip pan mean direction index
279 skip_bits(gbc, 6); // skip reserved paninfo bits
283 /* skip mixing configuration information */
284 if (get_bits1(gbc)) {
285 for (blk = 0; blk < s->num_blocks; blk++) {
286 if (s->num_blocks == 1 || get_bits1(gbc)) {
294 /* informational metadata */
295 if (get_bits1(gbc)) {
296 skip_bits(gbc, 3); // skip bit stream mode
297 skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
298 if (s->channel_mode == AC3_CHMODE_STEREO) {
299 skip_bits(gbc, 4); // skip Dolby surround and headphone mode
301 if (s->channel_mode >= AC3_CHMODE_2F2R) {
302 skip_bits(gbc, 2); // skip Dolby surround EX mode
304 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
305 if (get_bits1(gbc)) {
306 skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
309 if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) {
310 skip_bits1(gbc); // skip source sample rate code
314 /* converter synchronization flag
315 If frames are less than six blocks, this bit should be turned on
316 once every 6 blocks to indicate the start of a frame set.
317 reference: RFC 4598, Section 2.1.3 Frame Sets */
318 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
319 skip_bits1(gbc); // skip converter synchronization flag
322 /* original frame size code if this stream was converted from AC-3 */
323 if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT &&
324 (s->num_blocks == 6 || get_bits1(gbc))) {
325 skip_bits(gbc, 6); // skip frame size code
328 /* additional bitstream info */
329 if (get_bits1(gbc)) {
330 int addbsil = get_bits(gbc, 6);
331 for (i = 0; i < addbsil + 1; i++) {
332 skip_bits(gbc, 8); // skip additional bit stream info
336 /* audio frame syntax flags, strategy data, and per-frame data */
338 if (s->num_blocks == 6) {
339 ac3_exponent_strategy = get_bits1(gbc);
340 parse_aht_info = get_bits1(gbc);
342 /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
344 ac3_exponent_strategy = 1;
348 s->snr_offset_strategy = get_bits(gbc, 2);
349 parse_transient_proc_info = get_bits1(gbc);
351 s->block_switch_syntax = get_bits1(gbc);
352 if (!s->block_switch_syntax)
353 memset(s->block_switch, 0, sizeof(s->block_switch));
355 s->dither_flag_syntax = get_bits1(gbc);
356 if (!s->dither_flag_syntax) {
357 for (ch = 1; ch <= s->fbw_channels; ch++)
358 s->dither_flag[ch] = 1;
360 s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
362 s->bit_allocation_syntax = get_bits1(gbc);
363 if (!s->bit_allocation_syntax) {
364 /* set default bit allocation parameters */
365 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];
366 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];
367 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];
368 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];
369 s->bit_alloc_params.floor = ff_ac3_floor_tab [7];
372 s->fast_gain_syntax = get_bits1(gbc);
373 s->dba_syntax = get_bits1(gbc);
374 s->skip_syntax = get_bits1(gbc);
375 parse_spx_atten_data = get_bits1(gbc);
377 /* coupling strategy occurance and coupling use per block */
379 if (s->channel_mode > 1) {
380 for (blk = 0; blk < s->num_blocks; blk++) {
381 s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
382 if (s->cpl_strategy_exists[blk]) {
383 s->cpl_in_use[blk] = get_bits1(gbc);
385 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
387 num_cpl_blocks += s->cpl_in_use[blk];
390 memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
393 /* exponent strategy data */
394 if (ac3_exponent_strategy) {
395 /* AC-3-style exponent strategy syntax */
396 for (blk = 0; blk < s->num_blocks; blk++) {
397 for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
398 s->exp_strategy[blk][ch] = get_bits(gbc, 2);
402 /* LUT-based exponent strategy syntax */
403 for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
404 int frmchexpstr = get_bits(gbc, 5);
405 for (blk = 0; blk < 6; blk++) {
406 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
410 /* LFE exponent strategy */
412 for (blk = 0; blk < s->num_blocks; blk++) {
413 s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
416 /* original exponent strategies if this stream was converted from AC-3 */
417 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&
418 (s->num_blocks == 6 || get_bits1(gbc))) {
419 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
422 /* determine which channels use AHT */
423 if (parse_aht_info) {
424 /* For AHT to be used, all non-zero blocks must reuse exponents from
425 the first block. Furthermore, for AHT to be used in the coupling
426 channel, all blocks must use coupling and use the same coupling
428 s->channel_uses_aht[CPL_CH]=0;
429 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
431 for (blk = 1; blk < 6; blk++) {
432 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
433 (!ch && s->cpl_strategy_exists[blk])) {
438 s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
441 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
444 /* per-frame SNR offset */
445 if (!s->snr_offset_strategy) {
446 int csnroffst = (get_bits(gbc, 6) - 15) << 4;
447 int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
448 for (ch = 0; ch <= s->channels; ch++)
449 s->snr_offset[ch] = snroffst;
452 /* transient pre-noise processing data */
453 if (parse_transient_proc_info) {
454 for (ch = 1; ch <= s->fbw_channels; ch++) {
455 if (get_bits1(gbc)) { // channel in transient processing
456 skip_bits(gbc, 10); // skip transient processing location
457 skip_bits(gbc, 8); // skip transient processing length
462 /* spectral extension attenuation data */
463 if (parse_spx_atten_data) {
464 ff_log_missing_feature(s->avctx, "Spectral extension attenuation", 1);
465 for (ch = 1; ch <= s->fbw_channels; ch++) {
466 if (get_bits1(gbc)) { // channel has spx attenuation
467 skip_bits(gbc, 5); // skip spx attenuation code
472 /* block start information */
473 if (s->num_blocks > 1 && get_bits1(gbc)) {
474 /* reference: Section E2.3.2.27
475 nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
476 The spec does not say what this data is or what it's used for.
477 It is likely the offset of each block within the frame. */
478 int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
479 skip_bits_long(gbc, block_start_bits);
480 ff_log_missing_feature(s->avctx, "Block start info", 1);
483 /* syntax state initialization */
484 for (ch = 1; ch <= s->fbw_channels; ch++) {
485 s->first_cpl_coords[ch] = 1;
487 s->first_cpl_leak = 1;