00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
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
00131
00132 static av_cold void ac3_tables_init(void)
00133 {
00134 int i;
00135
00136
00137
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
00145
00146 for(i=0; i<32; i++) {
00147
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
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
00159 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
00160 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
00161 }
00162
00163
00164 for(i=0; i<7; i++) {
00165
00166 b3_mantissas[i] = symmetric_dequant(i, 7);
00167 }
00168 for(i=0; i<15; i++) {
00169
00170 b5_mantissas[i] = symmetric_dequant(i, 15);
00171 }
00172
00173
00174
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 ff_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 ff_fmt_convert_init(&s->fmt_conv, avctx);
00197 av_lfg_init(&s->dith_state, 0);
00198
00199
00200 s->mul_bias = 32767.0f;
00201
00202
00203 if (avctx->channels > 0 && avctx->request_channels > 0 &&
00204 avctx->request_channels < avctx->channels &&
00205 avctx->request_channels <= 2) {
00206 avctx->channels = avctx->request_channels;
00207 }
00208 s->downmixed = 1;
00209
00210
00211 if (avctx->error_recognition >= FF_ER_CAREFUL) {
00212 s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
00213 if (!s->input_buffer)
00214 return AVERROR(ENOMEM);
00215 }
00216
00217 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00218 return 0;
00219 }
00220
00226 static int ac3_parse_header(AC3DecodeContext *s)
00227 {
00228 GetBitContext *gbc = &s->gbc;
00229 int i;
00230
00231
00232 i = !(s->channel_mode);
00233 do {
00234 skip_bits(gbc, 5);
00235 if (get_bits1(gbc))
00236 skip_bits(gbc, 8);
00237 if (get_bits1(gbc))
00238 skip_bits(gbc, 8);
00239 if (get_bits1(gbc))
00240 skip_bits(gbc, 7);
00241 } while (i--);
00242
00243 skip_bits(gbc, 2);
00244
00245
00246
00247 if (get_bits1(gbc))
00248 skip_bits(gbc, 14);
00249 if (get_bits1(gbc))
00250 skip_bits(gbc, 14);
00251
00252
00253 if (get_bits1(gbc)) {
00254 i = get_bits(gbc, 6);
00255 do {
00256 skip_bits(gbc, 8);
00257 } while(i--);
00258 }
00259
00260 return 0;
00261 }
00262
00266 static int parse_frame_header(AC3DecodeContext *s)
00267 {
00268 AC3HeaderInfo hdr;
00269 int err;
00270
00271 err = ff_ac3_parse_header(&s->gbc, &hdr);
00272 if(err)
00273 return err;
00274
00275
00276 s->bit_alloc_params.sr_code = hdr.sr_code;
00277 s->channel_mode = hdr.channel_mode;
00278 s->channel_layout = hdr.channel_layout;
00279 s->lfe_on = hdr.lfe_on;
00280 s->bit_alloc_params.sr_shift = hdr.sr_shift;
00281 s->sample_rate = hdr.sample_rate;
00282 s->bit_rate = hdr.bit_rate;
00283 s->channels = hdr.channels;
00284 s->fbw_channels = s->channels - s->lfe_on;
00285 s->lfe_ch = s->fbw_channels + 1;
00286 s->frame_size = hdr.frame_size;
00287 s->center_mix_level = hdr.center_mix_level;
00288 s->surround_mix_level = hdr.surround_mix_level;
00289 s->num_blocks = hdr.num_blocks;
00290 s->frame_type = hdr.frame_type;
00291 s->substreamid = hdr.substreamid;
00292
00293 if(s->lfe_on) {
00294 s->start_freq[s->lfe_ch] = 0;
00295 s->end_freq[s->lfe_ch] = 7;
00296 s->num_exp_groups[s->lfe_ch] = 2;
00297 s->channel_in_cpl[s->lfe_ch] = 0;
00298 }
00299
00300 if (hdr.bitstream_id <= 10) {
00301 s->eac3 = 0;
00302 s->snr_offset_strategy = 2;
00303 s->block_switch_syntax = 1;
00304 s->dither_flag_syntax = 1;
00305 s->bit_allocation_syntax = 1;
00306 s->fast_gain_syntax = 0;
00307 s->first_cpl_leak = 0;
00308 s->dba_syntax = 1;
00309 s->skip_syntax = 1;
00310 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
00311 return ac3_parse_header(s);
00312 } else if (CONFIG_EAC3_DECODER) {
00313 s->eac3 = 1;
00314 return ff_eac3_parse_header(s);
00315 } else {
00316 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
00317 return -1;
00318 }
00319 }
00320
00325 static void set_downmix_coeffs(AC3DecodeContext *s)
00326 {
00327 int i;
00328 float cmix = gain_levels[center_levels[s->center_mix_level]];
00329 float smix = gain_levels[surround_levels[s->surround_mix_level]];
00330 float norm0, norm1;
00331
00332 for(i=0; i<s->fbw_channels; i++) {
00333 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
00334 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
00335 }
00336 if(s->channel_mode > 1 && s->channel_mode & 1) {
00337 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
00338 }
00339 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
00340 int nf = s->channel_mode - 2;
00341 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
00342 }
00343 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
00344 int nf = s->channel_mode - 4;
00345 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
00346 }
00347
00348
00349 norm0 = norm1 = 0.0;
00350 for(i=0; i<s->fbw_channels; i++) {
00351 norm0 += s->downmix_coeffs[i][0];
00352 norm1 += s->downmix_coeffs[i][1];
00353 }
00354 norm0 = 1.0f / norm0;
00355 norm1 = 1.0f / norm1;
00356 for(i=0; i<s->fbw_channels; i++) {
00357 s->downmix_coeffs[i][0] *= norm0;
00358 s->downmix_coeffs[i][1] *= norm1;
00359 }
00360
00361 if(s->output_mode == AC3_CHMODE_MONO) {
00362 for(i=0; i<s->fbw_channels; i++)
00363 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
00364 }
00365 }
00366
00371 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
00372 uint8_t absexp, int8_t *dexps)
00373 {
00374 int i, j, grp, group_size;
00375 int dexp[256];
00376 int expacc, prevexp;
00377
00378
00379 group_size = exp_strategy + (exp_strategy == EXP_D45);
00380 for(grp=0,i=0; grp<ngrps; grp++) {
00381 expacc = get_bits(gbc, 7);
00382 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
00383 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
00384 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
00385 }
00386
00387
00388 prevexp = absexp;
00389 for(i=0,j=0; i<ngrps*3; i++) {
00390 prevexp += dexp[i] - 2;
00391 if (prevexp > 24U)
00392 return -1;
00393 switch (group_size) {
00394 case 4: dexps[j++] = prevexp;
00395 dexps[j++] = prevexp;
00396 case 2: dexps[j++] = prevexp;
00397 case 1: dexps[j++] = prevexp;
00398 }
00399 }
00400 return 0;
00401 }
00402
00408 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
00409 {
00410 int bin, band, ch;
00411
00412 bin = s->start_freq[CPL_CH];
00413 for (band = 0; band < s->num_cpl_bands; band++) {
00414 int band_start = bin;
00415 int band_end = bin + s->cpl_band_sizes[band];
00416 for (ch = 1; ch <= s->fbw_channels; ch++) {
00417 if (s->channel_in_cpl[ch]) {
00418 int cpl_coord = s->cpl_coords[ch][band] << 5;
00419 for (bin = band_start; bin < band_end; bin++) {
00420 s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
00421 }
00422 if (ch == 2 && s->phase_flags[band]) {
00423 for (bin = band_start; bin < band_end; bin++)
00424 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
00425 }
00426 }
00427 }
00428 bin = band_end;
00429 }
00430 }
00431
00435 typedef struct {
00436 int b1_mant[2];
00437 int b2_mant[2];
00438 int b4_mant;
00439 int b1;
00440 int b2;
00441 int b4;
00442 } mant_groups;
00443
00448 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
00449 {
00450 int start_freq = s->start_freq[ch_index];
00451 int end_freq = s->end_freq[ch_index];
00452 uint8_t *baps = s->bap[ch_index];
00453 int8_t *exps = s->dexps[ch_index];
00454 int *coeffs = s->fixed_coeffs[ch_index];
00455 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];
00456 GetBitContext *gbc = &s->gbc;
00457 int freq;
00458
00459 for(freq = start_freq; freq < end_freq; freq++){
00460 int bap = baps[freq];
00461 int mantissa;
00462 switch(bap){
00463 case 0:
00464 if (dither)
00465 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
00466 else
00467 mantissa = 0;
00468 break;
00469 case 1:
00470 if(m->b1){
00471 m->b1--;
00472 mantissa = m->b1_mant[m->b1];
00473 }
00474 else{
00475 int bits = get_bits(gbc, 5);
00476 mantissa = b1_mantissas[bits][0];
00477 m->b1_mant[1] = b1_mantissas[bits][1];
00478 m->b1_mant[0] = b1_mantissas[bits][2];
00479 m->b1 = 2;
00480 }
00481 break;
00482 case 2:
00483 if(m->b2){
00484 m->b2--;
00485 mantissa = m->b2_mant[m->b2];
00486 }
00487 else{
00488 int bits = get_bits(gbc, 7);
00489 mantissa = b2_mantissas[bits][0];
00490 m->b2_mant[1] = b2_mantissas[bits][1];
00491 m->b2_mant[0] = b2_mantissas[bits][2];
00492 m->b2 = 2;
00493 }
00494 break;
00495 case 3:
00496 mantissa = b3_mantissas[get_bits(gbc, 3)];
00497 break;
00498 case 4:
00499 if(m->b4){
00500 m->b4 = 0;
00501 mantissa = m->b4_mant;
00502 }
00503 else{
00504 int bits = get_bits(gbc, 7);
00505 mantissa = b4_mantissas[bits][0];
00506 m->b4_mant = b4_mantissas[bits][1];
00507 m->b4 = 1;
00508 }
00509 break;
00510 case 5:
00511 mantissa = b5_mantissas[get_bits(gbc, 4)];
00512 break;
00513 default:
00514 mantissa = get_bits(gbc, quantization_tab[bap]);
00515
00516 mantissa = (mantissa << (32-quantization_tab[bap]))>>8;
00517 break;
00518 }
00519 coeffs[freq] = mantissa >> exps[freq];
00520 }
00521 }
00522
00528 static void remove_dithering(AC3DecodeContext *s) {
00529 int ch, i;
00530
00531 for(ch=1; ch<=s->fbw_channels; ch++) {
00532 if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
00533 for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) {
00534 if(!s->bap[CPL_CH][i])
00535 s->fixed_coeffs[ch][i] = 0;
00536 }
00537 }
00538 }
00539 }
00540
00541 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
00542 mant_groups *m)
00543 {
00544 if (!s->channel_uses_aht[ch]) {
00545 ac3_decode_transform_coeffs_ch(s, ch, m);
00546 } else {
00547
00548
00549 int bin;
00550 if (!blk && CONFIG_EAC3_DECODER)
00551 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
00552 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
00553 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
00554 }
00555 }
00556 }
00557
00561 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
00562 {
00563 int ch, end;
00564 int got_cplchan = 0;
00565 mant_groups m;
00566
00567 m.b1 = m.b2 = m.b4 = 0;
00568
00569 for (ch = 1; ch <= s->channels; ch++) {
00570
00571 decode_transform_coeffs_ch(s, blk, ch, &m);
00572
00573
00574 if (s->channel_in_cpl[ch]) {
00575 if (!got_cplchan) {
00576 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
00577 calc_transform_coeffs_cpl(s);
00578 got_cplchan = 1;
00579 }
00580 end = s->end_freq[CPL_CH];
00581 } else {
00582 end = s->end_freq[ch];
00583 }
00584 do
00585 s->fixed_coeffs[ch][end] = 0;
00586 while(++end < 256);
00587 }
00588
00589
00590 remove_dithering(s);
00591 }
00592
00597 static void do_rematrixing(AC3DecodeContext *s)
00598 {
00599 int bnd, i;
00600 int end, bndend;
00601
00602 end = FFMIN(s->end_freq[1], s->end_freq[2]);
00603
00604 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
00605 if(s->rematrixing_flags[bnd]) {
00606 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
00607 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
00608 int tmp0 = s->fixed_coeffs[1][i];
00609 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
00610 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];
00611 }
00612 }
00613 }
00614 }
00615
00621 static inline void do_imdct(AC3DecodeContext *s, int channels)
00622 {
00623 int ch;
00624
00625 for (ch=1; ch<=channels; ch++) {
00626 if (s->block_switch[ch]) {
00627 int i;
00628 float *x = s->tmp_output+128;
00629 for(i=0; i<128; i++)
00630 x[i] = s->transform_coeffs[ch][2*i];
00631 ff_imdct_half(&s->imdct_256, s->tmp_output, x);
00632 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
00633 for(i=0; i<128; i++)
00634 x[i] = s->transform_coeffs[ch][2*i+1];
00635 ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
00636 } else {
00637 ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
00638 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, 128);
00639 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
00640 }
00641 }
00642 }
00643
00647 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
00648 {
00649 int i, j;
00650 float v0, v1;
00651 if(out_ch == 2) {
00652 for(i=0; i<len; i++) {
00653 v0 = v1 = 0.0f;
00654 for(j=0; j<in_ch; j++) {
00655 v0 += samples[j][i] * matrix[j][0];
00656 v1 += samples[j][i] * matrix[j][1];
00657 }
00658 samples[0][i] = v0;
00659 samples[1][i] = v1;
00660 }
00661 } else if(out_ch == 1) {
00662 for(i=0; i<len; i++) {
00663 v0 = 0.0f;
00664 for(j=0; j<in_ch; j++)
00665 v0 += samples[j][i] * matrix[j][0];
00666 samples[0][i] = v0;
00667 }
00668 }
00669 }
00670
00674 static void ac3_upmix_delay(AC3DecodeContext *s)
00675 {
00676 int channel_data_size = sizeof(s->delay[0]);
00677 switch(s->channel_mode) {
00678 case AC3_CHMODE_DUALMONO:
00679 case AC3_CHMODE_STEREO:
00680
00681 memcpy(s->delay[1], s->delay[0], channel_data_size);
00682 break;
00683 case AC3_CHMODE_2F2R:
00684 memset(s->delay[3], 0, channel_data_size);
00685 case AC3_CHMODE_2F1R:
00686 memset(s->delay[2], 0, channel_data_size);
00687 break;
00688 case AC3_CHMODE_3F2R:
00689 memset(s->delay[4], 0, channel_data_size);
00690 case AC3_CHMODE_3F1R:
00691 memset(s->delay[3], 0, channel_data_size);
00692 case AC3_CHMODE_3F:
00693 memcpy(s->delay[2], s->delay[1], channel_data_size);
00694 memset(s->delay[1], 0, channel_data_size);
00695 break;
00696 }
00697 }
00698
00715 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
00716 int ecpl, int start_subband, int end_subband,
00717 const uint8_t *default_band_struct,
00718 int *num_bands, uint8_t *band_sizes)
00719 {
00720 int subbnd, bnd, n_subbands, n_bands=0;
00721 uint8_t bnd_sz[22];
00722 uint8_t coded_band_struct[22];
00723 const uint8_t *band_struct;
00724
00725 n_subbands = end_subband - start_subband;
00726
00727
00728 if (!eac3 || get_bits1(gbc)) {
00729 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
00730 coded_band_struct[subbnd] = get_bits1(gbc);
00731 }
00732 band_struct = coded_band_struct;
00733 } else if (!blk) {
00734 band_struct = &default_band_struct[start_subband+1];
00735 } else {
00736
00737 return;
00738 }
00739
00740
00741
00742
00743 if (num_bands || band_sizes ) {
00744 n_bands = n_subbands;
00745 bnd_sz[0] = ecpl ? 6 : 12;
00746 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
00747 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
00748 if (band_struct[subbnd-1]) {
00749 n_bands--;
00750 bnd_sz[bnd] += subbnd_size;
00751 } else {
00752 bnd_sz[++bnd] = subbnd_size;
00753 }
00754 }
00755 }
00756
00757
00758 if (num_bands)
00759 *num_bands = n_bands;
00760 if (band_sizes)
00761 memcpy(band_sizes, bnd_sz, n_bands);
00762 }
00763
00767 static int decode_audio_block(AC3DecodeContext *s, int blk)
00768 {
00769 int fbw_channels = s->fbw_channels;
00770 int channel_mode = s->channel_mode;
00771 int i, bnd, seg, ch;
00772 int different_transforms;
00773 int downmix_output;
00774 int cpl_in_use;
00775 GetBitContext *gbc = &s->gbc;
00776 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
00777
00778 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
00779
00780
00781 different_transforms = 0;
00782 if (s->block_switch_syntax) {
00783 for (ch = 1; ch <= fbw_channels; ch++) {
00784 s->block_switch[ch] = get_bits1(gbc);
00785 if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
00786 different_transforms = 1;
00787 }
00788 }
00789
00790
00791 if (s->dither_flag_syntax) {
00792 for (ch = 1; ch <= fbw_channels; ch++) {
00793 s->dither_flag[ch] = get_bits1(gbc);
00794 }
00795 }
00796
00797
00798 i = !(s->channel_mode);
00799 do {
00800 if(get_bits1(gbc)) {
00801 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
00802 s->avctx->drc_scale)+1.0;
00803 } else if(blk == 0) {
00804 s->dynamic_range[i] = 1.0f;
00805 }
00806 } while(i--);
00807
00808
00809 if (s->eac3 && (!blk || get_bits1(gbc))) {
00810 s->spx_in_use = get_bits1(gbc);
00811 if (s->spx_in_use) {
00812 int dst_start_freq, dst_end_freq, src_start_freq,
00813 start_subband, end_subband;
00814
00815
00816 if (s->channel_mode == AC3_CHMODE_MONO) {
00817 s->channel_uses_spx[1] = 1;
00818 } else {
00819 for (ch = 1; ch <= fbw_channels; ch++)
00820 s->channel_uses_spx[ch] = get_bits1(gbc);
00821 }
00822
00823
00824
00825 dst_start_freq = get_bits(gbc, 2);
00826 start_subband = get_bits(gbc, 3) + 2;
00827 if (start_subband > 7)
00828 start_subband += start_subband - 7;
00829 end_subband = get_bits(gbc, 3) + 5;
00830 if (end_subband > 7)
00831 end_subband += end_subband - 7;
00832 dst_start_freq = dst_start_freq * 12 + 25;
00833 src_start_freq = start_subband * 12 + 25;
00834 dst_end_freq = end_subband * 12 + 25;
00835
00836
00837 if (start_subband >= end_subband) {
00838 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
00839 "range (%d >= %d)\n", start_subband, end_subband);
00840 return -1;
00841 }
00842 if (dst_start_freq >= src_start_freq) {
00843 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
00844 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
00845 return -1;
00846 }
00847
00848 s->spx_dst_start_freq = dst_start_freq;
00849 s->spx_src_start_freq = src_start_freq;
00850 s->spx_dst_end_freq = dst_end_freq;
00851
00852 decode_band_structure(gbc, blk, s->eac3, 0,
00853 start_subband, end_subband,
00854 ff_eac3_default_spx_band_struct,
00855 &s->num_spx_bands,
00856 s->spx_band_sizes);
00857 } else {
00858 for (ch = 1; ch <= fbw_channels; ch++) {
00859 s->channel_uses_spx[ch] = 0;
00860 s->first_spx_coords[ch] = 1;
00861 }
00862 }
00863 }
00864
00865
00866 if (s->spx_in_use) {
00867 for (ch = 1; ch <= fbw_channels; ch++) {
00868 if (s->channel_uses_spx[ch]) {
00869 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
00870 float spx_blend;
00871 int bin, master_spx_coord;
00872
00873 s->first_spx_coords[ch] = 0;
00874 spx_blend = get_bits(gbc, 5) * (1.0f/32);
00875 master_spx_coord = get_bits(gbc, 2) * 3;
00876
00877 bin = s->spx_src_start_freq;
00878 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
00879 int bandsize;
00880 int spx_coord_exp, spx_coord_mant;
00881 float nratio, sblend, nblend, spx_coord;
00882
00883
00884 bandsize = s->spx_band_sizes[bnd];
00885 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
00886 nratio = av_clipf(nratio, 0.0f, 1.0f);
00887 nblend = sqrtf(3.0f * nratio);
00888 sblend = sqrtf(1.0f - nratio);
00889 bin += bandsize;
00890
00891
00892 spx_coord_exp = get_bits(gbc, 4);
00893 spx_coord_mant = get_bits(gbc, 2);
00894 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
00895 else spx_coord_mant += 4;
00896 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
00897 spx_coord = spx_coord_mant * (1.0f/(1<<23));
00898
00899
00900 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
00901 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
00902 }
00903 }
00904 } else {
00905 s->first_spx_coords[ch] = 1;
00906 }
00907 }
00908 }
00909
00910
00911 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
00912 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
00913 if (!s->eac3)
00914 s->cpl_in_use[blk] = get_bits1(gbc);
00915 if (s->cpl_in_use[blk]) {
00916
00917 int cpl_start_subband, cpl_end_subband;
00918
00919 if (channel_mode < AC3_CHMODE_STEREO) {
00920 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
00921 return -1;
00922 }
00923
00924
00925 if (s->eac3 && get_bits1(gbc)) {
00926
00927 av_log_missing_feature(s->avctx, "Enhanced coupling", 1);
00928 return -1;
00929 }
00930
00931
00932 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
00933 s->channel_in_cpl[1] = 1;
00934 s->channel_in_cpl[2] = 1;
00935 } else {
00936 for (ch = 1; ch <= fbw_channels; ch++)
00937 s->channel_in_cpl[ch] = get_bits1(gbc);
00938 }
00939
00940
00941 if (channel_mode == AC3_CHMODE_STEREO)
00942 s->phase_flags_in_use = get_bits1(gbc);
00943
00944
00945 cpl_start_subband = get_bits(gbc, 4);
00946 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
00947 get_bits(gbc, 4) + 3;
00948 if (cpl_start_subband >= cpl_end_subband) {
00949 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
00950 cpl_start_subband, cpl_end_subband);
00951 return -1;
00952 }
00953 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
00954 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;
00955
00956 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
00957 cpl_end_subband,
00958 ff_eac3_default_cpl_band_struct,
00959 &s->num_cpl_bands, s->cpl_band_sizes);
00960 } else {
00961
00962 for (ch = 1; ch <= fbw_channels; ch++) {
00963 s->channel_in_cpl[ch] = 0;
00964 s->first_cpl_coords[ch] = 1;
00965 }
00966 s->first_cpl_leak = s->eac3;
00967 s->phase_flags_in_use = 0;
00968 }
00969 } else if (!s->eac3) {
00970 if(!blk) {
00971 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
00972 return -1;
00973 } else {
00974 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
00975 }
00976 }
00977 cpl_in_use = s->cpl_in_use[blk];
00978
00979
00980 if (cpl_in_use) {
00981 int cpl_coords_exist = 0;
00982
00983 for (ch = 1; ch <= fbw_channels; ch++) {
00984 if (s->channel_in_cpl[ch]) {
00985 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
00986 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
00987 s->first_cpl_coords[ch] = 0;
00988 cpl_coords_exist = 1;
00989 master_cpl_coord = 3 * get_bits(gbc, 2);
00990 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
00991 cpl_coord_exp = get_bits(gbc, 4);
00992 cpl_coord_mant = get_bits(gbc, 4);
00993 if (cpl_coord_exp == 15)
00994 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
00995 else
00996 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
00997 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
00998 }
00999 } else if (!blk) {
01000 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
01001 return -1;
01002 }
01003 } else {
01004
01005 s->first_cpl_coords[ch] = 1;
01006 }
01007 }
01008
01009 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
01010 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
01011 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
01012 }
01013 }
01014 }
01015
01016
01017 if (channel_mode == AC3_CHMODE_STEREO) {
01018 if ((s->eac3 && !blk) || get_bits1(gbc)) {
01019 s->num_rematrixing_bands = 4;
01020 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
01021 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
01022 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
01023 s->num_rematrixing_bands--;
01024 }
01025 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
01026 s->rematrixing_flags[bnd] = get_bits1(gbc);
01027 } else if (!blk) {
01028 av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n");
01029 s->num_rematrixing_bands = 0;
01030 }
01031 }
01032
01033
01034 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01035 if (!s->eac3)
01036 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
01037 if(s->exp_strategy[blk][ch] != EXP_REUSE)
01038 bit_alloc_stages[ch] = 3;
01039 }
01040
01041
01042 for (ch = 1; ch <= fbw_channels; ch++) {
01043 s->start_freq[ch] = 0;
01044 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
01045 int group_size;
01046 int prev = s->end_freq[ch];
01047 if (s->channel_in_cpl[ch])
01048 s->end_freq[ch] = s->start_freq[CPL_CH];
01049 else if (s->channel_uses_spx[ch])
01050 s->end_freq[ch] = s->spx_src_start_freq;
01051 else {
01052 int bandwidth_code = get_bits(gbc, 6);
01053 if (bandwidth_code > 60) {
01054 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
01055 return -1;
01056 }
01057 s->end_freq[ch] = bandwidth_code * 3 + 73;
01058 }
01059 group_size = 3 << (s->exp_strategy[blk][ch] - 1);
01060 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
01061 if(blk > 0 && s->end_freq[ch] != prev)
01062 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
01063 }
01064 }
01065 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
01066 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
01067 (3 << (s->exp_strategy[blk][CPL_CH] - 1));
01068 }
01069
01070
01071 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01072 if (s->exp_strategy[blk][ch] != EXP_REUSE) {
01073 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
01074 if (decode_exponents(gbc, s->exp_strategy[blk][ch],
01075 s->num_exp_groups[ch], s->dexps[ch][0],
01076 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
01077 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
01078 return -1;
01079 }
01080 if(ch != CPL_CH && ch != s->lfe_ch)
01081 skip_bits(gbc, 2);
01082 }
01083 }
01084
01085
01086 if (s->bit_allocation_syntax) {
01087 if (get_bits1(gbc)) {
01088 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01089 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
01090 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
01091 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
01092 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];
01093 for(ch=!cpl_in_use; ch<=s->channels; ch++)
01094 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01095 } else if (!blk) {
01096 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
01097 return -1;
01098 }
01099 }
01100
01101
01102 if(!s->eac3 || !blk){
01103 if(s->snr_offset_strategy && get_bits1(gbc)) {
01104 int snr = 0;
01105 int csnr;
01106 csnr = (get_bits(gbc, 6) - 15) << 4;
01107 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
01108
01109 if (ch == i || s->snr_offset_strategy == 2)
01110 snr = (csnr + get_bits(gbc, 4)) << 2;
01111
01112 if(blk && s->snr_offset[ch] != snr) {
01113 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
01114 }
01115 s->snr_offset[ch] = snr;
01116
01117
01118 if (!s->eac3) {
01119 int prev = s->fast_gain[ch];
01120 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01121
01122 if(blk && prev != s->fast_gain[ch])
01123 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01124 }
01125 }
01126 } else if (!s->eac3 && !blk) {
01127 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
01128 return -1;
01129 }
01130 }
01131
01132
01133 if (s->fast_gain_syntax && get_bits1(gbc)) {
01134 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
01135 int prev = s->fast_gain[ch];
01136 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
01137
01138 if(blk && prev != s->fast_gain[ch])
01139 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01140 }
01141 } else if (s->eac3 && !blk) {
01142 for (ch = !cpl_in_use; ch <= s->channels; ch++)
01143 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
01144 }
01145
01146
01147 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
01148 skip_bits(gbc, 10);
01149 }
01150
01151
01152 if (cpl_in_use) {
01153 if (s->first_cpl_leak || get_bits1(gbc)) {
01154 int fl = get_bits(gbc, 3);
01155 int sl = get_bits(gbc, 3);
01156
01157
01158 if(blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
01159 sl != s->bit_alloc_params.cpl_slow_leak)) {
01160 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
01161 }
01162 s->bit_alloc_params.cpl_fast_leak = fl;
01163 s->bit_alloc_params.cpl_slow_leak = sl;
01164 } else if (!s->eac3 && !blk) {
01165 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
01166 return -1;
01167 }
01168 s->first_cpl_leak = 0;
01169 }
01170
01171
01172 if (s->dba_syntax && get_bits1(gbc)) {
01173
01174 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01175 s->dba_mode[ch] = get_bits(gbc, 2);
01176 if (s->dba_mode[ch] == DBA_RESERVED) {
01177 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
01178 return -1;
01179 }
01180 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01181 }
01182
01183 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
01184 if (s->dba_mode[ch] == DBA_NEW) {
01185 s->dba_nsegs[ch] = get_bits(gbc, 3);
01186 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
01187 s->dba_offsets[ch][seg] = get_bits(gbc, 5);
01188 s->dba_lengths[ch][seg] = get_bits(gbc, 4);
01189 s->dba_values[ch][seg] = get_bits(gbc, 3);
01190 }
01191
01192 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
01193 }
01194 }
01195 } else if(blk == 0) {
01196 for(ch=0; ch<=s->channels; ch++) {
01197 s->dba_mode[ch] = DBA_NONE;
01198 }
01199 }
01200
01201
01202 for(ch=!cpl_in_use; ch<=s->channels; ch++) {
01203 if(bit_alloc_stages[ch] > 2) {
01204
01205 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
01206 s->start_freq[ch], s->end_freq[ch],
01207 s->psd[ch], s->band_psd[ch]);
01208 }
01209 if(bit_alloc_stages[ch] > 1) {
01210
01211
01212 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
01213 s->start_freq[ch], s->end_freq[ch],
01214 s->fast_gain[ch], (ch == s->lfe_ch),
01215 s->dba_mode[ch], s->dba_nsegs[ch],
01216 s->dba_offsets[ch], s->dba_lengths[ch],
01217 s->dba_values[ch], s->mask[ch])) {
01218 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
01219 return -1;
01220 }
01221 }
01222 if(bit_alloc_stages[ch] > 0) {
01223
01224 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
01225 ff_eac3_hebap_tab : ff_ac3_bap_tab;
01226 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
01227 s->start_freq[ch], s->end_freq[ch],
01228 s->snr_offset[ch],
01229 s->bit_alloc_params.floor,
01230 bap_tab, s->bap[ch]);
01231 }
01232 }
01233
01234
01235 if (s->skip_syntax && get_bits1(gbc)) {
01236 int skipl = get_bits(gbc, 9);
01237 while(skipl--)
01238 skip_bits(gbc, 8);
01239 }
01240
01241
01242
01243 decode_transform_coeffs(s, blk);
01244
01245
01246
01247
01248 if(s->channel_mode == AC3_CHMODE_STEREO)
01249 do_rematrixing(s);
01250
01251
01252 for(ch=1; ch<=s->channels; ch++) {
01253 float gain = s->mul_bias / 4194304.0f;
01254 if(s->channel_mode == AC3_CHMODE_DUALMONO) {
01255 gain *= s->dynamic_range[2-ch];
01256 } else {
01257 gain *= s->dynamic_range[0];
01258 }
01259 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
01260 }
01261
01262
01263 if (s->spx_in_use && CONFIG_EAC3_DECODER) {
01264 ff_eac3_apply_spectral_extension(s);
01265 }
01266
01267
01268
01269
01270 downmix_output = s->channels != s->out_channels &&
01271 !((s->output_mode & AC3_OUTPUT_LFEON) &&
01272 s->fbw_channels == s->out_channels);
01273 if(different_transforms) {
01274
01275
01276 if(s->downmixed) {
01277 s->downmixed = 0;
01278 ac3_upmix_delay(s);
01279 }
01280
01281 do_imdct(s, s->channels);
01282
01283 if(downmix_output) {
01284 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
01285 }
01286 } else {
01287 if(downmix_output) {
01288 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
01289 }
01290
01291 if(downmix_output && !s->downmixed) {
01292 s->downmixed = 1;
01293 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
01294 }
01295
01296 do_imdct(s, s->out_channels);
01297 }
01298
01299 return 0;
01300 }
01301
01305 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
01306 AVPacket *avpkt)
01307 {
01308 const uint8_t *buf = avpkt->data;
01309 int buf_size = avpkt->size;
01310 AC3DecodeContext *s = avctx->priv_data;
01311 int16_t *out_samples = (int16_t *)data;
01312 int blk, ch, err;
01313 const uint8_t *channel_map;
01314 const float *output[AC3_MAX_CHANNELS];
01315
01316
01317 if (s->input_buffer) {
01318
01319
01320 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
01321 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
01322 } else {
01323 init_get_bits(&s->gbc, buf, buf_size * 8);
01324 }
01325
01326
01327 *data_size = 0;
01328 err = parse_frame_header(s);
01329
01330 if (err) {
01331 switch(err) {
01332 case AAC_AC3_PARSE_ERROR_SYNC:
01333 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
01334 return -1;
01335 case AAC_AC3_PARSE_ERROR_BSID:
01336 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
01337 break;
01338 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
01339 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
01340 break;
01341 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
01342 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
01343 break;
01344 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
01345
01346
01347 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
01348 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
01349 return s->frame_size;
01350 } else {
01351 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
01352 }
01353 break;
01354 default:
01355 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
01356 break;
01357 }
01358 } else {
01359
01360 if (s->frame_size > buf_size) {
01361 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
01362 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
01363 } else if (avctx->error_recognition >= FF_ER_CAREFUL) {
01364
01365 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
01366 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
01367 err = AAC_AC3_PARSE_ERROR_CRC;
01368 }
01369 }
01370 }
01371
01372
01373 if (!err) {
01374 avctx->sample_rate = s->sample_rate;
01375 avctx->bit_rate = s->bit_rate;
01376
01377
01378 s->out_channels = s->channels;
01379 s->output_mode = s->channel_mode;
01380 if(s->lfe_on)
01381 s->output_mode |= AC3_OUTPUT_LFEON;
01382 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
01383 avctx->request_channels < s->channels) {
01384 s->out_channels = avctx->request_channels;
01385 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01386 s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];
01387 }
01388 avctx->channels = s->out_channels;
01389 avctx->channel_layout = s->channel_layout;
01390
01391
01392 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
01393 s->fbw_channels == s->out_channels)) {
01394 set_downmix_coeffs(s);
01395 }
01396 } else if (!s->out_channels) {
01397 s->out_channels = avctx->channels;
01398 if(s->out_channels < s->channels)
01399 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
01400 }
01401
01402
01403 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
01404 for (ch = 0; ch < s->out_channels; ch++)
01405 output[ch] = s->output[channel_map[ch]];
01406 for (blk = 0; blk < s->num_blocks; blk++) {
01407 if (!err && decode_audio_block(s, blk)) {
01408 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
01409 err = 1;
01410 }
01411 s->fmt_conv.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
01412 out_samples += 256 * s->out_channels;
01413 }
01414 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
01415 return FFMIN(buf_size, s->frame_size);
01416 }
01417
01421 static av_cold int ac3_decode_end(AVCodecContext *avctx)
01422 {
01423 AC3DecodeContext *s = avctx->priv_data;
01424 ff_mdct_end(&s->imdct_512);
01425 ff_mdct_end(&s->imdct_256);
01426
01427 av_freep(&s->input_buffer);
01428
01429 return 0;
01430 }
01431
01432 AVCodec ff_ac3_decoder = {
01433 .name = "ac3",
01434 .type = AVMEDIA_TYPE_AUDIO,
01435 .id = CODEC_ID_AC3,
01436 .priv_data_size = sizeof (AC3DecodeContext),
01437 .init = ac3_decode_init,
01438 .close = ac3_decode_end,
01439 .decode = ac3_decode_frame,
01440 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
01441 };
01442
01443 #if CONFIG_EAC3_DECODER
01444 AVCodec ff_eac3_decoder = {
01445 .name = "eac3",
01446 .type = AVMEDIA_TYPE_AUDIO,
01447 .id = CODEC_ID_EAC3,
01448 .priv_data_size = sizeof (AC3DecodeContext),
01449 .init = ac3_decode_init,
01450 .close = ac3_decode_end,
01451 .decode = ac3_decode_frame,
01452 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
01453 };
01454 #endif