Libav
|
00001 /* 00002 * AC-3 Audio Decoder 00003 * This code was developed as part of Google Summer of Code 2006. 00004 * E-AC-3 support was added as part of Google Summer of Code 2007. 00005 * 00006 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com) 00007 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com> 00008 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com> 00009 * 00010 * This file is part of FFmpeg. 00011 * 00012 * FFmpeg is free software; you can redistribute it and/or 00013 * modify it under the terms of the GNU Lesser General Public 00014 * License as published by the Free Software Foundation; either 00015 * version 2.1 of the License, or (at your option) any later version. 00016 * 00017 * FFmpeg is distributed in the hope that it will be useful, 00018 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00019 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00020 * Lesser General Public License for more details. 00021 * 00022 * You should have received a copy of the GNU Lesser General Public 00023 * License along with FFmpeg; if not, write to the Free Software 00024 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00025 */ 00026 00027 #include <stdio.h> 00028 #include <stddef.h> 00029 #include <math.h> 00030 #include <string.h> 00031 00032 #include "libavutil/crc.h" 00033 #include "internal.h" 00034 #include "aac_ac3_parser.h" 00035 #include "ac3_parser.h" 00036 #include "ac3dec.h" 00037 #include "ac3dec_data.h" 00038 00040 #define AC3_FRAME_BUFFER_SIZE 32768 00041 00046 static uint8_t ungroup_3_in_7_bits_tab[128][3]; 00047 00048 00050 static int b1_mantissas[32][3]; 00051 static int b2_mantissas[128][3]; 00052 static int b3_mantissas[8]; 00053 static int b4_mantissas[128][2]; 00054 static int b5_mantissas[16]; 00055 00060 static const uint8_t quantization_tab[16] = { 00061 0, 3, 5, 7, 11, 15, 00062 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 00063 }; 00064 00066 static float dynamic_range_tab[256]; 00067 00069 #define LEVEL_PLUS_3DB 1.4142135623730950 00070 #define LEVEL_PLUS_1POINT5DB 1.1892071150027209 00071 #define LEVEL_MINUS_1POINT5DB 0.8408964152537145 00072 #define LEVEL_MINUS_3DB 0.7071067811865476 00073 #define LEVEL_MINUS_4POINT5DB 0.5946035575013605 00074 #define LEVEL_MINUS_6DB 0.5000000000000000 00075 #define LEVEL_MINUS_9DB 0.3535533905932738 00076 #define LEVEL_ZERO 0.0000000000000000 00077 #define LEVEL_ONE 1.0000000000000000 00078 00079 static const float gain_levels[9] = { 00080 LEVEL_PLUS_3DB, 00081 LEVEL_PLUS_1POINT5DB, 00082 LEVEL_ONE, 00083 LEVEL_MINUS_1POINT5DB, 00084 LEVEL_MINUS_3DB, 00085 LEVEL_MINUS_4POINT5DB, 00086 LEVEL_MINUS_6DB, 00087 LEVEL_ZERO, 00088 LEVEL_MINUS_9DB 00089 }; 00090 00095 static const uint8_t center_levels[4] = { 4, 5, 6, 5 }; 00096 00101 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 }; 00102 00107 static const uint8_t ac3_default_coeffs[8][5][2] = { 00108 { { 2, 7 }, { 7, 2 }, }, 00109 { { 4, 4 }, }, 00110 { { 2, 7 }, { 7, 2 }, }, 00111 { { 2, 7 }, { 5, 5 }, { 7, 2 }, }, 00112 { { 2, 7 }, { 7, 2 }, { 6, 6 }, }, 00113 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, }, 00114 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, }, 00115 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, }, 00116 }; 00117 00123 static inline int 00124 symmetric_dequant(int code, int levels) 00125 { 00126 return ((code - (levels >> 1)) << 24) / levels; 00127 } 00128 00129 /* 00130 * Initialize tables at runtime. 00131 */ 00132 static av_cold void ac3_tables_init(void) 00133 { 00134 int i; 00135 00136 /* generate table for ungrouping 3 values in 7 bits 00137 reference: Section 7.1.3 Exponent Decoding */ 00138 for(i=0; i<128; i++) { 00139 ungroup_3_in_7_bits_tab[i][0] = i / 25; 00140 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5; 00141 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5; 00142 } 00143 00144 /* generate grouped mantissa tables 00145 reference: Section 7.3.5 Ungrouping of Mantissas */ 00146 for(i=0; i<32; i++) { 00147 /* bap=1 mantissas */ 00148 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3); 00149 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3); 00150 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3); 00151 } 00152 for(i=0; i<128; i++) { 00153 /* bap=2 mantissas */ 00154 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5); 00155 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5); 00156 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5); 00157 00158 /* bap=4 mantissas */ 00159 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11); 00160 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11); 00161 } 00162 /* generate ungrouped mantissa tables 00163 reference: Tables 7.21 and 7.23 */ 00164 for(i=0; i<7; i++) { 00165 /* bap=3 mantissas */ 00166 b3_mantissas[i] = symmetric_dequant(i, 7); 00167 } 00168 for(i=0; i<15; i++) { 00169 /* bap=5 mantissas */ 00170 b5_mantissas[i] = symmetric_dequant(i, 15); 00171 } 00172 00173 /* generate dynamic range table 00174 reference: Section 7.7.1 Dynamic Range Control */ 00175 for(i=0; i<256; i++) { 00176 int v = (i >> 5) - ((i >> 7) << 3) - 5; 00177 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20); 00178 } 00179 } 00180 00181 00185 static av_cold int ac3_decode_init(AVCodecContext *avctx) 00186 { 00187 AC3DecodeContext *s = avctx->priv_data; 00188 s->avctx = avctx; 00189 00190 ac3_common_init(); 00191 ac3_tables_init(); 00192 ff_mdct_init(&s->imdct_256, 8, 1, 1.0); 00193 ff_mdct_init(&s->imdct_512, 9, 1, 1.0); 00194 ff_kbd_window_init(s->window, 5.0, 256); 00195 dsputil_init(&s->dsp, avctx); 00196 av_lfg_init(&s->dith_state, 0); 00197 00198 /* set bias values for float to int16 conversion */ 00199 if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { 00200 s->add_bias = 385.0f; 00201 s->mul_bias = 1.0f; 00202 } else { 00203 s->add_bias = 0.0f; 00204 s->mul_bias = 32767.0f; 00205 } 00206 00207 /* allow downmixing to stereo or mono */ 00208 if (avctx->channels > 0 && avctx->request_channels > 0 && 00209 avctx->request_channels < avctx->channels && 00210 avctx->request_channels <= 2) { 00211 avctx->channels = avctx->request_channels; 00212 } 00213 s->downmixed = 1; 00214 00215 /* allocate context input buffer */ 00216 if (avctx->error_recognition >= FF_ER_CAREFUL) { 00217 s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); 00218 if (!s->input_buffer) 00219 return AVERROR(ENOMEM); 00220 } 00221 00222 avctx->sample_fmt = SAMPLE_FMT_S16; 00223 return 0; 00224 } 00225 00231 static int ac3_parse_header(AC3DecodeContext *s) 00232 { 00233 GetBitContext *gbc = &s->gbc; 00234 int i; 00235 00236 /* read the rest of the bsi. read twice for dual mono mode. */ 00237 i = !(s->channel_mode); 00238 do { 00239 skip_bits(gbc, 5); // skip dialog normalization 00240 if (get_bits1(gbc)) 00241 skip_bits(gbc, 8); //skip compression 00242 if (get_bits1(gbc)) 00243 skip_bits(gbc, 8); //skip language code 00244 if (get_bits1(gbc)) 00245 skip_bits(gbc, 7); //skip audio production information 00246 } while (i--); 00247 00248 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit 00249 00250 /* skip the timecodes (or extra bitstream information for Alternate Syntax) 00251 TODO: read & use the xbsi1 downmix levels */ 00252 if (get_bits1(gbc)) 00253 skip_bits(gbc, 14); //skip timecode1 / xbsi1 00254 if (get_bits1(gbc)) 00255 skip_bits(gbc, 14); //skip timecode2 / xbsi2 00256 00257 /* skip additional bitstream info */ 00258 if (get_bits1(gbc)) { 00259 i = get_bits(gbc, 6); 00260 do { 00261 skip_bits(gbc, 8); 00262 } while(i--); 00263 } 00264 00265 return 0; 00266 } 00267 00271 static int parse_frame_header(AC3DecodeContext *s) 00272 { 00273 AC3HeaderInfo hdr; 00274 int err; 00275 00276 err = ff_ac3_parse_header(&s->gbc, &hdr); 00277 if(err) 00278 return err; 00279 00280 /* get decoding parameters from header info */ 00281 s->bit_alloc_params.sr_code = hdr.sr_code; 00282 s->channel_mode = hdr.channel_mode; 00283 s->channel_layout = hdr.channel_layout; 00284 s->lfe_on = hdr.lfe_on; 00285 s->bit_alloc_params.sr_shift = hdr.sr_shift; 00286 s->sample_rate = hdr.sample_rate; 00287 s->bit_rate = hdr.bit_rate; 00288 s->channels = hdr.channels; 00289 s->fbw_channels = s->channels - s->lfe_on; 00290 s->lfe_ch = s->fbw_channels + 1; 00291 s->frame_size = hdr.frame_size; 00292 s->center_mix_level = hdr.center_mix_level; 00293 s->surround_mix_level = hdr.surround_mix_level; 00294 s->num_blocks = hdr.num_blocks; 00295 s->frame_type = hdr.frame_type; 00296 s->substreamid = hdr.substreamid; 00297 00298 if(s->lfe_on) { 00299 s->start_freq[s->lfe_ch] = 0; 00300 s->end_freq[s->lfe_ch] = 7; 00301 s->num_exp_groups[s->lfe_ch] = 2; 00302 s->channel_in_cpl[s->lfe_ch] = 0; 00303 } 00304 00305 if (hdr.bitstream_id <= 10) { 00306 s->eac3 = 0; 00307 s->snr_offset_strategy = 2; 00308 s->block_switch_syntax = 1; 00309 s->dither_flag_syntax = 1; 00310 s->bit_allocation_syntax = 1; 00311 s->fast_gain_syntax = 0; 00312 s->first_cpl_leak = 0; 00313 s->dba_syntax = 1; 00314 s->skip_syntax = 1; 00315 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht)); 00316 return ac3_parse_header(s); 00317 } else if (CONFIG_EAC3_DECODER) { 00318 s->eac3 = 1; 00319 return ff_eac3_parse_header(s); 00320 } else { 00321 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n"); 00322 return -1; 00323 } 00324 } 00325 00330 static void set_downmix_coeffs(AC3DecodeContext *s) 00331 { 00332 int i; 00333 float cmix = gain_levels[center_levels[s->center_mix_level]]; 00334 float smix = gain_levels[surround_levels[s->surround_mix_level]]; 00335 float norm0, norm1; 00336 00337 for(i=0; i<s->fbw_channels; i++) { 00338 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]]; 00339 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]]; 00340 } 00341 if(s->channel_mode > 1 && s->channel_mode & 1) { 00342 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix; 00343 } 00344 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) { 00345 int nf = s->channel_mode - 2; 00346 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB; 00347 } 00348 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) { 00349 int nf = s->channel_mode - 4; 00350 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix; 00351 } 00352 00353 /* renormalize */ 00354 norm0 = norm1 = 0.0; 00355 for(i=0; i<s->fbw_channels; i++) { 00356 norm0 += s->downmix_coeffs[i][0]; 00357 norm1 += s->downmix_coeffs[i][1]; 00358 } 00359 norm0 = 1.0f / norm0; 00360 norm1 = 1.0f / norm1; 00361 for(i=0; i<s->fbw_channels; i++) { 00362 s->downmix_coeffs[i][0] *= norm0; 00363 s->downmix_coeffs[i][1] *= norm1; 00364 } 00365 00366 if(s->output_mode == AC3_CHMODE_MONO) { 00367 for(i=0; i<s->fbw_channels; i++) 00368 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB; 00369 } 00370 } 00371 00376 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, 00377 uint8_t absexp, int8_t *dexps) 00378 { 00379 int i, j, grp, group_size; 00380 int dexp[256]; 00381 int expacc, prevexp; 00382 00383 /* unpack groups */ 00384 group_size = exp_strategy + (exp_strategy == EXP_D45); 00385 for(grp=0,i=0; grp<ngrps; grp++) { 00386 expacc = get_bits(gbc, 7); 00387 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0]; 00388 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1]; 00389 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2]; 00390 } 00391 00392 /* convert to absolute exps and expand groups */ 00393 prevexp = absexp; 00394 for(i=0,j=0; i<ngrps*3; i++) { 00395 prevexp += dexp[i] - 2; 00396 if (prevexp > 24U) 00397 return -1; 00398 switch (group_size) { 00399 case 4: dexps[j++] = prevexp; 00400 dexps[j++] = prevexp; 00401 case 2: dexps[j++] = prevexp; 00402 case 1: dexps[j++] = prevexp; 00403 } 00404 } 00405 return 0; 00406 } 00407 00413 static void calc_transform_coeffs_cpl(AC3DecodeContext *s) 00414 { 00415 int bin, band, ch; 00416 00417 bin = s->start_freq[CPL_CH]; 00418 for (band = 0; band < s->num_cpl_bands; band++) { 00419 int band_start = bin; 00420 int band_end = bin + s->cpl_band_sizes[band]; 00421 for (ch = 1; ch <= s->fbw_channels; ch++) { 00422 if (s->channel_in_cpl[ch]) { 00423 int cpl_coord = s->cpl_coords[ch][band] << 5; 00424 for (bin = band_start; bin < band_end; bin++) { 00425 s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord); 00426 } 00427 if (ch == 2 && s->phase_flags[band]) { 00428 for (bin = band_start; bin < band_end; bin++) 00429 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin]; 00430 } 00431 } 00432 } 00433 bin = band_end; 00434 } 00435 } 00436 00440 typedef struct { 00441 int b1_mant[2]; 00442 int b2_mant[2]; 00443 int b4_mant; 00444 int b1; 00445 int b2; 00446 int b4; 00447 } mant_groups; 00448 00453 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) 00454 { 00455 int start_freq = s->start_freq[ch_index]; 00456 int end_freq = s->end_freq[ch_index]; 00457 uint8_t *baps = s->bap[ch_index]; 00458 int8_t *exps = s->dexps[ch_index]; 00459 int *coeffs = s->fixed_coeffs[ch_index]; 00460 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index]; 00461 GetBitContext *gbc = &s->gbc; 00462 int freq; 00463 00464 for(freq = start_freq; freq < end_freq; freq++){ 00465 int bap = baps[freq]; 00466 int mantissa; 00467 switch(bap){ 00468 case 0: 00469 if (dither) 00470 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000; 00471 else 00472 mantissa = 0; 00473 break; 00474 case 1: 00475 if(m->b1){ 00476 m->b1--; 00477 mantissa = m->b1_mant[m->b1]; 00478 } 00479 else{ 00480 int bits = get_bits(gbc, 5); 00481 mantissa = b1_mantissas[bits][0]; 00482 m->b1_mant[1] = b1_mantissas[bits][1]; 00483 m->b1_mant[0] = b1_mantissas[bits][2]; 00484 m->b1 = 2; 00485 } 00486 break; 00487 case 2: 00488 if(m->b2){ 00489 m->b2--; 00490 mantissa = m->b2_mant[m->b2]; 00491 } 00492 else{ 00493 int bits = get_bits(gbc, 7); 00494 mantissa = b2_mantissas[bits][0]; 00495 m->b2_mant[1] = b2_mantissas[bits][1]; 00496 m->b2_mant[0] = b2_mantissas[bits][2]; 00497 m->b2 = 2; 00498 } 00499 break; 00500 case 3: 00501 mantissa = b3_mantissas[get_bits(gbc, 3)]; 00502 break; 00503 case 4: 00504 if(m->b4){ 00505 m->b4 = 0; 00506 mantissa = m->b4_mant; 00507 } 00508 else{ 00509 int bits = get_bits(gbc, 7); 00510 mantissa = b4_mantissas[bits][0]; 00511 m->b4_mant = b4_mantissas[bits][1]; 00512 m->b4 = 1; 00513 } 00514 break; 00515 case 5: 00516 mantissa = b5_mantissas[get_bits(gbc, 4)]; 00517 break; 00518 default: /* 6 to 15 */ 00519 mantissa = get_bits(gbc, quantization_tab[bap]); 00520 /* Shift mantissa and sign-extend it. */ 00521 mantissa = (mantissa << (32-quantization_tab[bap]))>>8; 00522 break; 00523 } 00524 coeffs[freq] = mantissa >> exps[freq]; 00525 } 00526 } 00527 00533 static void remove_dithering(AC3DecodeContext *s) { 00534 int ch, i; 00535 00536 for(ch=1; ch<=s->fbw_channels; ch++) { 00537 if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) { 00538 for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) { 00539 if(!s->bap[CPL_CH][i]) 00540 s->fixed_coeffs[ch][i] = 0; 00541 } 00542 } 00543 } 00544 } 00545 00546 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, 00547 mant_groups *m) 00548 { 00549 if (!s->channel_uses_aht[ch]) { 00550 ac3_decode_transform_coeffs_ch(s, ch, m); 00551 } else { 00552 /* if AHT is used, mantissas for all blocks are encoded in the first 00553 block of the frame. */ 00554 int bin; 00555 if (!blk && CONFIG_EAC3_DECODER) 00556 ff_eac3_decode_transform_coeffs_aht_ch(s, ch); 00557 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { 00558 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin]; 00559 } 00560 } 00561 } 00562 00566 static void decode_transform_coeffs(AC3DecodeContext *s, int blk) 00567 { 00568 int ch, end; 00569 int got_cplchan = 0; 00570 mant_groups m; 00571 00572 m.b1 = m.b2 = m.b4 = 0; 00573 00574 for (ch = 1; ch <= s->channels; ch++) { 00575 /* transform coefficients for full-bandwidth channel */ 00576 decode_transform_coeffs_ch(s, blk, ch, &m); 00577 /* tranform coefficients for coupling channel come right after the 00578 coefficients for the first coupled channel*/ 00579 if (s->channel_in_cpl[ch]) { 00580 if (!got_cplchan) { 00581 decode_transform_coeffs_ch(s, blk, CPL_CH, &m); 00582 calc_transform_coeffs_cpl(s); 00583 got_cplchan = 1; 00584 } 00585 end = s->end_freq[CPL_CH]; 00586 } else { 00587 end = s->end_freq[ch]; 00588 } 00589 do 00590 s->fixed_coeffs[ch][end] = 0; 00591 while(++end < 256); 00592 } 00593 00594 /* zero the dithered coefficients for appropriate channels */ 00595 remove_dithering(s); 00596 } 00597 00602 static void do_rematrixing(AC3DecodeContext *s) 00603 { 00604 int bnd, i; 00605 int end, bndend; 00606 00607 end = FFMIN(s->end_freq[1], s->end_freq[2]); 00608 00609 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) { 00610 if(s->rematrixing_flags[bnd]) { 00611 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]); 00612 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) { 00613 int tmp0 = s->fixed_coeffs[1][i]; 00614 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i]; 00615 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i]; 00616 } 00617 } 00618 } 00619 } 00620 00626 static inline void do_imdct(AC3DecodeContext *s, int channels) 00627 { 00628 int ch; 00629 float add_bias = s->add_bias; 00630 if(s->out_channels==1 && channels>1) 00631 add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix 00632 00633 for (ch=1; ch<=channels; ch++) { 00634 if (s->block_switch[ch]) { 00635 int i; 00636 float *x = s->tmp_output+128; 00637 for(i=0; i<128; i++) 00638 x[i] = s->transform_coeffs[ch][2*i]; 00639 ff_imdct_half(&s->imdct_256, s->tmp_output, x); 00640 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128); 00641 for(i=0; i<128; i++) 00642 x[i] = s->transform_coeffs[ch][2*i+1]; 00643 ff_imdct_half(&s->imdct_256, s->delay[ch-1], x); 00644 } else { 00645 ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]); 00646 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128); 00647 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float)); 00648 } 00649 } 00650 } 00651 00655 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len) 00656 { 00657 int i, j; 00658 float v0, v1; 00659 if(out_ch == 2) { 00660 for(i=0; i<len; i++) { 00661 v0 = v1 = 0.0f; 00662 for(j=0; j<in_ch; j++) { 00663 v0 += samples[j][i] * matrix[j][0]; 00664 v1 += samples[j][i] * matrix[j][1]; 00665 } 00666 samples[0][i] = v0; 00667 samples[1][i] = v1; 00668 } 00669 } else if(out_ch == 1) { 00670 for(i=0; i<len; i++) { 00671 v0 = 0.0f; 00672 for(j=0; j<in_ch; j++) 00673 v0 += samples[j][i] * matrix[j][0]; 00674 samples[0][i] = v0; 00675 } 00676 } 00677 } 00678 00682 static void ac3_upmix_delay(AC3DecodeContext *s) 00683 { 00684 int channel_data_size = sizeof(s->delay[0]); 00685 switch(s->channel_mode) { 00686 case AC3_CHMODE_DUALMONO: 00687 case AC3_CHMODE_STEREO: 00688 /* upmix mono to stereo */ 00689 memcpy(s->delay[1], s->delay[0], channel_data_size); 00690 break; 00691 case AC3_CHMODE_2F2R: 00692 memset(s->delay[3], 0, channel_data_size); 00693 case AC3_CHMODE_2F1R: 00694 memset(s->delay[2], 0, channel_data_size); 00695 break; 00696 case AC3_CHMODE_3F2R: 00697 memset(s->delay[4], 0, channel_data_size); 00698 case AC3_CHMODE_3F1R: 00699 memset(s->delay[3], 0, channel_data_size); 00700 case AC3_CHMODE_3F: 00701 memcpy(s->delay[2], s->delay[1], channel_data_size); 00702 memset(s->delay[1], 0, channel_data_size); 00703 break; 00704 } 00705 } 00706 00723 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3, 00724 int ecpl, int start_subband, int end_subband, 00725 const uint8_t *default_band_struct, 00726 int *num_bands, uint8_t *band_sizes) 00727 { 00728 int subbnd, bnd, n_subbands, n_bands=0; 00729 uint8_t bnd_sz[22]; 00730 uint8_t coded_band_struct[22]; 00731 const uint8_t *band_struct; 00732 00733 n_subbands = end_subband - start_subband; 00734 00735 /* decode band structure from bitstream or use default */ 00736 if (!eac3 || get_bits1(gbc)) { 00737 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) { 00738 coded_band_struct[subbnd] = get_bits1(gbc); 00739 } 00740 band_struct = coded_band_struct; 00741 } else if (!blk) { 00742 band_struct = &default_band_struct[start_subband+1]; 00743 } else { 00744 /* no change in band structure */ 00745 return; 00746 } 00747 00748 /* calculate number of bands and band sizes based on band structure. 00749 note that the first 4 subbands in enhanced coupling span only 6 bins 00750 instead of 12. */ 00751 if (num_bands || band_sizes ) { 00752 n_bands = n_subbands; 00753 bnd_sz[0] = ecpl ? 6 : 12; 00754 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) { 00755 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12; 00756 if (band_struct[subbnd-1]) { 00757 n_bands--; 00758 bnd_sz[bnd] += subbnd_size; 00759 } else { 00760 bnd_sz[++bnd] = subbnd_size; 00761 } 00762 } 00763 } 00764 00765 /* set optional output params */ 00766 if (num_bands) 00767 *num_bands = n_bands; 00768 if (band_sizes) 00769 memcpy(band_sizes, bnd_sz, n_bands); 00770 } 00771 00775 static int decode_audio_block(AC3DecodeContext *s, int blk) 00776 { 00777 int fbw_channels = s->fbw_channels; 00778 int channel_mode = s->channel_mode; 00779 int i, bnd, seg, ch; 00780 int different_transforms; 00781 int downmix_output; 00782 int cpl_in_use; 00783 GetBitContext *gbc = &s->gbc; 00784 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; 00785 00786 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS); 00787 00788 /* block switch flags */ 00789 different_transforms = 0; 00790 if (s->block_switch_syntax) { 00791 for (ch = 1; ch <= fbw_channels; ch++) { 00792 s->block_switch[ch] = get_bits1(gbc); 00793 if(ch > 1 && s->block_switch[ch] != s->block_switch[1]) 00794 different_transforms = 1; 00795 } 00796 } 00797 00798 /* dithering flags */ 00799 if (s->dither_flag_syntax) { 00800 for (ch = 1; ch <= fbw_channels; ch++) { 00801 s->dither_flag[ch] = get_bits1(gbc); 00802 } 00803 } 00804 00805 /* dynamic range */ 00806 i = !(s->channel_mode); 00807 do { 00808 if(get_bits1(gbc)) { 00809 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) * 00810 s->avctx->drc_scale)+1.0; 00811 } else if(blk == 0) { 00812 s->dynamic_range[i] = 1.0f; 00813 } 00814 } while(i--); 00815 00816 /* spectral extension strategy */ 00817 if (s->eac3 && (!blk || get_bits1(gbc))) { 00818 s->spx_in_use = get_bits1(gbc); 00819 if (s->spx_in_use) { 00820 int dst_start_freq, dst_end_freq, src_start_freq, 00821 start_subband, end_subband; 00822 00823 /* determine which channels use spx */ 00824 if (s->channel_mode == AC3_CHMODE_MONO) { 00825 s->channel_uses_spx[1] = 1; 00826 } else { 00827 for (ch = 1; ch <= fbw_channels; ch++) 00828 s->channel_uses_spx[ch] = get_bits1(gbc); 00829 } 00830 00831 /* get the frequency bins of the spx copy region and the spx start 00832 and end subbands */ 00833 dst_start_freq = get_bits(gbc, 2); 00834 start_subband = get_bits(gbc, 3) + 2; 00835 if (start_subband > 7) 00836 start_subband += start_subband - 7; 00837 end_subband = get_bits(gbc, 3) + 5; 00838 if (end_subband > 7) 00839 end_subband += end_subband - 7; 00840 dst_start_freq = dst_start_freq * 12 + 25; 00841 src_start_freq = start_subband * 12 + 25; 00842 dst_end_freq = end_subband * 12 + 25; 00843 00844 /* check validity of spx ranges */ 00845 if (start_subband >= end_subband) { 00846 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension " 00847 "range (%d >= %d)\n", start_subband, end_subband); 00848 return -1; 00849 } 00850 if (dst_start_freq >= src_start_freq) { 00851 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension " 00852 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq); 00853 return -1; 00854 } 00855 00856 s->spx_dst_start_freq = dst_start_freq; 00857 s->spx_src_start_freq = src_start_freq; 00858 s->spx_dst_end_freq = dst_end_freq; 00859 00860 decode_band_structure(gbc, blk, s->eac3, 0, 00861 start_subband, end_subband, 00862 ff_eac3_default_spx_band_struct, 00863 &s->num_spx_bands, 00864 s->spx_band_sizes); 00865 } else { 00866 for (ch = 1; ch <= fbw_channels; ch++) { 00867 s->channel_uses_spx[ch] = 0; 00868 s->first_spx_coords[ch] = 1; 00869 } 00870 } 00871 } 00872 00873 /* spectral extension coordinates */ 00874 if (s->spx_in_use) { 00875 for (ch = 1; ch <= fbw_channels; ch++) { 00876 if (s->channel_uses_spx[ch]) { 00877 if (s->first_spx_coords[ch] || get_bits1(gbc)) { 00878 float spx_blend; 00879 int bin, master_spx_coord; 00880 00881 s->first_spx_coords[ch] = 0; 00882 spx_blend = get_bits(gbc, 5) * (1.0f/32); 00883 master_spx_coord = get_bits(gbc, 2) * 3; 00884 00885 bin = s->spx_src_start_freq; 00886 for (bnd = 0; bnd < s->num_spx_bands; bnd++) { 00887 int bandsize; 00888 int spx_coord_exp, spx_coord_mant; 00889 float nratio, sblend, nblend, spx_coord; 00890 00891 /* calculate blending factors */ 00892 bandsize = s->spx_band_sizes[bnd]; 00893 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend; 00894 nratio = av_clipf(nratio, 0.0f, 1.0f); 00895 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance 00896 sblend = sqrtf(1.0f - nratio); 00897 bin += bandsize; 00898 00899 /* decode spx coordinates */ 00900 spx_coord_exp = get_bits(gbc, 4); 00901 spx_coord_mant = get_bits(gbc, 2); 00902 if (spx_coord_exp == 15) spx_coord_mant <<= 1; 00903 else spx_coord_mant += 4; 00904 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord); 00905 spx_coord = spx_coord_mant * (1.0f/(1<<23)); 00906 00907 /* multiply noise and signal blending factors by spx coordinate */ 00908 s->spx_noise_blend [ch][bnd] = nblend * spx_coord; 00909 s->spx_signal_blend[ch][bnd] = sblend * spx_coord; 00910 } 00911 } 00912 } else { 00913 s->first_spx_coords[ch] = 1; 00914 } 00915 } 00916 } 00917 00918 /* coupling strategy */ 00919 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) { 00920 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); 00921 if (!s->eac3) 00922 s->cpl_in_use[blk] = get_bits1(gbc); 00923 if (s->cpl_in_use[blk]) { 00924 /* coupling in use */ 00925 int cpl_start_subband, cpl_end_subband; 00926 00927 if (channel_mode < AC3_CHMODE_STEREO) { 00928 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n"); 00929 return -1; 00930 } 00931 00932 /* check for enhanced coupling */ 00933 if (s->eac3 && get_bits1(gbc)) { 00934 /* TODO: parse enhanced coupling strategy info */ 00935 av_log_missing_feature(s->avctx, "Enhanced coupling", 1); 00936 return -1; 00937 } 00938 00939 /* determine which channels are coupled */ 00940 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) { 00941 s->channel_in_cpl[1] = 1; 00942 s->channel_in_cpl[2] = 1; 00943 } else { 00944 for (ch = 1; ch <= fbw_channels; ch++) 00945 s->channel_in_cpl[ch] = get_bits1(gbc); 00946 } 00947 00948 /* phase flags in use */ 00949 if (channel_mode == AC3_CHMODE_STEREO) 00950 s->phase_flags_in_use = get_bits1(gbc); 00951 00952 /* coupling frequency range */ 00953 cpl_start_subband = get_bits(gbc, 4); 00954 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 : 00955 get_bits(gbc, 4) + 3; 00956 if (cpl_start_subband >= cpl_end_subband) { 00957 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n", 00958 cpl_start_subband, cpl_end_subband); 00959 return -1; 00960 } 00961 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37; 00962 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37; 00963 00964 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband, 00965 cpl_end_subband, 00966 ff_eac3_default_cpl_band_struct, 00967 &s->num_cpl_bands, s->cpl_band_sizes); 00968 } else { 00969 /* coupling not in use */ 00970 for (ch = 1; ch <= fbw_channels; ch++) { 00971 s->channel_in_cpl[ch] = 0; 00972 s->first_cpl_coords[ch] = 1; 00973 } 00974 s->first_cpl_leak = s->eac3; 00975 s->phase_flags_in_use = 0; 00976 } 00977 } else if (!s->eac3) { 00978 if(!blk) { 00979 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n"); 00980 return -1; 00981 } else { 00982 s->cpl_in_use[blk] = s->cpl_in_use[blk-1]; 00983 } 00984 } 00985 cpl_in_use = s->cpl_in_use[blk]; 00986 00987 /* coupling coordinates */ 00988 if (cpl_in_use) { 00989 int cpl_coords_exist = 0; 00990 00991 for (ch = 1; ch <= fbw_channels; ch++) { 00992 if (s->channel_in_cpl[ch]) { 00993 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) { 00994 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant; 00995 s->first_cpl_coords[ch] = 0; 00996 cpl_coords_exist = 1; 00997 master_cpl_coord = 3 * get_bits(gbc, 2); 00998 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { 00999 cpl_coord_exp = get_bits(gbc, 4); 01000 cpl_coord_mant = get_bits(gbc, 4); 01001 if (cpl_coord_exp == 15) 01002 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22; 01003 else 01004 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21; 01005 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord); 01006 } 01007 } else if (!blk) { 01008 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n"); 01009 return -1; 01010 } 01011 } else { 01012 /* channel not in coupling */ 01013 s->first_cpl_coords[ch] = 1; 01014 } 01015 } 01016 /* phase flags */ 01017 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) { 01018 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { 01019 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0; 01020 } 01021 } 01022 } 01023 01024 /* stereo rematrixing strategy and band structure */ 01025 if (channel_mode == AC3_CHMODE_STEREO) { 01026 if ((s->eac3 && !blk) || get_bits1(gbc)) { 01027 s->num_rematrixing_bands = 4; 01028 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) { 01029 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37); 01030 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) { 01031 s->num_rematrixing_bands--; 01032 } 01033 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) 01034 s->rematrixing_flags[bnd] = get_bits1(gbc); 01035 } else if (!blk) { 01036 av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n"); 01037 s->num_rematrixing_bands = 0; 01038 } 01039 } 01040 01041 /* exponent strategies for each channel */ 01042 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 01043 if (!s->eac3) 01044 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch)); 01045 if(s->exp_strategy[blk][ch] != EXP_REUSE) 01046 bit_alloc_stages[ch] = 3; 01047 } 01048 01049 /* channel bandwidth */ 01050 for (ch = 1; ch <= fbw_channels; ch++) { 01051 s->start_freq[ch] = 0; 01052 if (s->exp_strategy[blk][ch] != EXP_REUSE) { 01053 int group_size; 01054 int prev = s->end_freq[ch]; 01055 if (s->channel_in_cpl[ch]) 01056 s->end_freq[ch] = s->start_freq[CPL_CH]; 01057 else if (s->channel_uses_spx[ch]) 01058 s->end_freq[ch] = s->spx_src_start_freq; 01059 else { 01060 int bandwidth_code = get_bits(gbc, 6); 01061 if (bandwidth_code > 60) { 01062 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code); 01063 return -1; 01064 } 01065 s->end_freq[ch] = bandwidth_code * 3 + 73; 01066 } 01067 group_size = 3 << (s->exp_strategy[blk][ch] - 1); 01068 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size; 01069 if(blk > 0 && s->end_freq[ch] != prev) 01070 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); 01071 } 01072 } 01073 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) { 01074 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) / 01075 (3 << (s->exp_strategy[blk][CPL_CH] - 1)); 01076 } 01077 01078 /* decode exponents for each channel */ 01079 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 01080 if (s->exp_strategy[blk][ch] != EXP_REUSE) { 01081 s->dexps[ch][0] = get_bits(gbc, 4) << !ch; 01082 if (decode_exponents(gbc, s->exp_strategy[blk][ch], 01083 s->num_exp_groups[ch], s->dexps[ch][0], 01084 &s->dexps[ch][s->start_freq[ch]+!!ch])) { 01085 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n"); 01086 return -1; 01087 } 01088 if(ch != CPL_CH && ch != s->lfe_ch) 01089 skip_bits(gbc, 2); /* skip gainrng */ 01090 } 01091 } 01092 01093 /* bit allocation information */ 01094 if (s->bit_allocation_syntax) { 01095 if (get_bits1(gbc)) { 01096 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; 01097 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; 01098 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)]; 01099 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)]; 01100 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)]; 01101 for(ch=!cpl_in_use; ch<=s->channels; ch++) 01102 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 01103 } else if (!blk) { 01104 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n"); 01105 return -1; 01106 } 01107 } 01108 01109 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */ 01110 if(!s->eac3 || !blk){ 01111 if(s->snr_offset_strategy && get_bits1(gbc)) { 01112 int snr = 0; 01113 int csnr; 01114 csnr = (get_bits(gbc, 6) - 15) << 4; 01115 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) { 01116 /* snr offset */ 01117 if (ch == i || s->snr_offset_strategy == 2) 01118 snr = (csnr + get_bits(gbc, 4)) << 2; 01119 /* run at least last bit allocation stage if snr offset changes */ 01120 if(blk && s->snr_offset[ch] != snr) { 01121 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1); 01122 } 01123 s->snr_offset[ch] = snr; 01124 01125 /* fast gain (normal AC-3 only) */ 01126 if (!s->eac3) { 01127 int prev = s->fast_gain[ch]; 01128 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; 01129 /* run last 2 bit allocation stages if fast gain changes */ 01130 if(blk && prev != s->fast_gain[ch]) 01131 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 01132 } 01133 } 01134 } else if (!s->eac3 && !blk) { 01135 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n"); 01136 return -1; 01137 } 01138 } 01139 01140 /* fast gain (E-AC-3 only) */ 01141 if (s->fast_gain_syntax && get_bits1(gbc)) { 01142 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 01143 int prev = s->fast_gain[ch]; 01144 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; 01145 /* run last 2 bit allocation stages if fast gain changes */ 01146 if(blk && prev != s->fast_gain[ch]) 01147 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 01148 } 01149 } else if (s->eac3 && !blk) { 01150 for (ch = !cpl_in_use; ch <= s->channels; ch++) 01151 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4]; 01152 } 01153 01154 /* E-AC-3 to AC-3 converter SNR offset */ 01155 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) { 01156 skip_bits(gbc, 10); // skip converter snr offset 01157 } 01158 01159 /* coupling leak information */ 01160 if (cpl_in_use) { 01161 if (s->first_cpl_leak || get_bits1(gbc)) { 01162 int fl = get_bits(gbc, 3); 01163 int sl = get_bits(gbc, 3); 01164 /* run last 2 bit allocation stages for coupling channel if 01165 coupling leak changes */ 01166 if(blk && (fl != s->bit_alloc_params.cpl_fast_leak || 01167 sl != s->bit_alloc_params.cpl_slow_leak)) { 01168 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2); 01169 } 01170 s->bit_alloc_params.cpl_fast_leak = fl; 01171 s->bit_alloc_params.cpl_slow_leak = sl; 01172 } else if (!s->eac3 && !blk) { 01173 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n"); 01174 return -1; 01175 } 01176 s->first_cpl_leak = 0; 01177 } 01178 01179 /* delta bit allocation information */ 01180 if (s->dba_syntax && get_bits1(gbc)) { 01181 /* delta bit allocation exists (strategy) */ 01182 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) { 01183 s->dba_mode[ch] = get_bits(gbc, 2); 01184 if (s->dba_mode[ch] == DBA_RESERVED) { 01185 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); 01186 return -1; 01187 } 01188 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 01189 } 01190 /* channel delta offset, len and bit allocation */ 01191 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) { 01192 if (s->dba_mode[ch] == DBA_NEW) { 01193 s->dba_nsegs[ch] = get_bits(gbc, 3); 01194 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) { 01195 s->dba_offsets[ch][seg] = get_bits(gbc, 5); 01196 s->dba_lengths[ch][seg] = get_bits(gbc, 4); 01197 s->dba_values[ch][seg] = get_bits(gbc, 3); 01198 } 01199 /* run last 2 bit allocation stages if new dba values */ 01200 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 01201 } 01202 } 01203 } else if(blk == 0) { 01204 for(ch=0; ch<=s->channels; ch++) { 01205 s->dba_mode[ch] = DBA_NONE; 01206 } 01207 } 01208 01209 /* Bit allocation */ 01210 for(ch=!cpl_in_use; ch<=s->channels; ch++) { 01211 if(bit_alloc_stages[ch] > 2) { 01212 /* Exponent mapping into PSD and PSD integration */ 01213 ff_ac3_bit_alloc_calc_psd(s->dexps[ch], 01214 s->start_freq[ch], s->end_freq[ch], 01215 s->psd[ch], s->band_psd[ch]); 01216 } 01217 if(bit_alloc_stages[ch] > 1) { 01218 /* Compute excitation function, Compute masking curve, and 01219 Apply delta bit allocation */ 01220 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch], 01221 s->start_freq[ch], s->end_freq[ch], 01222 s->fast_gain[ch], (ch == s->lfe_ch), 01223 s->dba_mode[ch], s->dba_nsegs[ch], 01224 s->dba_offsets[ch], s->dba_lengths[ch], 01225 s->dba_values[ch], s->mask[ch])) { 01226 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n"); 01227 return -1; 01228 } 01229 } 01230 if(bit_alloc_stages[ch] > 0) { 01231 /* Compute bit allocation */ 01232 const uint8_t *bap_tab = s->channel_uses_aht[ch] ? 01233 ff_eac3_hebap_tab : ff_ac3_bap_tab; 01234 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch], 01235 s->start_freq[ch], s->end_freq[ch], 01236 s->snr_offset[ch], 01237 s->bit_alloc_params.floor, 01238 bap_tab, s->bap[ch]); 01239 } 01240 } 01241 01242 /* unused dummy data */ 01243 if (s->skip_syntax && get_bits1(gbc)) { 01244 int skipl = get_bits(gbc, 9); 01245 while(skipl--) 01246 skip_bits(gbc, 8); 01247 } 01248 01249 /* unpack the transform coefficients 01250 this also uncouples channels if coupling is in use. */ 01251 decode_transform_coeffs(s, blk); 01252 01253 /* TODO: generate enhanced coupling coordinates and uncouple */ 01254 01255 /* recover coefficients if rematrixing is in use */ 01256 if(s->channel_mode == AC3_CHMODE_STEREO) 01257 do_rematrixing(s); 01258 01259 /* apply scaling to coefficients (headroom, dynrng) */ 01260 for(ch=1; ch<=s->channels; ch++) { 01261 float gain = s->mul_bias / 4194304.0f; 01262 if(s->channel_mode == AC3_CHMODE_DUALMONO) { 01263 gain *= s->dynamic_range[2-ch]; 01264 } else { 01265 gain *= s->dynamic_range[0]; 01266 } 01267 s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256); 01268 } 01269 01270 /* apply spectral extension to high frequency bins */ 01271 if (s->spx_in_use && CONFIG_EAC3_DECODER) { 01272 ff_eac3_apply_spectral_extension(s); 01273 } 01274 01275 /* downmix and MDCT. order depends on whether block switching is used for 01276 any channel in this block. this is because coefficients for the long 01277 and short transforms cannot be mixed. */ 01278 downmix_output = s->channels != s->out_channels && 01279 !((s->output_mode & AC3_OUTPUT_LFEON) && 01280 s->fbw_channels == s->out_channels); 01281 if(different_transforms) { 01282 /* the delay samples have already been downmixed, so we upmix the delay 01283 samples in order to reconstruct all channels before downmixing. */ 01284 if(s->downmixed) { 01285 s->downmixed = 0; 01286 ac3_upmix_delay(s); 01287 } 01288 01289 do_imdct(s, s->channels); 01290 01291 if(downmix_output) { 01292 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256); 01293 } 01294 } else { 01295 if(downmix_output) { 01296 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256); 01297 } 01298 01299 if(downmix_output && !s->downmixed) { 01300 s->downmixed = 1; 01301 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128); 01302 } 01303 01304 do_imdct(s, s->out_channels); 01305 } 01306 01307 return 0; 01308 } 01309 01313 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, 01314 AVPacket *avpkt) 01315 { 01316 const uint8_t *buf = avpkt->data; 01317 int buf_size = avpkt->size; 01318 AC3DecodeContext *s = avctx->priv_data; 01319 int16_t *out_samples = (int16_t *)data; 01320 int blk, ch, err; 01321 const uint8_t *channel_map; 01322 const float *output[AC3_MAX_CHANNELS]; 01323 01324 /* initialize the GetBitContext with the start of valid AC-3 Frame */ 01325 if (s->input_buffer) { 01326 /* copy input buffer to decoder context to avoid reading past the end 01327 of the buffer, which can be caused by a damaged input stream. */ 01328 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE)); 01329 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8); 01330 } else { 01331 init_get_bits(&s->gbc, buf, buf_size * 8); 01332 } 01333 01334 /* parse the syncinfo */ 01335 *data_size = 0; 01336 err = parse_frame_header(s); 01337 01338 if (err) { 01339 switch(err) { 01340 case AAC_AC3_PARSE_ERROR_SYNC: 01341 av_log(avctx, AV_LOG_ERROR, "frame sync error\n"); 01342 return -1; 01343 case AAC_AC3_PARSE_ERROR_BSID: 01344 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n"); 01345 break; 01346 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE: 01347 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n"); 01348 break; 01349 case AAC_AC3_PARSE_ERROR_FRAME_SIZE: 01350 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n"); 01351 break; 01352 case AAC_AC3_PARSE_ERROR_FRAME_TYPE: 01353 /* skip frame if CRC is ok. otherwise use error concealment. */ 01354 /* TODO: add support for substreams and dependent frames */ 01355 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) { 01356 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n"); 01357 return s->frame_size; 01358 } else { 01359 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n"); 01360 } 01361 break; 01362 default: 01363 av_log(avctx, AV_LOG_ERROR, "invalid header\n"); 01364 break; 01365 } 01366 } else { 01367 /* check that reported frame size fits in input buffer */ 01368 if (s->frame_size > buf_size) { 01369 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); 01370 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE; 01371 } else if (avctx->error_recognition >= FF_ER_CAREFUL) { 01372 /* check for crc mismatch */ 01373 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) { 01374 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n"); 01375 err = AAC_AC3_PARSE_ERROR_CRC; 01376 } 01377 } 01378 } 01379 01380 /* if frame is ok, set audio parameters */ 01381 if (!err) { 01382 avctx->sample_rate = s->sample_rate; 01383 avctx->bit_rate = s->bit_rate; 01384 01385 /* channel config */ 01386 s->out_channels = s->channels; 01387 s->output_mode = s->channel_mode; 01388 if(s->lfe_on) 01389 s->output_mode |= AC3_OUTPUT_LFEON; 01390 if (avctx->request_channels > 0 && avctx->request_channels <= 2 && 01391 avctx->request_channels < s->channels) { 01392 s->out_channels = avctx->request_channels; 01393 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; 01394 s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode]; 01395 } 01396 avctx->channels = s->out_channels; 01397 avctx->channel_layout = s->channel_layout; 01398 01399 /* set downmixing coefficients if needed */ 01400 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) && 01401 s->fbw_channels == s->out_channels)) { 01402 set_downmix_coeffs(s); 01403 } 01404 } else if (!s->out_channels) { 01405 s->out_channels = avctx->channels; 01406 if(s->out_channels < s->channels) 01407 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; 01408 } 01409 01410 /* decode the audio blocks */ 01411 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on]; 01412 for (ch = 0; ch < s->out_channels; ch++) 01413 output[ch] = s->output[channel_map[ch]]; 01414 for (blk = 0; blk < s->num_blocks; blk++) { 01415 if (!err && decode_audio_block(s, blk)) { 01416 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n"); 01417 err = 1; 01418 } 01419 s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels); 01420 out_samples += 256 * s->out_channels; 01421 } 01422 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t); 01423 return FFMIN(buf_size, s->frame_size); 01424 } 01425 01429 static av_cold int ac3_decode_end(AVCodecContext *avctx) 01430 { 01431 AC3DecodeContext *s = avctx->priv_data; 01432 ff_mdct_end(&s->imdct_512); 01433 ff_mdct_end(&s->imdct_256); 01434 01435 av_freep(&s->input_buffer); 01436 01437 return 0; 01438 } 01439 01440 AVCodec ac3_decoder = { 01441 .name = "ac3", 01442 .type = AVMEDIA_TYPE_AUDIO, 01443 .id = CODEC_ID_AC3, 01444 .priv_data_size = sizeof (AC3DecodeContext), 01445 .init = ac3_decode_init, 01446 .close = ac3_decode_end, 01447 .decode = ac3_decode_frame, 01448 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), 01449 }; 01450 01451 #if CONFIG_EAC3_DECODER 01452 AVCodec eac3_decoder = { 01453 .name = "eac3", 01454 .type = AVMEDIA_TYPE_AUDIO, 01455 .id = CODEC_ID_EAC3, 01456 .priv_data_size = sizeof (AC3DecodeContext), 01457 .init = ac3_decode_init, 01458 .close = ac3_decode_end, 01459 .decode = ac3_decode_frame, 01460 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"), 01461 }; 01462 #endif