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