1/* 2 * AC-3 Audio Decoder 3 * This code was developed as part of Google Summer of Code 2006. 4 * E-AC-3 support was added as part of Google Summer of Code 2007. 5 * 6 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com) 7 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com> 8 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com> 9 * 10 * This file is part of FFmpeg. 11 * 12 * FFmpeg is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU Lesser General Public 14 * License as published by the Free Software Foundation; either 15 * version 2.1 of the License, or (at your option) any later version. 16 * 17 * FFmpeg is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * Lesser General Public License for more details. 21 * 22 * You should have received a copy of the GNU Lesser General Public 23 * License along with FFmpeg; if not, write to the Free Software 24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 25 */ 26 27#include "config_components.h" 28 29#include <stdio.h> 30#include <stddef.h> 31#include <math.h> 32#include <string.h> 33 34#include "libavutil/channel_layout.h" 35#include "libavutil/crc.h" 36#include "libavutil/downmix_info.h" 37#include "libavutil/intmath.h" 38#include "libavutil/opt.h" 39#include "libavutil/thread.h" 40#include "bswapdsp.h" 41#include "internal.h" 42#include "aac_ac3_parser.h" 43#include "ac3_parser_internal.h" 44#include "ac3dec.h" 45#include "ac3dec_data.h" 46#include "ac3defs.h" 47#include "kbdwin.h" 48 49/** 50 * table for ungrouping 3 values in 7 bits. 51 * used for exponents and bap=2 mantissas 52 */ 53static uint8_t ungroup_3_in_7_bits_tab[128][3]; 54 55/** tables for ungrouping mantissas */ 56static int b1_mantissas[32][3]; 57static int b2_mantissas[128][3]; 58static int b3_mantissas[8]; 59static int b4_mantissas[128][2]; 60static int b5_mantissas[16]; 61 62/** 63 * Quantization table: levels for symmetric. bits for asymmetric. 64 * reference: Table 7.18 Mapping of bap to Quantizer 65 */ 66static const uint8_t quantization_tab[16] = { 67 0, 3, 5, 7, 11, 15, 68 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 69}; 70 71#if (!USE_FIXED) 72/** dynamic range table. converts codes to scale factors. */ 73static float dynamic_range_tab[256]; 74float ff_ac3_heavy_dynamic_range_tab[256]; 75#endif 76 77/** Adjustments in dB gain */ 78static const float gain_levels[9] = { 79 LEVEL_PLUS_3DB, 80 LEVEL_PLUS_1POINT5DB, 81 LEVEL_ONE, 82 LEVEL_MINUS_1POINT5DB, 83 LEVEL_MINUS_3DB, 84 LEVEL_MINUS_4POINT5DB, 85 LEVEL_MINUS_6DB, 86 LEVEL_ZERO, 87 LEVEL_MINUS_9DB 88}; 89 90/** Adjustments in dB gain (LFE, +10 to -21 dB) */ 91static const float gain_levels_lfe[32] = { 92 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893, 93 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946, 94 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227, 95 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253, 96 0.125892, 0.112201, 0.100000, 0.089125 97}; 98 99/** 100 * Table for default stereo downmixing coefficients 101 * reference: Section 7.8.2 Downmixing Into Two Channels 102 */ 103static const uint8_t ac3_default_coeffs[8][5][2] = { 104 { { 2, 7 }, { 7, 2 }, }, 105 { { 4, 4 }, }, 106 { { 2, 7 }, { 7, 2 }, }, 107 { { 2, 7 }, { 5, 5 }, { 7, 2 }, }, 108 { { 2, 7 }, { 7, 2 }, { 6, 6 }, }, 109 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, }, 110 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, }, 111 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, }, 112}; 113 114/** 115 * Symmetrical Dequantization 116 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization 117 * Tables 7.19 to 7.23 118 */ 119static inline int 120symmetric_dequant(int code, int levels) 121{ 122 return ((code - (levels >> 1)) * (1 << 24)) / levels; 123} 124 125/* 126 * Initialize tables at runtime. 127 */ 128static av_cold void ac3_tables_init(void) 129{ 130 int i; 131 132 /* generate table for ungrouping 3 values in 7 bits 133 reference: Section 7.1.3 Exponent Decoding */ 134 for (i = 0; i < 128; i++) { 135 ungroup_3_in_7_bits_tab[i][0] = i / 25; 136 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5; 137 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5; 138 } 139 140 /* generate grouped mantissa tables 141 reference: Section 7.3.5 Ungrouping of Mantissas */ 142 for (i = 0; i < 32; i++) { 143 /* bap=1 mantissas */ 144 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3); 145 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3); 146 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3); 147 } 148 for (i = 0; i < 128; i++) { 149 /* bap=2 mantissas */ 150 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5); 151 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5); 152 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5); 153 154 /* bap=4 mantissas */ 155 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11); 156 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11); 157 } 158 /* generate ungrouped mantissa tables 159 reference: Tables 7.21 and 7.23 */ 160 for (i = 0; i < 7; i++) { 161 /* bap=3 mantissas */ 162 b3_mantissas[i] = symmetric_dequant(i, 7); 163 } 164 for (i = 0; i < 15; i++) { 165 /* bap=5 mantissas */ 166 b5_mantissas[i] = symmetric_dequant(i, 15); 167 } 168 169#if (!USE_FIXED) 170 /* generate dynamic range table 171 reference: Section 7.7.1 Dynamic Range Control */ 172 for (i = 0; i < 256; i++) { 173 int v = (i >> 5) - ((i >> 7) << 3) - 5; 174 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20); 175 } 176 177 /* generate compr dynamic range table 178 reference: Section 7.7.2 Heavy Compression */ 179 for (i = 0; i < 256; i++) { 180 int v = (i >> 4) - ((i >> 7) << 4) - 4; 181 ff_ac3_heavy_dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0xF) | 0x10); 182 } 183#endif 184} 185 186/** 187 * AVCodec initialization 188 */ 189static av_cold int ac3_decode_init(AVCodecContext *avctx) 190{ 191 static AVOnce init_static_once = AV_ONCE_INIT; 192 AC3DecodeContext *s = avctx->priv_data; 193 const AVChannelLayout mono = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; 194 const AVChannelLayout stereo = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; 195 int i, ret; 196 197 s->avctx = avctx; 198 199 if ((ret = ff_mdct_init(&s->imdct_256, 8, 1, 1.0)) < 0 || 200 (ret = ff_mdct_init(&s->imdct_512, 9, 1, 1.0)) < 0) 201 return ret; 202 AC3_RENAME(ff_kbd_window_init)(s->window, 5.0, 256); 203 ff_bswapdsp_init(&s->bdsp); 204 205#if (USE_FIXED) 206 s->fdsp = avpriv_alloc_fixed_dsp(avctx->flags & AV_CODEC_FLAG_BITEXACT); 207#else 208 ff_fmt_convert_init(&s->fmt_conv, avctx); 209 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT); 210#endif 211 if (!s->fdsp) 212 return AVERROR(ENOMEM); 213 214 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & AV_CODEC_FLAG_BITEXACT); 215 av_lfg_init(&s->dith_state, 0); 216 217 if (USE_FIXED) 218 avctx->sample_fmt = AV_SAMPLE_FMT_S16P; 219 else 220 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; 221 222 /* allow downmixing to stereo or mono */ 223#if FF_API_OLD_CHANNEL_LAYOUT 224FF_DISABLE_DEPRECATION_WARNINGS 225 if (avctx->request_channel_layout) { 226 av_channel_layout_uninit(&s->downmix_layout); 227 av_channel_layout_from_mask(&s->downmix_layout, avctx->request_channel_layout); 228 } 229FF_ENABLE_DEPRECATION_WARNINGS 230#endif 231 if (avctx->ch_layout.nb_channels > 1 && 232 !av_channel_layout_compare(&s->downmix_layout, &mono)) { 233 av_channel_layout_uninit(&avctx->ch_layout); 234 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; 235 } else if (avctx->ch_layout.nb_channels > 2 && 236 !av_channel_layout_compare(&s->downmix_layout, &stereo)) { 237 av_channel_layout_uninit(&avctx->ch_layout); 238 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; 239 } 240 s->downmixed = 1; 241 242 for (i = 0; i < AC3_MAX_CHANNELS; i++) { 243 s->xcfptr[i] = s->transform_coeffs[i]; 244 s->dlyptr[i] = s->delay[i]; 245 } 246 247 ff_thread_once(&init_static_once, ac3_tables_init); 248 249 return 0; 250} 251 252/** 253 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream. 254 * GetBitContext within AC3DecodeContext must point to 255 * the start of the synchronized AC-3 bitstream. 256 */ 257static int ac3_parse_header(AC3DecodeContext *s) 258{ 259 GetBitContext *gbc = &s->gbc; 260 int i; 261 262 /* read the rest of the bsi. read twice for dual mono mode. */ 263 i = !s->channel_mode; 264 do { 265 s->dialog_normalization[(!s->channel_mode)-i] = -get_bits(gbc, 5); 266 if (s->dialog_normalization[(!s->channel_mode)-i] == 0) { 267 s->dialog_normalization[(!s->channel_mode)-i] = -31; 268 } 269 if (s->target_level != 0) { 270 s->level_gain[(!s->channel_mode)-i] = powf(2.0f, 271 (float)(s->target_level - 272 s->dialog_normalization[(!s->channel_mode)-i])/6.0f); 273 } 274 if (s->compression_exists[(!s->channel_mode)-i] = get_bits1(gbc)) { 275 s->heavy_dynamic_range[(!s->channel_mode)-i] = 276 AC3_HEAVY_RANGE(get_bits(gbc, 8)); 277 } 278 if (get_bits1(gbc)) 279 skip_bits(gbc, 8); //skip language code 280 if (get_bits1(gbc)) 281 skip_bits(gbc, 7); //skip audio production information 282 } while (i--); 283 284 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit 285 286 /* skip the timecodes or parse the Alternate Bit Stream Syntax */ 287 if (s->bitstream_id != 6) { 288 if (get_bits1(gbc)) 289 skip_bits(gbc, 14); //skip timecode1 290 if (get_bits1(gbc)) 291 skip_bits(gbc, 14); //skip timecode2 292 } else { 293 if (get_bits1(gbc)) { 294 s->preferred_downmix = get_bits(gbc, 2); 295 s->center_mix_level_ltrt = get_bits(gbc, 3); 296 s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7); 297 s->center_mix_level = get_bits(gbc, 3); 298 s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7); 299 } 300 if (get_bits1(gbc)) { 301 s->dolby_surround_ex_mode = get_bits(gbc, 2); 302 s->dolby_headphone_mode = get_bits(gbc, 2); 303 skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1) 304 } 305 } 306 307 /* skip additional bitstream info */ 308 if (get_bits1(gbc)) { 309 i = get_bits(gbc, 6); 310 do { 311 skip_bits(gbc, 8); 312 } while (i--); 313 } 314 315 return 0; 316} 317 318/** 319 * Common function to parse AC-3 or E-AC-3 frame header 320 */ 321static int parse_frame_header(AC3DecodeContext *s) 322{ 323 AC3HeaderInfo hdr; 324 int err; 325 326 err = ff_ac3_parse_header(&s->gbc, &hdr); 327 if (err) 328 return err; 329 330 /* get decoding parameters from header info */ 331 s->bit_alloc_params.sr_code = hdr.sr_code; 332 s->bitstream_id = hdr.bitstream_id; 333 s->bitstream_mode = hdr.bitstream_mode; 334 s->channel_mode = hdr.channel_mode; 335 s->lfe_on = hdr.lfe_on; 336 s->bit_alloc_params.sr_shift = hdr.sr_shift; 337 s->sample_rate = hdr.sample_rate; 338 s->bit_rate = hdr.bit_rate; 339 s->channels = hdr.channels; 340 s->fbw_channels = s->channels - s->lfe_on; 341 s->lfe_ch = s->fbw_channels + 1; 342 s->frame_size = hdr.frame_size; 343 s->superframe_size += hdr.frame_size; 344 s->preferred_downmix = AC3_DMIXMOD_NOTINDICATED; 345 s->center_mix_level = hdr.center_mix_level; 346 s->center_mix_level_ltrt = 4; // -3.0dB 347 s->surround_mix_level = hdr.surround_mix_level; 348 s->surround_mix_level_ltrt = 4; // -3.0dB 349 s->lfe_mix_level_exists = 0; 350 s->num_blocks = hdr.num_blocks; 351 s->frame_type = hdr.frame_type; 352 s->substreamid = hdr.substreamid; 353 s->dolby_surround_mode = hdr.dolby_surround_mode; 354 s->dolby_surround_ex_mode = AC3_DSUREXMOD_NOTINDICATED; 355 s->dolby_headphone_mode = AC3_DHEADPHONMOD_NOTINDICATED; 356 357 if (s->lfe_on) { 358 s->start_freq[s->lfe_ch] = 0; 359 s->end_freq[s->lfe_ch] = 7; 360 s->num_exp_groups[s->lfe_ch] = 2; 361 s->channel_in_cpl[s->lfe_ch] = 0; 362 } 363 364 if (s->bitstream_id <= 10) { 365 s->eac3 = 0; 366 s->snr_offset_strategy = 2; 367 s->block_switch_syntax = 1; 368 s->dither_flag_syntax = 1; 369 s->bit_allocation_syntax = 1; 370 s->fast_gain_syntax = 0; 371 s->first_cpl_leak = 0; 372 s->dba_syntax = 1; 373 s->skip_syntax = 1; 374 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht)); 375 return ac3_parse_header(s); 376 } else if (CONFIG_EAC3_DECODER) { 377 s->eac3 = 1; 378 return ff_eac3_parse_header(s); 379 } else { 380 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n"); 381 return AVERROR(ENOSYS); 382 } 383} 384 385/** 386 * Set stereo downmixing coefficients based on frame header info. 387 * reference: Section 7.8.2 Downmixing Into Two Channels 388 */ 389static int set_downmix_coeffs(AC3DecodeContext *s) 390{ 391 int i; 392 float cmix = gain_levels[s-> center_mix_level]; 393 float smix = gain_levels[s->surround_mix_level]; 394 float norm0, norm1; 395 float downmix_coeffs[2][AC3_MAX_CHANNELS]; 396 397 if (!s->downmix_coeffs[0]) { 398 s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS, 399 sizeof(**s->downmix_coeffs)); 400 if (!s->downmix_coeffs[0]) 401 return AVERROR(ENOMEM); 402 s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS; 403 } 404 405 for (i = 0; i < s->fbw_channels; i++) { 406 downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]]; 407 downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]]; 408 } 409 if (s->channel_mode > 1 && s->channel_mode & 1) { 410 downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix; 411 } 412 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) { 413 int nf = s->channel_mode - 2; 414 downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB; 415 } 416 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) { 417 int nf = s->channel_mode - 4; 418 downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix; 419 } 420 421 /* renormalize */ 422 norm0 = norm1 = 0.0; 423 for (i = 0; i < s->fbw_channels; i++) { 424 norm0 += downmix_coeffs[0][i]; 425 norm1 += downmix_coeffs[1][i]; 426 } 427 norm0 = 1.0f / norm0; 428 norm1 = 1.0f / norm1; 429 for (i = 0; i < s->fbw_channels; i++) { 430 downmix_coeffs[0][i] *= norm0; 431 downmix_coeffs[1][i] *= norm1; 432 } 433 434 if (s->output_mode == AC3_CHMODE_MONO) { 435 for (i = 0; i < s->fbw_channels; i++) 436 downmix_coeffs[0][i] = (downmix_coeffs[0][i] + 437 downmix_coeffs[1][i]) * LEVEL_MINUS_3DB; 438 } 439 for (i = 0; i < s->fbw_channels; i++) { 440 s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]); 441 s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]); 442 } 443 444 return 0; 445} 446 447/** 448 * Decode the grouped exponents according to exponent strategy. 449 * reference: Section 7.1.3 Exponent Decoding 450 */ 451static int decode_exponents(AC3DecodeContext *s, 452 GetBitContext *gbc, int exp_strategy, int ngrps, 453 uint8_t absexp, int8_t *dexps) 454{ 455 int i, j, grp, group_size; 456 int dexp[256]; 457 int expacc, prevexp; 458 459 /* unpack groups */ 460 group_size = exp_strategy + (exp_strategy == EXP_D45); 461 for (grp = 0, i = 0; grp < ngrps; grp++) { 462 expacc = get_bits(gbc, 7); 463 if (expacc >= 125) { 464 av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc); 465 return AVERROR_INVALIDDATA; 466 } 467 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0]; 468 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1]; 469 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2]; 470 } 471 472 /* convert to absolute exps and expand groups */ 473 prevexp = absexp; 474 for (i = 0, j = 0; i < ngrps * 3; i++) { 475 prevexp += dexp[i] - 2; 476 if (prevexp > 24U) { 477 av_log(s->avctx, AV_LOG_ERROR, "exponent %d is out-of-range\n", prevexp); 478 return AVERROR_INVALIDDATA; 479 } 480 switch (group_size) { 481 case 4: dexps[j++] = prevexp; 482 dexps[j++] = prevexp; 483 case 2: dexps[j++] = prevexp; 484 case 1: dexps[j++] = prevexp; 485 } 486 } 487 return 0; 488} 489 490/** 491 * Generate transform coefficients for each coupled channel in the coupling 492 * range using the coupling coefficients and coupling coordinates. 493 * reference: Section 7.4.3 Coupling Coordinate Format 494 */ 495static void calc_transform_coeffs_cpl(AC3DecodeContext *s) 496{ 497 int bin, band, ch; 498 499 bin = s->start_freq[CPL_CH]; 500 for (band = 0; band < s->num_cpl_bands; band++) { 501 int band_start = bin; 502 int band_end = bin + s->cpl_band_sizes[band]; 503 for (ch = 1; ch <= s->fbw_channels; ch++) { 504 if (s->channel_in_cpl[ch]) { 505 int cpl_coord = s->cpl_coords[ch][band] << 5; 506 for (bin = band_start; bin < band_end; bin++) { 507 s->fixed_coeffs[ch][bin] = 508 MULH(s->fixed_coeffs[CPL_CH][bin] * (1 << 4), cpl_coord); 509 } 510 if (ch == 2 && s->phase_flags[band]) { 511 for (bin = band_start; bin < band_end; bin++) 512 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin]; 513 } 514 } 515 } 516 bin = band_end; 517 } 518} 519 520/** 521 * Grouped mantissas for 3-level 5-level and 11-level quantization 522 */ 523typedef struct mant_groups { 524 int b1_mant[2]; 525 int b2_mant[2]; 526 int b4_mant; 527 int b1; 528 int b2; 529 int b4; 530} mant_groups; 531 532/** 533 * Decode the transform coefficients for a particular channel 534 * reference: Section 7.3 Quantization and Decoding of Mantissas 535 */ 536static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) 537{ 538 int start_freq = s->start_freq[ch_index]; 539 int end_freq = s->end_freq[ch_index]; 540 uint8_t *baps = s->bap[ch_index]; 541 int8_t *exps = s->dexps[ch_index]; 542 int32_t *coeffs = s->fixed_coeffs[ch_index]; 543 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index]; 544 GetBitContext *gbc = &s->gbc; 545 int freq; 546 547 for (freq = start_freq; freq < end_freq; freq++) { 548 int bap = baps[freq]; 549 int mantissa; 550 switch (bap) { 551 case 0: 552 /* random noise with approximate range of -0.707 to 0.707 */ 553 if (dither) 554 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008; 555 else 556 mantissa = 0; 557 break; 558 case 1: 559 if (m->b1) { 560 m->b1--; 561 mantissa = m->b1_mant[m->b1]; 562 } else { 563 int bits = get_bits(gbc, 5); 564 mantissa = b1_mantissas[bits][0]; 565 m->b1_mant[1] = b1_mantissas[bits][1]; 566 m->b1_mant[0] = b1_mantissas[bits][2]; 567 m->b1 = 2; 568 } 569 break; 570 case 2: 571 if (m->b2) { 572 m->b2--; 573 mantissa = m->b2_mant[m->b2]; 574 } else { 575 int bits = get_bits(gbc, 7); 576 mantissa = b2_mantissas[bits][0]; 577 m->b2_mant[1] = b2_mantissas[bits][1]; 578 m->b2_mant[0] = b2_mantissas[bits][2]; 579 m->b2 = 2; 580 } 581 break; 582 case 3: 583 mantissa = b3_mantissas[get_bits(gbc, 3)]; 584 break; 585 case 4: 586 if (m->b4) { 587 m->b4 = 0; 588 mantissa = m->b4_mant; 589 } else { 590 int bits = get_bits(gbc, 7); 591 mantissa = b4_mantissas[bits][0]; 592 m->b4_mant = b4_mantissas[bits][1]; 593 m->b4 = 1; 594 } 595 break; 596 case 5: 597 mantissa = b5_mantissas[get_bits(gbc, 4)]; 598 break; 599 default: /* 6 to 15 */ 600 /* Shift mantissa and sign-extend it. */ 601 if (bap > 15) { 602 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap); 603 bap = 15; 604 } 605 mantissa = (unsigned)get_sbits(gbc, quantization_tab[bap]) << (24 - quantization_tab[bap]); 606 break; 607 } 608 coeffs[freq] = mantissa >> exps[freq]; 609 } 610} 611 612/** 613 * Remove random dithering from coupling range coefficients with zero-bit 614 * mantissas for coupled channels which do not use dithering. 615 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0) 616 */ 617static void remove_dithering(AC3DecodeContext *s) { 618 int ch, i; 619 620 for (ch = 1; ch <= s->fbw_channels; ch++) { 621 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) { 622 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) { 623 if (!s->bap[CPL_CH][i]) 624 s->fixed_coeffs[ch][i] = 0; 625 } 626 } 627 } 628} 629 630static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, 631 int ch, mant_groups *m) 632{ 633 if (!s->channel_uses_aht[ch]) { 634 ac3_decode_transform_coeffs_ch(s, ch, m); 635 } else { 636 /* if AHT is used, mantissas for all blocks are encoded in the first 637 block of the frame. */ 638 int bin; 639 if (CONFIG_EAC3_DECODER && !blk) 640 ff_eac3_decode_transform_coeffs_aht_ch(s, ch); 641 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { 642 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin]; 643 } 644 } 645} 646 647/** 648 * Decode the transform coefficients. 649 */ 650static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk) 651{ 652 int ch, end; 653 int got_cplchan = 0; 654 mant_groups m; 655 656 m.b1 = m.b2 = m.b4 = 0; 657 658 for (ch = 1; ch <= s->channels; ch++) { 659 /* transform coefficients for full-bandwidth channel */ 660 decode_transform_coeffs_ch(s, blk, ch, &m); 661 /* transform coefficients for coupling channel come right after the 662 coefficients for the first coupled channel*/ 663 if (s->channel_in_cpl[ch]) { 664 if (!got_cplchan) { 665 decode_transform_coeffs_ch(s, blk, CPL_CH, &m); 666 calc_transform_coeffs_cpl(s); 667 got_cplchan = 1; 668 } 669 end = s->end_freq[CPL_CH]; 670 } else { 671 end = s->end_freq[ch]; 672 } 673 do 674 s->fixed_coeffs[ch][end] = 0; 675 while (++end < 256); 676 } 677 678 /* zero the dithered coefficients for appropriate channels */ 679 remove_dithering(s); 680} 681 682/** 683 * Stereo rematrixing. 684 * reference: Section 7.5.4 Rematrixing : Decoding Technique 685 */ 686static void do_rematrixing(AC3DecodeContext *s) 687{ 688 int bnd, i; 689 int end, bndend; 690 691 end = FFMIN(s->end_freq[1], s->end_freq[2]); 692 693 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) { 694 if (s->rematrixing_flags[bnd]) { 695 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]); 696 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) { 697 int tmp0 = s->fixed_coeffs[1][i]; 698 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i]; 699 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i]; 700 } 701 } 702 } 703} 704 705/** 706 * Inverse MDCT Transform. 707 * Convert frequency domain coefficients to time-domain audio samples. 708 * reference: Section 7.9.4 Transformation Equations 709 */ 710static inline void do_imdct(AC3DecodeContext *s, int channels, int offset) 711{ 712 int ch; 713 714 for (ch = 1; ch <= channels; ch++) { 715 if (s->block_switch[ch]) { 716 int i; 717 FFTSample *x = s->tmp_output + 128; 718 for (i = 0; i < 128; i++) 719 x[i] = s->transform_coeffs[ch][2 * i]; 720 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x); 721#if USE_FIXED 722 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset], 723 s->tmp_output, s->window, 128, 8); 724#else 725 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset], 726 s->tmp_output, s->window, 128); 727#endif 728 for (i = 0; i < 128; i++) 729 x[i] = s->transform_coeffs[ch][2 * i + 1]; 730 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x); 731 } else { 732 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]); 733#if USE_FIXED 734 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset], 735 s->tmp_output, s->window, 128, 8); 736#else 737 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset], 738 s->tmp_output, s->window, 128); 739#endif 740 memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 * sizeof(FFTSample)); 741 } 742 } 743} 744 745/** 746 * Upmix delay samples from stereo to original channel layout. 747 */ 748static void ac3_upmix_delay(AC3DecodeContext *s) 749{ 750 int channel_data_size = sizeof(s->delay[0]); 751 switch (s->channel_mode) { 752 case AC3_CHMODE_DUALMONO: 753 case AC3_CHMODE_STEREO: 754 /* upmix mono to stereo */ 755 memcpy(s->delay[1], s->delay[0], channel_data_size); 756 break; 757 case AC3_CHMODE_2F2R: 758 memset(s->delay[3], 0, channel_data_size); 759 case AC3_CHMODE_2F1R: 760 memset(s->delay[2], 0, channel_data_size); 761 break; 762 case AC3_CHMODE_3F2R: 763 memset(s->delay[4], 0, channel_data_size); 764 case AC3_CHMODE_3F1R: 765 memset(s->delay[3], 0, channel_data_size); 766 case AC3_CHMODE_3F: 767 memcpy(s->delay[2], s->delay[1], channel_data_size); 768 memset(s->delay[1], 0, channel_data_size); 769 break; 770 } 771} 772 773/** 774 * Decode band structure for coupling, spectral extension, or enhanced coupling. 775 * The band structure defines how many subbands are in each band. For each 776 * subband in the range, 1 means it is combined with the previous band, and 0 777 * means that it starts a new band. 778 * 779 * @param[in] gbc bit reader context 780 * @param[in] blk block number 781 * @param[in] eac3 flag to indicate E-AC-3 782 * @param[in] ecpl flag to indicate enhanced coupling 783 * @param[in] start_subband subband number for start of range 784 * @param[in] end_subband subband number for end of range 785 * @param[in] default_band_struct default band structure table 786 * @param[out] num_bands number of bands (optionally NULL) 787 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL) 788 * @param[in,out] band_struct current band structure 789 */ 790static void decode_band_structure(GetBitContext *gbc, int blk, int eac3, 791 int ecpl, int start_subband, int end_subband, 792 const uint8_t *default_band_struct, 793 int *num_bands, uint8_t *band_sizes, 794 uint8_t *band_struct, int band_struct_size) 795{ 796 int subbnd, bnd, n_subbands, n_bands=0; 797 uint8_t bnd_sz[22]; 798 799 n_subbands = end_subband - start_subband; 800 801 if (!blk) 802 memcpy(band_struct, default_band_struct, band_struct_size); 803 804 av_assert0(band_struct_size >= start_subband + n_subbands); 805 806 band_struct += start_subband + 1; 807 808 /* decode band structure from bitstream or use default */ 809 if (!eac3 || get_bits1(gbc)) { 810 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) { 811 band_struct[subbnd] = get_bits1(gbc); 812 } 813 } 814 815 /* calculate number of bands and band sizes based on band structure. 816 note that the first 4 subbands in enhanced coupling span only 6 bins 817 instead of 12. */ 818 if (num_bands || band_sizes ) { 819 n_bands = n_subbands; 820 bnd_sz[0] = ecpl ? 6 : 12; 821 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) { 822 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12; 823 if (band_struct[subbnd - 1]) { 824 n_bands--; 825 bnd_sz[bnd] += subbnd_size; 826 } else { 827 bnd_sz[++bnd] = subbnd_size; 828 } 829 } 830 } 831 832 /* set optional output params */ 833 if (num_bands) 834 *num_bands = n_bands; 835 if (band_sizes) 836 memcpy(band_sizes, bnd_sz, n_bands); 837} 838 839static inline int spx_strategy(AC3DecodeContext *s, int blk) 840{ 841 GetBitContext *bc = &s->gbc; 842 int fbw_channels = s->fbw_channels; 843 int dst_start_freq, dst_end_freq, src_start_freq, 844 start_subband, end_subband, ch; 845 846 /* determine which channels use spx */ 847 if (s->channel_mode == AC3_CHMODE_MONO) { 848 s->channel_uses_spx[1] = 1; 849 } else { 850 for (ch = 1; ch <= fbw_channels; ch++) 851 s->channel_uses_spx[ch] = get_bits1(bc); 852 } 853 854 /* get the frequency bins of the spx copy region and the spx start 855 and end subbands */ 856 dst_start_freq = get_bits(bc, 2); 857 start_subband = get_bits(bc, 3) + 2; 858 if (start_subband > 7) 859 start_subband += start_subband - 7; 860 end_subband = get_bits(bc, 3) + 5; 861#if USE_FIXED 862 s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5]; 863#endif 864 if (end_subband > 7) 865 end_subband += end_subband - 7; 866 dst_start_freq = dst_start_freq * 12 + 25; 867 src_start_freq = start_subband * 12 + 25; 868 dst_end_freq = end_subband * 12 + 25; 869 870 /* check validity of spx ranges */ 871 if (start_subband >= end_subband) { 872 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension " 873 "range (%d >= %d)\n", start_subband, end_subband); 874 return AVERROR_INVALIDDATA; 875 } 876 if (dst_start_freq >= src_start_freq) { 877 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension " 878 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq); 879 return AVERROR_INVALIDDATA; 880 } 881 882 s->spx_dst_start_freq = dst_start_freq; 883 s->spx_src_start_freq = src_start_freq; 884 if (!USE_FIXED) 885 s->spx_dst_end_freq = dst_end_freq; 886 887 decode_band_structure(bc, blk, s->eac3, 0, 888 start_subband, end_subband, 889 ff_eac3_default_spx_band_struct, 890 &s->num_spx_bands, 891 s->spx_band_sizes, 892 s->spx_band_struct, sizeof(s->spx_band_struct)); 893 return 0; 894} 895 896static inline void spx_coordinates(AC3DecodeContext *s) 897{ 898 GetBitContext *bc = &s->gbc; 899 int fbw_channels = s->fbw_channels; 900 int ch, bnd; 901 902 for (ch = 1; ch <= fbw_channels; ch++) { 903 if (s->channel_uses_spx[ch]) { 904 if (s->first_spx_coords[ch] || get_bits1(bc)) { 905 INTFLOAT spx_blend; 906 int bin, master_spx_coord; 907 908 s->first_spx_coords[ch] = 0; 909 spx_blend = AC3_SPX_BLEND(get_bits(bc, 5)); 910 master_spx_coord = get_bits(bc, 2) * 3; 911 912 bin = s->spx_src_start_freq; 913 for (bnd = 0; bnd < s->num_spx_bands; bnd++) { 914 int bandsize = s->spx_band_sizes[bnd]; 915 int spx_coord_exp, spx_coord_mant; 916 INTFLOAT nratio, sblend, nblend; 917#if USE_FIXED 918 /* calculate blending factors */ 919 int64_t accu = ((bin << 23) + (bandsize << 22)) 920 * (int64_t)s->spx_dst_end_freq; 921 nratio = (int)(accu >> 32); 922 nratio -= spx_blend << 18; 923 924 if (nratio < 0) { 925 nblend = 0; 926 sblend = 0x800000; 927 } else if (nratio > 0x7fffff) { 928 nblend = 14529495; // sqrt(3) in FP.23 929 sblend = 0; 930 } else { 931 nblend = fixed_sqrt(nratio, 23); 932 accu = (int64_t)nblend * 1859775393; 933 nblend = (int)((accu + (1<<29)) >> 30); 934 sblend = fixed_sqrt(0x800000 - nratio, 23); 935 } 936#else 937 float spx_coord; 938 939 /* calculate blending factors */ 940 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend; 941 nratio = av_clipf(nratio, 0.0f, 1.0f); 942 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) 943 // to give unity variance 944 sblend = sqrtf(1.0f - nratio); 945#endif 946 bin += bandsize; 947 948 /* decode spx coordinates */ 949 spx_coord_exp = get_bits(bc, 4); 950 spx_coord_mant = get_bits(bc, 2); 951 if (spx_coord_exp == 15) spx_coord_mant <<= 1; 952 else spx_coord_mant += 4; 953 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord); 954 955 /* multiply noise and signal blending factors by spx coordinate */ 956#if USE_FIXED 957 accu = (int64_t)nblend * spx_coord_mant; 958 s->spx_noise_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23); 959 accu = (int64_t)sblend * spx_coord_mant; 960 s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23); 961#else 962 spx_coord = spx_coord_mant * (1.0f / (1 << 23)); 963 s->spx_noise_blend [ch][bnd] = nblend * spx_coord; 964 s->spx_signal_blend[ch][bnd] = sblend * spx_coord; 965#endif 966 } 967 } 968 } else { 969 s->first_spx_coords[ch] = 1; 970 } 971 } 972} 973 974static inline int coupling_strategy(AC3DecodeContext *s, int blk, 975 uint8_t *bit_alloc_stages) 976{ 977 GetBitContext *bc = &s->gbc; 978 int fbw_channels = s->fbw_channels; 979 int channel_mode = s->channel_mode; 980 int ch; 981 982 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); 983 if (!s->eac3) 984 s->cpl_in_use[blk] = get_bits1(bc); 985 if (s->cpl_in_use[blk]) { 986 /* coupling in use */ 987 int cpl_start_subband, cpl_end_subband; 988 989 if (channel_mode < AC3_CHMODE_STEREO) { 990 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n"); 991 return AVERROR_INVALIDDATA; 992 } 993 994 /* check for enhanced coupling */ 995 if (s->eac3 && get_bits1(bc)) { 996 /* TODO: parse enhanced coupling strategy info */ 997 avpriv_request_sample(s->avctx, "Enhanced coupling"); 998 return AVERROR_PATCHWELCOME; 999 } 1000 1001 /* determine which channels are coupled */ 1002 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) { 1003 s->channel_in_cpl[1] = 1; 1004 s->channel_in_cpl[2] = 1; 1005 } else { 1006 for (ch = 1; ch <= fbw_channels; ch++) 1007 s->channel_in_cpl[ch] = get_bits1(bc); 1008 } 1009 1010 /* phase flags in use */ 1011 if (channel_mode == AC3_CHMODE_STEREO) 1012 s->phase_flags_in_use = get_bits1(bc); 1013 1014 /* coupling frequency range */ 1015 cpl_start_subband = get_bits(bc, 4); 1016 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 : 1017 get_bits(bc, 4) + 3; 1018 if (cpl_start_subband >= cpl_end_subband) { 1019 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n", 1020 cpl_start_subband, cpl_end_subband); 1021 return AVERROR_INVALIDDATA; 1022 } 1023 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37; 1024 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37; 1025 1026 decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband, 1027 cpl_end_subband, 1028 ff_eac3_default_cpl_band_struct, 1029 &s->num_cpl_bands, s->cpl_band_sizes, 1030 s->cpl_band_struct, sizeof(s->cpl_band_struct)); 1031 } else { 1032 /* coupling not in use */ 1033 for (ch = 1; ch <= fbw_channels; ch++) { 1034 s->channel_in_cpl[ch] = 0; 1035 s->first_cpl_coords[ch] = 1; 1036 } 1037 s->first_cpl_leak = s->eac3; 1038 s->phase_flags_in_use = 0; 1039 } 1040 1041 return 0; 1042} 1043 1044static inline int coupling_coordinates(AC3DecodeContext *s, int blk) 1045{ 1046 GetBitContext *bc = &s->gbc; 1047 int fbw_channels = s->fbw_channels; 1048 int ch, bnd; 1049 int cpl_coords_exist = 0; 1050 1051 for (ch = 1; ch <= fbw_channels; ch++) { 1052 if (s->channel_in_cpl[ch]) { 1053 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) { 1054 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant; 1055 s->first_cpl_coords[ch] = 0; 1056 cpl_coords_exist = 1; 1057 master_cpl_coord = 3 * get_bits(bc, 2); 1058 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { 1059 cpl_coord_exp = get_bits(bc, 4); 1060 cpl_coord_mant = get_bits(bc, 4); 1061 if (cpl_coord_exp == 15) 1062 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22; 1063 else 1064 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21; 1065 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord); 1066 } 1067 } else if (!blk) { 1068 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must " 1069 "be present in block 0\n"); 1070 return AVERROR_INVALIDDATA; 1071 } 1072 } else { 1073 /* channel not in coupling */ 1074 s->first_cpl_coords[ch] = 1; 1075 } 1076 } 1077 /* phase flags */ 1078 if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) { 1079 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { 1080 s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0; 1081 } 1082 } 1083 1084 return 0; 1085} 1086 1087/** 1088 * Decode a single audio block from the AC-3 bitstream. 1089 */ 1090static int decode_audio_block(AC3DecodeContext *s, int blk, int offset) 1091{ 1092 int fbw_channels = s->fbw_channels; 1093 int channel_mode = s->channel_mode; 1094 int i, bnd, seg, ch, ret; 1095 int different_transforms; 1096 int downmix_output; 1097 int cpl_in_use; 1098 GetBitContext *gbc = &s->gbc; 1099 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 }; 1100 1101 /* block switch flags */ 1102 different_transforms = 0; 1103 if (s->block_switch_syntax) { 1104 for (ch = 1; ch <= fbw_channels; ch++) { 1105 s->block_switch[ch] = get_bits1(gbc); 1106 if (ch > 1 && s->block_switch[ch] != s->block_switch[1]) 1107 different_transforms = 1; 1108 } 1109 } 1110 1111 /* dithering flags */ 1112 if (s->dither_flag_syntax) { 1113 for (ch = 1; ch <= fbw_channels; ch++) { 1114 s->dither_flag[ch] = get_bits1(gbc); 1115 } 1116 } 1117 1118 /* dynamic range */ 1119 i = !s->channel_mode; 1120 do { 1121 if (get_bits1(gbc)) { 1122 /* Allow asymmetric application of DRC when drc_scale > 1. 1123 Amplification of quiet sounds is enhanced */ 1124 int range_bits = get_bits(gbc, 8); 1125 INTFLOAT range = AC3_RANGE(range_bits); 1126 if (range_bits <= 127 || s->drc_scale <= 1.0) 1127 s->dynamic_range[i] = AC3_DYNAMIC_RANGE(range); 1128 else 1129 s->dynamic_range[i] = range; 1130 } else if (blk == 0) { 1131 s->dynamic_range[i] = AC3_DYNAMIC_RANGE1; 1132 } 1133 } while (i--); 1134 1135 /* spectral extension strategy */ 1136 if (s->eac3 && (!blk || get_bits1(gbc))) { 1137 s->spx_in_use = get_bits1(gbc); 1138 if (s->spx_in_use) { 1139 if ((ret = spx_strategy(s, blk)) < 0) 1140 return ret; 1141 } 1142 } 1143 if (!s->eac3 || !s->spx_in_use) { 1144 s->spx_in_use = 0; 1145 for (ch = 1; ch <= fbw_channels; ch++) { 1146 s->channel_uses_spx[ch] = 0; 1147 s->first_spx_coords[ch] = 1; 1148 } 1149 } 1150 1151 /* spectral extension coordinates */ 1152 if (s->spx_in_use) 1153 spx_coordinates(s); 1154 1155 /* coupling strategy */ 1156 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) { 1157 if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0) 1158 return ret; 1159 } else if (!s->eac3) { 1160 if (!blk) { 1161 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must " 1162 "be present in block 0\n"); 1163 return AVERROR_INVALIDDATA; 1164 } else { 1165 s->cpl_in_use[blk] = s->cpl_in_use[blk-1]; 1166 } 1167 } 1168 cpl_in_use = s->cpl_in_use[blk]; 1169 1170 /* coupling coordinates */ 1171 if (cpl_in_use) { 1172 if ((ret = coupling_coordinates(s, blk)) < 0) 1173 return ret; 1174 } 1175 1176 /* stereo rematrixing strategy and band structure */ 1177 if (channel_mode == AC3_CHMODE_STEREO) { 1178 if ((s->eac3 && !blk) || get_bits1(gbc)) { 1179 s->num_rematrixing_bands = 4; 1180 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) { 1181 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37); 1182 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) { 1183 s->num_rematrixing_bands--; 1184 } 1185 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) 1186 s->rematrixing_flags[bnd] = get_bits1(gbc); 1187 } else if (!blk) { 1188 av_log(s->avctx, AV_LOG_WARNING, "Warning: " 1189 "new rematrixing strategy not present in block 0\n"); 1190 s->num_rematrixing_bands = 0; 1191 } 1192 } 1193 1194 /* exponent strategies for each channel */ 1195 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 1196 if (!s->eac3) 1197 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch)); 1198 if (s->exp_strategy[blk][ch] != EXP_REUSE) 1199 bit_alloc_stages[ch] = 3; 1200 } 1201 1202 /* channel bandwidth */ 1203 for (ch = 1; ch <= fbw_channels; ch++) { 1204 s->start_freq[ch] = 0; 1205 if (s->exp_strategy[blk][ch] != EXP_REUSE) { 1206 int group_size; 1207 int prev = s->end_freq[ch]; 1208 if (s->channel_in_cpl[ch]) 1209 s->end_freq[ch] = s->start_freq[CPL_CH]; 1210 else if (s->channel_uses_spx[ch]) 1211 s->end_freq[ch] = s->spx_src_start_freq; 1212 else { 1213 int bandwidth_code = get_bits(gbc, 6); 1214 if (bandwidth_code > 60) { 1215 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code); 1216 return AVERROR_INVALIDDATA; 1217 } 1218 s->end_freq[ch] = bandwidth_code * 3 + 73; 1219 } 1220 group_size = 3 << (s->exp_strategy[blk][ch] - 1); 1221 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size; 1222 if (blk > 0 && s->end_freq[ch] != prev) 1223 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); 1224 } 1225 } 1226 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) { 1227 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) / 1228 (3 << (s->exp_strategy[blk][CPL_CH] - 1)); 1229 } 1230 1231 /* decode exponents for each channel */ 1232 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 1233 if (s->exp_strategy[blk][ch] != EXP_REUSE) { 1234 s->dexps[ch][0] = get_bits(gbc, 4) << !ch; 1235 if (decode_exponents(s, gbc, s->exp_strategy[blk][ch], 1236 s->num_exp_groups[ch], s->dexps[ch][0], 1237 &s->dexps[ch][s->start_freq[ch]+!!ch])) { 1238 return AVERROR_INVALIDDATA; 1239 } 1240 if (ch != CPL_CH && ch != s->lfe_ch) 1241 skip_bits(gbc, 2); /* skip gainrng */ 1242 } 1243 } 1244 1245 /* bit allocation information */ 1246 if (s->bit_allocation_syntax) { 1247 if (get_bits1(gbc)) { 1248 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; 1249 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; 1250 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)]; 1251 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)]; 1252 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)]; 1253 for (ch = !cpl_in_use; ch <= s->channels; ch++) 1254 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 1255 } else if (!blk) { 1256 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must " 1257 "be present in block 0\n"); 1258 return AVERROR_INVALIDDATA; 1259 } 1260 } 1261 1262 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */ 1263 if (!s->eac3 || !blk) { 1264 if (s->snr_offset_strategy && get_bits1(gbc)) { 1265 int snr = 0; 1266 int csnr; 1267 csnr = (get_bits(gbc, 6) - 15) << 4; 1268 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) { 1269 /* snr offset */ 1270 if (ch == i || s->snr_offset_strategy == 2) 1271 snr = (csnr + get_bits(gbc, 4)) << 2; 1272 /* run at least last bit allocation stage if snr offset changes */ 1273 if (blk && s->snr_offset[ch] != snr) { 1274 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1); 1275 } 1276 s->snr_offset[ch] = snr; 1277 1278 /* fast gain (normal AC-3 only) */ 1279 if (!s->eac3) { 1280 int prev = s->fast_gain[ch]; 1281 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; 1282 /* run last 2 bit allocation stages if fast gain changes */ 1283 if (blk && prev != s->fast_gain[ch]) 1284 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 1285 } 1286 } 1287 } else if (!s->eac3 && !blk) { 1288 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n"); 1289 return AVERROR_INVALIDDATA; 1290 } 1291 } 1292 1293 /* fast gain (E-AC-3 only) */ 1294 if (s->fast_gain_syntax && get_bits1(gbc)) { 1295 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 1296 int prev = s->fast_gain[ch]; 1297 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; 1298 /* run last 2 bit allocation stages if fast gain changes */ 1299 if (blk && prev != s->fast_gain[ch]) 1300 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 1301 } 1302 } else if (s->eac3 && !blk) { 1303 for (ch = !cpl_in_use; ch <= s->channels; ch++) 1304 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4]; 1305 } 1306 1307 /* E-AC-3 to AC-3 converter SNR offset */ 1308 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) { 1309 skip_bits(gbc, 10); // skip converter snr offset 1310 } 1311 1312 /* coupling leak information */ 1313 if (cpl_in_use) { 1314 if (s->first_cpl_leak || get_bits1(gbc)) { 1315 int fl = get_bits(gbc, 3); 1316 int sl = get_bits(gbc, 3); 1317 /* run last 2 bit allocation stages for coupling channel if 1318 coupling leak changes */ 1319 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak || 1320 sl != s->bit_alloc_params.cpl_slow_leak)) { 1321 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2); 1322 } 1323 s->bit_alloc_params.cpl_fast_leak = fl; 1324 s->bit_alloc_params.cpl_slow_leak = sl; 1325 } else if (!s->eac3 && !blk) { 1326 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must " 1327 "be present in block 0\n"); 1328 return AVERROR_INVALIDDATA; 1329 } 1330 s->first_cpl_leak = 0; 1331 } 1332 1333 /* delta bit allocation information */ 1334 if (s->dba_syntax && get_bits1(gbc)) { 1335 /* delta bit allocation exists (strategy) */ 1336 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) { 1337 s->dba_mode[ch] = get_bits(gbc, 2); 1338 if (s->dba_mode[ch] == DBA_RESERVED) { 1339 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); 1340 return AVERROR_INVALIDDATA; 1341 } 1342 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 1343 } 1344 /* channel delta offset, len and bit allocation */ 1345 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) { 1346 if (s->dba_mode[ch] == DBA_NEW) { 1347 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1; 1348 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) { 1349 s->dba_offsets[ch][seg] = get_bits(gbc, 5); 1350 s->dba_lengths[ch][seg] = get_bits(gbc, 4); 1351 s->dba_values[ch][seg] = get_bits(gbc, 3); 1352 } 1353 /* run last 2 bit allocation stages if new dba values */ 1354 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); 1355 } 1356 } 1357 } else if (blk == 0) { 1358 for (ch = 0; ch <= s->channels; ch++) { 1359 s->dba_mode[ch] = DBA_NONE; 1360 } 1361 } 1362 1363 /* Bit allocation */ 1364 for (ch = !cpl_in_use; ch <= s->channels; ch++) { 1365 if (bit_alloc_stages[ch] > 2) { 1366 /* Exponent mapping into PSD and PSD integration */ 1367 ff_ac3_bit_alloc_calc_psd(s->dexps[ch], 1368 s->start_freq[ch], s->end_freq[ch], 1369 s->psd[ch], s->band_psd[ch]); 1370 } 1371 if (bit_alloc_stages[ch] > 1) { 1372 /* Compute excitation function, Compute masking curve, and 1373 Apply delta bit allocation */ 1374 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch], 1375 s->start_freq[ch], s->end_freq[ch], 1376 s->fast_gain[ch], (ch == s->lfe_ch), 1377 s->dba_mode[ch], s->dba_nsegs[ch], 1378 s->dba_offsets[ch], s->dba_lengths[ch], 1379 s->dba_values[ch], s->mask[ch])) { 1380 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n"); 1381 return AVERROR_INVALIDDATA; 1382 } 1383 } 1384 if (bit_alloc_stages[ch] > 0) { 1385 /* Compute bit allocation */ 1386 const uint8_t *bap_tab = s->channel_uses_aht[ch] ? 1387 ff_eac3_hebap_tab : ff_ac3_bap_tab; 1388 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch], 1389 s->start_freq[ch], s->end_freq[ch], 1390 s->snr_offset[ch], 1391 s->bit_alloc_params.floor, 1392 bap_tab, s->bap[ch]); 1393 } 1394 } 1395 1396 /* unused dummy data */ 1397 if (s->skip_syntax && get_bits1(gbc)) { 1398 int skipl = get_bits(gbc, 9); 1399 skip_bits_long(gbc, 8 * skipl); 1400 } 1401 1402 /* unpack the transform coefficients 1403 this also uncouples channels if coupling is in use. */ 1404 decode_transform_coeffs(s, blk); 1405 1406 /* TODO: generate enhanced coupling coordinates and uncouple */ 1407 1408 /* recover coefficients if rematrixing is in use */ 1409 if (s->channel_mode == AC3_CHMODE_STEREO) 1410 do_rematrixing(s); 1411 1412 /* apply scaling to coefficients (headroom, dynrng) */ 1413 for (ch = 1; ch <= s->channels; ch++) { 1414 int audio_channel = 0; 1415 INTFLOAT gain; 1416 if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2) 1417 audio_channel = 2-ch; 1418 if (s->heavy_compression && s->compression_exists[audio_channel]) 1419 gain = s->heavy_dynamic_range[audio_channel]; 1420 else 1421 gain = s->dynamic_range[audio_channel]; 1422 1423#if USE_FIXED 1424 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256); 1425#else 1426 if (s->target_level != 0) 1427 gain = gain * s->level_gain[audio_channel]; 1428 gain *= 1.0 / 4194304.0f; 1429 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch], 1430 s->fixed_coeffs[ch], gain, 256); 1431#endif 1432 } 1433 1434 /* apply spectral extension to high frequency bins */ 1435 if (CONFIG_EAC3_DECODER && s->spx_in_use) { 1436 ff_eac3_apply_spectral_extension(s); 1437 } 1438 1439 /* downmix and MDCT. order depends on whether block switching is used for 1440 any channel in this block. this is because coefficients for the long 1441 and short transforms cannot be mixed. */ 1442 downmix_output = s->channels != s->out_channels && 1443 !((s->output_mode & AC3_OUTPUT_LFEON) && 1444 s->fbw_channels == s->out_channels); 1445 if (different_transforms) { 1446 /* the delay samples have already been downmixed, so we upmix the delay 1447 samples in order to reconstruct all channels before downmixing. */ 1448 if (s->downmixed) { 1449 s->downmixed = 0; 1450 ac3_upmix_delay(s); 1451 } 1452 1453 do_imdct(s, s->channels, offset); 1454 1455 if (downmix_output) { 1456#if USE_FIXED 1457 ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs, 1458 s->out_channels, s->fbw_channels, 256); 1459#else 1460 ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs, 1461 s->out_channels, s->fbw_channels, 256); 1462#endif 1463 } 1464 } else { 1465 if (downmix_output) { 1466 AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs, 1467 s->out_channels, s->fbw_channels, 256); 1468 } 1469 1470 if (downmix_output && !s->downmixed) { 1471 s->downmixed = 1; 1472 AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs, 1473 s->out_channels, s->fbw_channels, 128); 1474 } 1475 1476 do_imdct(s, s->out_channels, offset); 1477 } 1478 1479 return 0; 1480} 1481 1482/** 1483 * Decode a single AC-3 frame. 1484 */ 1485static int ac3_decode_frame(AVCodecContext *avctx, AVFrame *frame, 1486 int *got_frame_ptr, AVPacket *avpkt) 1487{ 1488 const uint8_t *buf = avpkt->data; 1489 int buf_size, full_buf_size = avpkt->size; 1490 AC3DecodeContext *s = avctx->priv_data; 1491 int blk, ch, err, offset, ret; 1492 int i; 1493 int skip = 0, got_independent_frame = 0; 1494 const uint8_t *channel_map; 1495 uint8_t extended_channel_map[EAC3_MAX_CHANNELS]; 1496 const SHORTFLOAT *output[AC3_MAX_CHANNELS]; 1497 enum AVMatrixEncoding matrix_encoding; 1498 AVDownmixInfo *downmix_info; 1499 uint64_t mask; 1500 1501 s->superframe_size = 0; 1502 1503 buf_size = full_buf_size; 1504 for (i = 1; i < buf_size; i += 2) { 1505 if (buf[i] == 0x77 || buf[i] == 0x0B) { 1506 if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) { 1507 i--; 1508 break; 1509 } else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) { 1510 break; 1511 } 1512 } 1513 } 1514 if (i >= buf_size) 1515 return AVERROR_INVALIDDATA; 1516 if (i > 10) 1517 return i; 1518 buf += i; 1519 buf_size -= i; 1520 1521 /* copy input buffer to decoder context to avoid reading past the end 1522 of the buffer, which can be caused by a damaged input stream. */ 1523 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) { 1524 // seems to be byte-swapped AC-3 1525 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1; 1526 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer, 1527 (const uint16_t *) buf, cnt); 1528 } else 1529 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE)); 1530 1531 /* if consistent noise generation is enabled, seed the linear feedback generator 1532 * with the contents of the AC-3 frame so that the noise is identical across 1533 * decodes given the same AC-3 frame data, for use with non-linear edititing software. */ 1534 if (s->consistent_noise_generation) 1535 av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE)); 1536 1537 buf = s->input_buffer; 1538dependent_frame: 1539 /* initialize the GetBitContext with the start of valid AC-3 Frame */ 1540 if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0) 1541 return ret; 1542 1543 /* parse the syncinfo */ 1544 err = parse_frame_header(s); 1545 1546 if (err) { 1547 switch (err) { 1548 case AAC_AC3_PARSE_ERROR_SYNC: 1549 av_log(avctx, AV_LOG_ERROR, "frame sync error\n"); 1550 return AVERROR_INVALIDDATA; 1551 case AAC_AC3_PARSE_ERROR_BSID: 1552 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n"); 1553 break; 1554 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE: 1555 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n"); 1556 break; 1557 case AAC_AC3_PARSE_ERROR_FRAME_SIZE: 1558 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n"); 1559 break; 1560 case AAC_AC3_PARSE_ERROR_FRAME_TYPE: 1561 /* skip frame if CRC is ok. otherwise use error concealment. */ 1562 /* TODO: add support for substreams */ 1563 if (s->substreamid) { 1564 av_log(avctx, AV_LOG_DEBUG, 1565 "unsupported substream %d: skipping frame\n", 1566 s->substreamid); 1567 *got_frame_ptr = 0; 1568 return buf_size; 1569 } else { 1570 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n"); 1571 } 1572 break; 1573 case AAC_AC3_PARSE_ERROR_CRC: 1574 case AAC_AC3_PARSE_ERROR_CHANNEL_CFG: 1575 break; 1576 default: // Normal AVERROR do not try to recover. 1577 *got_frame_ptr = 0; 1578 return err; 1579 } 1580 } else { 1581 /* check that reported frame size fits in input buffer */ 1582 if (s->frame_size > buf_size) { 1583 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); 1584 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE; 1585 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) { 1586 /* check for crc mismatch */ 1587 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], 1588 s->frame_size - 2)) { 1589 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n"); 1590 if (avctx->err_recognition & AV_EF_EXPLODE) 1591 return AVERROR_INVALIDDATA; 1592 err = AAC_AC3_PARSE_ERROR_CRC; 1593 } 1594 } 1595 } 1596 1597 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT && !got_independent_frame) { 1598 av_log(avctx, AV_LOG_WARNING, "Ignoring dependent frame without independent frame.\n"); 1599 *got_frame_ptr = 0; 1600 return FFMIN(full_buf_size, s->frame_size); 1601 } 1602 1603 /* channel config */ 1604 if (!err || (s->channels && s->out_channels != s->channels)) { 1605 s->out_channels = s->channels; 1606 s->output_mode = s->channel_mode; 1607 if (s->lfe_on) 1608 s->output_mode |= AC3_OUTPUT_LFEON; 1609 if (s->channels > 1 && 1610 !av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_MONO)) { 1611 s->out_channels = 1; 1612 s->output_mode = AC3_CHMODE_MONO; 1613 } else if (s->channels > 2 && 1614 !av_channel_layout_compare(&s->downmix_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO)) { 1615 s->out_channels = 2; 1616 s->output_mode = AC3_CHMODE_STEREO; 1617 } 1618 1619 s->loro_center_mix_level = gain_levels[s-> center_mix_level]; 1620 s->loro_surround_mix_level = gain_levels[s->surround_mix_level]; 1621 s->ltrt_center_mix_level = LEVEL_MINUS_3DB; 1622 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB; 1623 /* set downmixing coefficients if needed */ 1624 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) && 1625 s->fbw_channels == s->out_channels)) { 1626 if ((ret = set_downmix_coeffs(s)) < 0) { 1627 av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n"); 1628 return ret; 1629 } 1630 } 1631 } else if (!s->channels) { 1632 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n"); 1633 return AVERROR_INVALIDDATA; 1634 } 1635 1636 mask = ff_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON]; 1637 if (s->output_mode & AC3_OUTPUT_LFEON) 1638 mask |= AV_CH_LOW_FREQUENCY; 1639 1640 av_channel_layout_uninit(&avctx->ch_layout); 1641 av_channel_layout_from_mask(&avctx->ch_layout, mask); 1642 1643 /* set audio service type based on bitstream mode for AC-3 */ 1644 avctx->audio_service_type = s->bitstream_mode; 1645 if (s->bitstream_mode == 0x7 && s->channels > 1) 1646 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE; 1647 1648 /* decode the audio blocks */ 1649 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on]; 1650 offset = s->frame_type == EAC3_FRAME_TYPE_DEPENDENT ? AC3_MAX_CHANNELS : 0; 1651 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) { 1652 output[ch] = s->output[ch + offset]; 1653 s->outptr[ch] = s->output[ch + offset]; 1654 } 1655 for (ch = 0; ch < s->channels; ch++) { 1656 if (ch < s->out_channels) 1657 s->outptr[channel_map[ch]] = s->output_buffer[ch + offset]; 1658 } 1659 for (blk = 0; blk < s->num_blocks; blk++) { 1660 if (!err && decode_audio_block(s, blk, offset)) { 1661 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n"); 1662 err = 1; 1663 } 1664 if (err) 1665 for (ch = 0; ch < s->out_channels; ch++) 1666 memcpy(s->output_buffer[ch + offset] + AC3_BLOCK_SIZE*blk, output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT)); 1667 for (ch = 0; ch < s->out_channels; ch++) 1668 output[ch] = s->outptr[channel_map[ch]]; 1669 for (ch = 0; ch < s->out_channels; ch++) { 1670 if (!ch || channel_map[ch]) 1671 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE; 1672 } 1673 } 1674 1675 /* keep last block for error concealment in next frame */ 1676 for (ch = 0; ch < s->out_channels; ch++) 1677 memcpy(s->output[ch + offset], output[ch], AC3_BLOCK_SIZE*sizeof(SHORTFLOAT)); 1678 1679 /* check if there is dependent frame */ 1680 if (buf_size > s->frame_size) { 1681 AC3HeaderInfo hdr; 1682 int err; 1683 1684 if (buf_size - s->frame_size <= 16) { 1685 skip = buf_size - s->frame_size; 1686 goto skip; 1687 } 1688 1689 if ((ret = init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0) 1690 return ret; 1691 1692 err = ff_ac3_parse_header(&s->gbc, &hdr); 1693 if (err) 1694 return err; 1695 1696 if (hdr.frame_type == EAC3_FRAME_TYPE_DEPENDENT) { 1697 if (hdr.num_blocks != s->num_blocks || s->sample_rate != hdr.sample_rate) { 1698 av_log(avctx, AV_LOG_WARNING, "Ignoring non-compatible dependent frame.\n"); 1699 } else { 1700 buf += s->frame_size; 1701 buf_size -= s->frame_size; 1702 s->prev_output_mode = s->output_mode; 1703 s->prev_bit_rate = s->bit_rate; 1704 got_independent_frame = 1; 1705 goto dependent_frame; 1706 } 1707 } 1708 } 1709skip: 1710 1711 frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0; 1712 1713 /* if frame is ok, set audio parameters */ 1714 if (!err) { 1715 avctx->sample_rate = s->sample_rate; 1716 avctx->bit_rate = s->bit_rate + s->prev_bit_rate; 1717 } 1718 1719 for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) 1720 extended_channel_map[ch] = ch; 1721 1722 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) { 1723 uint64_t ich_layout = ff_ac3_channel_layout_tab[s->prev_output_mode & ~AC3_OUTPUT_LFEON]; 1724 int channel_map_size = ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on; 1725 uint64_t channel_layout; 1726 int extend = 0; 1727 1728 if (s->prev_output_mode & AC3_OUTPUT_LFEON) 1729 ich_layout |= AV_CH_LOW_FREQUENCY; 1730 1731 channel_layout = ich_layout; 1732 for (ch = 0; ch < 16; ch++) { 1733 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) { 1734 channel_layout |= ff_eac3_custom_channel_map_locations[ch][1]; 1735 } 1736 } 1737 if (av_popcount64(channel_layout) > EAC3_MAX_CHANNELS) { 1738 av_log(avctx, AV_LOG_ERROR, "Too many channels (%d) coded\n", 1739 av_popcount64(channel_layout)); 1740 return AVERROR_INVALIDDATA; 1741 } 1742 1743 av_channel_layout_uninit(&avctx->ch_layout); 1744 av_channel_layout_from_mask(&avctx->ch_layout, channel_layout); 1745 1746 for (ch = 0; ch < EAC3_MAX_CHANNELS; ch++) { 1747 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) { 1748 if (ff_eac3_custom_channel_map_locations[ch][0]) { 1749 int index = av_channel_layout_index_from_channel(&avctx->ch_layout, 1750 ff_ctzll(ff_eac3_custom_channel_map_locations[ch][1])); 1751 if (index < 0) 1752 return AVERROR_INVALIDDATA; 1753 if (extend >= channel_map_size) 1754 return AVERROR_INVALIDDATA; 1755 1756 extended_channel_map[index] = offset + channel_map[extend++]; 1757 } else { 1758 int i; 1759 1760 for (i = 0; i < 64; i++) { 1761 if ((1ULL << i) & ff_eac3_custom_channel_map_locations[ch][1]) { 1762 int index = av_channel_layout_index_from_channel(&avctx->ch_layout, i); 1763 if (index < 0) 1764 return AVERROR_INVALIDDATA; 1765 if (extend >= channel_map_size) 1766 return AVERROR_INVALIDDATA; 1767 1768 extended_channel_map[index] = offset + channel_map[extend++]; 1769 } 1770 } 1771 } 1772 } 1773 } 1774 } 1775 1776 /* get output buffer */ 1777 frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE; 1778 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 1779 return ret; 1780 1781 for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) { 1782 int map = extended_channel_map[ch]; 1783 av_assert0(ch>=AV_NUM_DATA_POINTERS || frame->extended_data[ch] == frame->data[ch]); 1784 memcpy((SHORTFLOAT *)frame->extended_data[ch], 1785 s->output_buffer[map], 1786 s->num_blocks * AC3_BLOCK_SIZE * sizeof(SHORTFLOAT)); 1787 } 1788 1789 /* 1790 * AVMatrixEncoding 1791 * 1792 * Check whether the input layout is compatible, and make sure we're not 1793 * downmixing (else the matrix encoding is no longer applicable). 1794 */ 1795 matrix_encoding = AV_MATRIX_ENCODING_NONE; 1796 if (s->channel_mode == AC3_CHMODE_STEREO && 1797 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) { 1798 if (s->dolby_surround_mode == AC3_DSURMOD_ON) 1799 matrix_encoding = AV_MATRIX_ENCODING_DOLBY; 1800 else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON) 1801 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE; 1802 } else if (s->channel_mode >= AC3_CHMODE_2F2R && 1803 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) { 1804 switch (s->dolby_surround_ex_mode) { 1805 case AC3_DSUREXMOD_ON: // EX or PLIIx 1806 matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX; 1807 break; 1808 case AC3_DSUREXMOD_PLIIZ: 1809 matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ; 1810 break; 1811 default: // not indicated or off 1812 break; 1813 } 1814 } 1815 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0) 1816 return ret; 1817 1818 /* AVDownmixInfo */ 1819 if ((downmix_info = av_downmix_info_update_side_data(frame))) { 1820 switch (s->preferred_downmix) { 1821 case AC3_DMIXMOD_LTRT: 1822 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LTRT; 1823 break; 1824 case AC3_DMIXMOD_LORO: 1825 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_LORO; 1826 break; 1827 case AC3_DMIXMOD_DPLII: 1828 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_DPLII; 1829 break; 1830 default: 1831 downmix_info->preferred_downmix_type = AV_DOWNMIX_TYPE_UNKNOWN; 1832 break; 1833 } 1834 downmix_info->center_mix_level = gain_levels[s-> center_mix_level]; 1835 downmix_info->center_mix_level_ltrt = gain_levels[s-> center_mix_level_ltrt]; 1836 downmix_info->surround_mix_level = gain_levels[s-> surround_mix_level]; 1837 downmix_info->surround_mix_level_ltrt = gain_levels[s->surround_mix_level_ltrt]; 1838 if (s->lfe_mix_level_exists) 1839 downmix_info->lfe_mix_level = gain_levels_lfe[s->lfe_mix_level]; 1840 else 1841 downmix_info->lfe_mix_level = 0.0; // -inf dB 1842 } else 1843 return AVERROR(ENOMEM); 1844 1845 *got_frame_ptr = 1; 1846 1847 if (!s->superframe_size) 1848 return FFMIN(full_buf_size, s->frame_size + skip); 1849 1850 return FFMIN(full_buf_size, s->superframe_size + skip); 1851} 1852 1853/** 1854 * Uninitialize the AC-3 decoder. 1855 */ 1856static av_cold int ac3_decode_end(AVCodecContext *avctx) 1857{ 1858 AC3DecodeContext *s = avctx->priv_data; 1859 ff_mdct_end(&s->imdct_512); 1860 ff_mdct_end(&s->imdct_256); 1861 av_freep(&s->fdsp); 1862 av_freep(&s->downmix_coeffs[0]); 1863 1864 return 0; 1865} 1866 1867#define OFFSET(x) offsetof(AC3DecodeContext, x) 1868#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM) 1869