64 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
88 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
89 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
90 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
91 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
92 0.125892, 0.112201, 0.100000, 0.089125
100 { { 2, 7 }, { 7, 2 }, },
102 { { 2, 7 }, { 7, 2 }, },
103 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
104 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
105 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
106 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
107 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
118 return ((code - (levels >> 1)) * (1 << 24)) / levels;
130 for (i = 0; i < 128; i++) {
138 for (i = 0; i < 32; i++) {
144 for (i = 0; i < 128; i++) {
156 for (i = 0; i < 7; i++) {
160 for (i = 0; i < 15; i++) {
168 for (i = 0; i < 256; i++) {
169 int v = (i >> 5) - ((i >> 7) << 3) - 5;
175 for (i = 0; i < 256; i++) {
176 int v = (i >> 4) - ((i >> 7) << 4) - 4;
193 if ((ret =
ff_mdct_init(&s->imdct_256, 8, 1, 1.0)) < 0 ||
226 s->xcfptr[
i] = s->transform_coeffs[
i];
227 s->dlyptr[
i] = s->delay[
i];
246 i = !s->channel_mode;
248 s->dialog_normalization[(!s->channel_mode)-i] = -
get_bits(gbc, 5);
249 if (s->dialog_normalization[(!s->channel_mode)-
i] == 0) {
250 s->dialog_normalization[(!s->channel_mode)-i] = -31;
252 if (s->target_level != 0) {
253 s->level_gain[(!s->channel_mode)-i] =
powf(2.0
f,
254 (
float)(s->target_level -
255 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
257 if (s->compression_exists[(!s->channel_mode)-
i] =
get_bits1(gbc)) {
258 s->heavy_dynamic_range[(!s->channel_mode)-i] =
270 if (s->bitstream_id != 6) {
277 s->preferred_downmix =
get_bits(gbc, 2);
278 s->center_mix_level_ltrt =
get_bits(gbc, 3);
279 s->surround_mix_level_ltrt = av_clip(
get_bits(gbc, 3), 3, 7);
280 s->center_mix_level =
get_bits(gbc, 3);
281 s->surround_mix_level = av_clip(
get_bits(gbc, 3), 3, 7);
284 s->dolby_surround_ex_mode =
get_bits(gbc, 2);
285 s->dolby_headphone_mode =
get_bits(gbc, 2);
314 s->bit_alloc_params.sr_code = hdr.
sr_code;
319 s->bit_alloc_params.sr_shift = hdr.
sr_shift;
323 s->fbw_channels = s->channels - s->lfe_on;
324 s->lfe_ch = s->fbw_channels + 1;
329 s->center_mix_level_ltrt = 4;
331 s->surround_mix_level_ltrt = 4;
332 s->lfe_mix_level_exists = 0;
341 s->start_freq[s->lfe_ch] = 0;
342 s->end_freq[s->lfe_ch] = 7;
343 s->num_exp_groups[s->lfe_ch] = 2;
344 s->channel_in_cpl[s->lfe_ch] = 0;
347 if (s->bitstream_id <= 10) {
349 s->snr_offset_strategy = 2;
350 s->block_switch_syntax = 1;
351 s->dither_flag_syntax = 1;
352 s->bit_allocation_syntax = 1;
353 s->fast_gain_syntax = 0;
354 s->first_cpl_leak = 0;
357 memset(s->channel_uses_aht, 0,
sizeof(s->channel_uses_aht));
359 }
else if (CONFIG_EAC3_DECODER) {
380 if (!s->downmix_coeffs[0]) {
382 sizeof(**s->downmix_coeffs));
383 if (!s->downmix_coeffs[0])
388 for (i = 0; i < s->fbw_channels; i++) {
390 downmix_coeffs[1][
i] =
gain_levels[ac3_default_coeffs[s->channel_mode][
i][1]];
392 if (s->channel_mode > 1 && s->channel_mode & 1) {
393 downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
396 int nf = s->channel_mode - 2;
397 downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix *
LEVEL_MINUS_3DB;
400 int nf = s->channel_mode - 4;
401 downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
406 for (i = 0; i < s->fbw_channels; i++) {
407 norm0 += downmix_coeffs[0][
i];
408 norm1 += downmix_coeffs[1][
i];
410 norm0 = 1.0f / norm0;
411 norm1 = 1.0f / norm1;
412 for (i = 0; i < s->fbw_channels; i++) {
413 downmix_coeffs[0][
i] *= norm0;
414 downmix_coeffs[1][
i] *= norm1;
418 for (i = 0; i < s->fbw_channels; i++)
419 downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
422 for (i = 0; i < s->fbw_channels; i++) {
423 s->downmix_coeffs[0][
i] =
FIXR12(downmix_coeffs[0][i]);
424 s->downmix_coeffs[1][
i] =
FIXR12(downmix_coeffs[1][i]);
438 int i, j, grp, group_size;
443 group_size = exp_strategy + (exp_strategy ==
EXP_D45);
444 for (grp = 0, i = 0; grp < ngrps; grp++) {
457 for (i = 0, j = 0; i < ngrps * 3; i++) {
458 prevexp += dexp[
i] - 2;
463 switch (group_size) {
464 case 4: dexps[j++] = prevexp;
465 dexps[j++] = prevexp;
466 case 2: dexps[j++] = prevexp;
467 case 1: dexps[j++] = prevexp;
482 bin = s->start_freq[
CPL_CH];
483 for (band = 0; band < s->num_cpl_bands; band++) {
484 int band_start = bin;
485 int band_end = bin + s->cpl_band_sizes[band];
486 for (ch = 1; ch <= s->fbw_channels; ch++) {
487 if (s->channel_in_cpl[ch]) {
488 int cpl_coord = s->cpl_coords[ch][band] << 5;
489 for (bin = band_start; bin < band_end; bin++) {
490 s->fixed_coeffs[ch][bin] =
491 MULH(s->fixed_coeffs[
CPL_CH][bin] * (1 << 4), cpl_coord);
493 if (ch == 2 && s->phase_flags[band]) {
494 for (bin = band_start; bin < band_end; bin++)
495 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
521 int start_freq = s->start_freq[ch_index];
522 int end_freq = s->end_freq[ch_index];
523 uint8_t *baps = s->bap[ch_index];
524 int8_t *exps = s->dexps[ch_index];
525 int32_t *coeffs = s->fixed_coeffs[ch_index];
526 int dither = (ch_index ==
CPL_CH) || s->dither_flag[ch_index];
530 for (freq = start_freq; freq < end_freq; freq++) {
531 int bap = baps[freq];
537 mantissa = (((
av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
591 coeffs[freq] = mantissa >> exps[freq];
603 for (ch = 1; ch <= s->fbw_channels; ch++) {
604 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
605 for (i = s->start_freq[
CPL_CH]; i < s->end_freq[
CPL_CH]; i++) {
607 s->fixed_coeffs[ch][
i] = 0;
616 if (!s->channel_uses_aht[ch]) {
622 if (CONFIG_EAC3_DECODER && !blk)
624 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
625 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][
blk] >> s->dexps[ch][bin];
641 for (ch = 1; ch <= s->channels; ch++) {
646 if (s->channel_in_cpl[ch]) {
652 end = s->end_freq[
CPL_CH];
654 end = s->end_freq[ch];
657 s->fixed_coeffs[ch][
end] = 0;
674 end =
FFMIN(s->end_freq[1], s->end_freq[2]);
676 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
677 if (s->rematrixing_flags[bnd]) {
680 int tmp0 = s->fixed_coeffs[1][
i];
681 s->fixed_coeffs[1][
i] += s->fixed_coeffs[2][
i];
682 s->fixed_coeffs[2][
i] = tmp0 - s->fixed_coeffs[2][
i];
697 for (ch = 1; ch <=
channels; ch++) {
698 if (s->block_switch[ch]) {
701 for (i = 0; i < 128; i++)
702 x[i] = s->transform_coeffs[ch][2 * i];
703 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
705 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
706 s->tmp_output, s->window, 128, 8);
708 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
709 s->tmp_output, s->window, 128);
711 for (i = 0; i < 128; i++)
712 x[i] = s->transform_coeffs[ch][2 * i + 1];
713 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
715 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
717 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
718 s->tmp_output, s->window, 128, 8);
720 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
721 s->tmp_output, s->window, 128);
723 memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 *
sizeof(
FFTSample));
733 int channel_data_size =
sizeof(s->delay[0]);
734 switch (s->channel_mode) {
738 memcpy(s->delay[1], s->delay[0], channel_data_size);
741 memset(s->delay[3], 0, channel_data_size);
743 memset(s->delay[2], 0, channel_data_size);
746 memset(s->delay[4], 0, channel_data_size);
748 memset(s->delay[3], 0, channel_data_size);
750 memcpy(s->delay[2], s->delay[1], channel_data_size);
751 memset(s->delay[1], 0, channel_data_size);
774 int ecpl,
int start_subband,
int end_subband,
775 const uint8_t *default_band_struct,
776 int *num_bands,
uint8_t *band_sizes,
777 uint8_t *band_struct,
int band_struct_size)
779 int subbnd, bnd, n_subbands, n_bands=0;
782 n_subbands = end_subband - start_subband;
785 memcpy(band_struct, default_band_struct, band_struct_size);
787 av_assert0(band_struct_size >= start_subband + n_subbands);
789 band_struct += start_subband + 1;
793 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
801 if (num_bands || band_sizes ) {
802 n_bands = n_subbands;
803 bnd_sz[0] = ecpl ? 6 : 12;
804 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
805 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
806 if (band_struct[subbnd - 1]) {
808 bnd_sz[bnd] += subbnd_size;
810 bnd_sz[++bnd] = subbnd_size;
817 *num_bands = n_bands;
819 memcpy(band_sizes, bnd_sz, n_bands);
825 int fbw_channels = s->fbw_channels;
826 int dst_start_freq, dst_end_freq, src_start_freq,
827 start_subband, end_subband, ch;
831 s->channel_uses_spx[1] = 1;
833 for (ch = 1; ch <= fbw_channels; ch++)
840 start_subband =
get_bits(bc, 3) + 2;
841 if (start_subband > 7)
842 start_subband += start_subband - 7;
848 end_subband += end_subband - 7;
849 dst_start_freq = dst_start_freq * 12 + 25;
850 src_start_freq = start_subband * 12 + 25;
851 dst_end_freq = end_subband * 12 + 25;
854 if (start_subband >= end_subband) {
856 "range (%d >= %d)\n", start_subband, end_subband);
859 if (dst_start_freq >= src_start_freq) {
861 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
865 s->spx_dst_start_freq = dst_start_freq;
866 s->spx_src_start_freq = src_start_freq;
868 s->spx_dst_end_freq = dst_end_freq;
871 start_subband, end_subband,
875 s->spx_band_struct,
sizeof(s->spx_band_struct));
882 int fbw_channels = s->fbw_channels;
885 for (ch = 1; ch <= fbw_channels; ch++) {
886 if (s->channel_uses_spx[ch]) {
887 if (s->first_spx_coords[ch] ||
get_bits1(bc)) {
889 int bin, master_spx_coord;
891 s->first_spx_coords[ch] = 0;
893 master_spx_coord =
get_bits(bc, 2) * 3;
895 bin = s->spx_src_start_freq;
896 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
897 int bandsize = s->spx_band_sizes[bnd];
898 int spx_coord_exp, spx_coord_mant;
902 int64_t accu = ((bin << 23) + (bandsize << 22))
903 * (int64_t)s->spx_dst_end_freq;
904 nratio = (
int)(accu >> 32);
905 nratio -= spx_blend << 18;
910 }
else if (nratio > 0x7fffff) {
915 accu = (int64_t)nblend * 1859775393;
916 nblend = (
int)((accu + (1<<29)) >> 30);
923 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
924 nratio = av_clipf(nratio, 0.0
f, 1.0
f);
925 nblend = sqrtf(3.0
f * nratio);
927 sblend = sqrtf(1.0
f - nratio);
934 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
935 else spx_coord_mant += 4;
936 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
940 accu = (int64_t)nblend * spx_coord_mant;
941 s->spx_noise_blend[ch][bnd] = (
int)((accu + (1<<22)) >> 23);
942 accu = (int64_t)sblend * spx_coord_mant;
943 s->spx_signal_blend[ch][bnd] = (
int)((accu + (1<<22)) >> 23);
945 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
946 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
947 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
952 s->first_spx_coords[ch] = 1;
961 int fbw_channels = s->fbw_channels;
962 int channel_mode = s->channel_mode;
968 if (s->cpl_in_use[blk]) {
970 int cpl_start_subband, cpl_end_subband;
986 s->channel_in_cpl[1] = 1;
987 s->channel_in_cpl[2] = 1;
989 for (ch = 1; ch <= fbw_channels; ch++)
998 cpl_start_subband =
get_bits(bc, 4);
999 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
1001 if (cpl_start_subband >= cpl_end_subband) {
1003 cpl_start_subband, cpl_end_subband);
1006 s->start_freq[
CPL_CH] = cpl_start_subband * 12 + 37;
1007 s->end_freq[
CPL_CH] = cpl_end_subband * 12 + 37;
1012 &s->num_cpl_bands, s->cpl_band_sizes,
1013 s->cpl_band_struct,
sizeof(s->cpl_band_struct));
1016 for (ch = 1; ch <= fbw_channels; ch++) {
1017 s->channel_in_cpl[ch] = 0;
1018 s->first_cpl_coords[ch] = 1;
1020 s->first_cpl_leak = s->eac3;
1021 s->phase_flags_in_use = 0;
1030 int fbw_channels = s->fbw_channels;
1032 int cpl_coords_exist = 0;
1034 for (ch = 1; ch <= fbw_channels; ch++) {
1035 if (s->channel_in_cpl[ch]) {
1036 if ((s->eac3 && s->first_cpl_coords[ch]) ||
get_bits1(bc)) {
1037 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1038 s->first_cpl_coords[ch] = 0;
1039 cpl_coords_exist = 1;
1040 master_cpl_coord = 3 *
get_bits(bc, 2);
1041 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1044 if (cpl_coord_exp == 15)
1045 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1047 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1048 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1052 "be present in block 0\n");
1057 s->first_cpl_coords[ch] = 1;
1062 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1063 s->phase_flags[bnd] = s->phase_flags_in_use ?
get_bits1(bc) : 0;
1075 int fbw_channels = s->fbw_channels;
1076 int channel_mode = s->channel_mode;
1077 int i, bnd, seg, ch,
ret;
1078 int different_transforms;
1085 different_transforms = 0;
1086 if (s->block_switch_syntax) {
1087 for (ch = 1; ch <= fbw_channels; ch++) {
1089 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1090 different_transforms = 1;
1095 if (s->dither_flag_syntax) {
1096 for (ch = 1; ch <= fbw_channels; ch++) {
1102 i = !s->channel_mode;
1109 if (range_bits <= 127 || s->drc_scale <= 1.0)
1112 s->dynamic_range[
i] = range;
1113 }
else if (blk == 0) {
1119 if (s->eac3 && (!blk ||
get_bits1(gbc))) {
1121 if (s->spx_in_use) {
1126 if (!s->eac3 || !s->spx_in_use) {
1128 for (ch = 1; ch <= fbw_channels; ch++) {
1129 s->channel_uses_spx[ch] = 0;
1130 s->first_spx_coords[ch] = 1;
1139 if (s->eac3 ? s->cpl_strategy_exists[blk] :
get_bits1(gbc)) {
1142 }
else if (!s->eac3) {
1145 "be present in block 0\n");
1148 s->cpl_in_use[
blk] = s->cpl_in_use[blk-1];
1151 cpl_in_use = s->cpl_in_use[
blk];
1161 if ((s->eac3 && !blk) ||
get_bits1(gbc)) {
1162 s->num_rematrixing_bands = 4;
1163 if (cpl_in_use && s->start_freq[
CPL_CH] <= 61) {
1164 s->num_rematrixing_bands -= 1 + (s->start_freq[
CPL_CH] == 37);
1165 }
else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1166 s->num_rematrixing_bands--;
1168 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1169 s->rematrixing_flags[bnd] =
get_bits1(gbc);
1172 "new rematrixing strategy not present in block 0\n");
1173 s->num_rematrixing_bands = 0;
1178 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1180 s->exp_strategy[
blk][ch] =
get_bits(gbc, 2 - (ch == s->lfe_ch));
1181 if (s->exp_strategy[blk][ch] !=
EXP_REUSE)
1182 bit_alloc_stages[ch] = 3;
1186 for (ch = 1; ch <= fbw_channels; ch++) {
1187 s->start_freq[ch] = 0;
1188 if (s->exp_strategy[blk][ch] !=
EXP_REUSE) {
1190 int prev = s->end_freq[ch];
1191 if (s->channel_in_cpl[ch])
1192 s->end_freq[ch] = s->start_freq[
CPL_CH];
1193 else if (s->channel_uses_spx[ch])
1194 s->end_freq[ch] = s->spx_src_start_freq;
1196 int bandwidth_code =
get_bits(gbc, 6);
1197 if (bandwidth_code > 60) {
1201 s->end_freq[ch] = bandwidth_code * 3 + 73;
1203 group_size = 3 << (s->exp_strategy[
blk][ch] - 1);
1204 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1205 if (blk > 0 && s->end_freq[ch] != prev)
1211 (3 << (s->exp_strategy[blk][
CPL_CH] - 1));
1215 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1216 if (s->exp_strategy[blk][ch] !=
EXP_REUSE) {
1217 s->dexps[ch][0] =
get_bits(gbc, 4) << !ch;
1219 s->num_exp_groups[ch], s->dexps[ch][0],
1220 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1223 if (ch !=
CPL_CH && ch != s->lfe_ch)
1229 if (s->bit_allocation_syntax) {
1236 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1237 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1240 "be present in block 0\n");
1246 if (!s->eac3 || !blk) {
1247 if (s->snr_offset_strategy &&
get_bits1(gbc)) {
1250 csnr = (
get_bits(gbc, 6) - 15) << 4;
1251 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1253 if (ch == i || s->snr_offset_strategy == 2)
1254 snr = (csnr +
get_bits(gbc, 4)) << 2;
1256 if (blk && s->snr_offset[ch] != snr) {
1257 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 1);
1259 s->snr_offset[ch] = snr;
1263 int prev = s->fast_gain[ch];
1266 if (blk && prev != s->fast_gain[ch])
1267 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1270 }
else if (!s->eac3 && !blk) {
1277 if (s->fast_gain_syntax &&
get_bits1(gbc)) {
1278 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1279 int prev = s->fast_gain[ch];
1282 if (blk && prev != s->fast_gain[ch])
1283 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1285 }
else if (s->eac3 && !blk) {
1286 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1297 if (s->first_cpl_leak ||
get_bits1(gbc)) {
1302 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1303 sl != s->bit_alloc_params.cpl_slow_leak)) {
1306 s->bit_alloc_params.cpl_fast_leak = fl;
1307 s->bit_alloc_params.cpl_slow_leak = sl;
1308 }
else if (!s->eac3 && !blk) {
1310 "be present in block 0\n");
1313 s->first_cpl_leak = 0;
1319 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1320 s->dba_mode[ch] =
get_bits(gbc, 2);
1325 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1328 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1329 if (s->dba_mode[ch] ==
DBA_NEW) {
1330 s->dba_nsegs[ch] =
get_bits(gbc, 3) + 1;
1331 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1332 s->dba_offsets[ch][seg] =
get_bits(gbc, 5);
1333 s->dba_lengths[ch][seg] =
get_bits(gbc, 4);
1334 s->dba_values[ch][seg] =
get_bits(gbc, 3);
1337 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1340 }
else if (blk == 0) {
1341 for (ch = 0; ch <= s->channels; ch++) {
1347 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1348 if (bit_alloc_stages[ch] > 2) {
1351 s->start_freq[ch], s->end_freq[ch],
1352 s->psd[ch], s->band_psd[ch]);
1354 if (bit_alloc_stages[ch] > 1) {
1358 s->start_freq[ch], s->end_freq[ch],
1359 s->fast_gain[ch], (ch == s->lfe_ch),
1360 s->dba_mode[ch], s->dba_nsegs[ch],
1361 s->dba_offsets[ch], s->dba_lengths[ch],
1362 s->dba_values[ch], s->mask[ch])) {
1367 if (bit_alloc_stages[ch] > 0) {
1371 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1372 s->start_freq[ch], s->end_freq[ch],
1374 s->bit_alloc_params.floor,
1375 bap_tab, s->bap[ch]);
1396 for (ch = 1; ch <= s->channels; ch++) {
1397 int audio_channel = 0;
1400 audio_channel = 2-ch;
1401 if (s->heavy_compression && s->compression_exists[audio_channel])
1402 gain = s->heavy_dynamic_range[audio_channel];
1404 gain = s->dynamic_range[audio_channel];
1407 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1409 if (s->target_level != 0)
1410 gain = gain * s->level_gain[audio_channel];
1411 gain *= 1.0 / 4194304.0f;
1412 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1413 s->fixed_coeffs[ch], gain, 256);
1418 if (CONFIG_EAC3_DECODER && s->spx_in_use) {
1425 downmix_output = s->channels != s->out_channels &&
1426 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1427 s->fbw_channels == s->out_channels);
1428 if (different_transforms) {
1438 if (downmix_output) {
1441 s->out_channels, s->fbw_channels, 256);
1444 s->out_channels, s->fbw_channels, 256);
1448 if (downmix_output) {
1450 s->out_channels, s->fbw_channels, 256);
1453 if (downmix_output && !s->downmixed) {
1456 s->out_channels, s->fbw_channels, 128);
1459 do_imdct(s, s->out_channels, offset);
1469 int *got_frame_ptr,
AVPacket *avpkt)
1473 int buf_size, full_buf_size = avpkt->
size;
1477 int skip = 0, got_independent_frame = 0;
1484 s->superframe_size = 0;
1486 buf_size = full_buf_size;
1487 for (i = 1; i < buf_size; i += 2) {
1488 if (buf[i] == 0x77 || buf[i] == 0x0B) {
1489 if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1492 }
else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1506 if (buf_size >= 2 &&
AV_RB16(buf) == 0x770B) {
1508 int cnt =
FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1509 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1510 (
const uint16_t *) buf, cnt);
1512 memcpy(s->input_buffer, buf,
FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1517 if (s->consistent_noise_generation)
1520 buf = s->input_buffer;
1546 if (s->substreamid) {
1548 "unsupported substream %d: skipping frame\n",
1565 if (s->frame_size > buf_size) {
1571 s->frame_size - 2)) {
1583 return FFMIN(full_buf_size, s->frame_size);
1587 if (!err || (s->channels && s->out_channels != s->channels)) {
1588 s->out_channels = s->channels;
1589 s->output_mode = s->channel_mode;
1591 s->output_mode |= AC3_OUTPUT_LFEON;
1592 if (s->channels > 1 &&
1594 s->out_channels = 1;
1596 }
else if (s->channels > 2 &&
1598 s->out_channels = 2;
1602 s->loro_center_mix_level =
gain_levels[s-> center_mix_level];
1603 s->loro_surround_mix_level =
gain_levels[s->surround_mix_level];
1607 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1608 s->fbw_channels == s->out_channels)) {
1614 }
else if (!s->channels) {
1620 if (s->output_mode & AC3_OUTPUT_LFEON)
1625 if (s->bitstream_mode == 0x7 && s->channels > 1)
1632 output[ch] = s->output[ch +
offset];
1633 s->outptr[ch] = s->output[ch +
offset];
1635 for (ch = 0; ch < s->channels; ch++) {
1636 if (ch < s->out_channels)
1637 s->outptr[channel_map[ch]] = s->output_buffer[ch +
offset];
1639 for (blk = 0; blk < s->num_blocks; blk++) {
1645 for (ch = 0; ch < s->out_channels; ch++)
1647 for (ch = 0; ch < s->out_channels; ch++)
1648 output[ch] = s->outptr[channel_map[ch]];
1649 for (ch = 0; ch < s->out_channels; ch++) {
1650 if (!ch || channel_map[ch])
1656 for (ch = 0; ch < s->out_channels; ch++)
1660 if (buf_size > s->frame_size) {
1664 if (buf_size - s->frame_size <= 16) {
1669 if ((ret =
init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1680 buf += s->frame_size;
1681 buf_size -= s->frame_size;
1682 s->prev_output_mode = s->output_mode;
1683 s->prev_bit_rate = s->bit_rate;
1684 got_independent_frame = 1;
1685 goto dependent_frame;
1696 avctx->
bit_rate = s->bit_rate + s->prev_bit_rate;
1700 extended_channel_map[ch] = ch;
1704 int channel_map_size =
ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1705 uint64_t channel_layout;
1708 if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1711 channel_layout = ich_layout;
1712 for (ch = 0; ch < 16; ch++) {
1713 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1727 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1733 if (extend >= channel_map_size)
1736 extended_channel_map[
index] = offset + channel_map[extend++];
1740 for (i = 0; i < 64; i++) {
1746 if (extend >= channel_map_size)
1749 extended_channel_map[
index] = offset + channel_map[extend++];
1762 for (ch = 0; ch < avctx->
channels; ch++) {
1763 int map = extended_channel_map[ch];
1766 s->output_buffer[map],
1778 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1784 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1785 switch (s->dolby_surround_ex_mode) {
1801 switch (s->preferred_downmix) {
1819 if (s->lfe_mix_level_exists)
1828 if (!s->superframe_size)
1829 return FFMIN(full_buf_size, s->frame_size + skip);
1831 return FFMIN(full_buf_size, s->superframe_size + skip);
1848 #define OFFSET(x) offsetof(AC3DecodeContext, x) 1849 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
static int coupling_strategy(AC3DecodeContext *s, int blk, uint8_t *bit_alloc_stages)
void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix, int out_ch, int in_ch, int len)
const uint8_t ff_ac3_bap_tab[64]
static const uint8_t ac3_default_coeffs[8][5][2]
Table for default stereo downmixing coefficients reference: Section 7.8.2 Downmixing Into Two Channel...
int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)
Parse AC-3 frame header.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_NUM_DATA_POINTERS
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
static int spx_strategy(AC3DecodeContext *s, int blk)
const uint8_t ff_eac3_default_spx_band_struct[17]
Table E2.15 Default Spectral Extension Banding Structure.
const uint8_t ff_ac3_slow_decay_tab[4]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
int64_t bit_rate
the average bitrate
const uint8_t ff_ac3_ungroup_3_in_5_bits_tab[32][3]
Table used to ungroup 3 values stored in 5 bits.
static int ff_eac3_parse_header(AC3DecodeContext *s)
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define avpriv_request_sample(...)
double center_mix_level_ltrt
Absolute scale factor representing the nominal level of the center channel during an Lt/Rt compatible...
static const uint8_t bap_tab[64]
#define LEVEL_PLUS_1POINT5DB
AVDownmixInfo * av_downmix_info_update_side_data(AVFrame *frame)
Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing.
static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
Decode the transform coefficients for a particular channel reference: Section 7.3 Quantization and De...
static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, mant_groups *m)
#define AV_CH_LAYOUT_STEREO
const uint16_t ff_ac3_slow_gain_tab[4]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
static int get_sbits(GetBitContext *s, int n)
static void spx_coordinates(AC3DecodeContext *s)
static void scale_coefs(int32_t *dst, const int32_t *src, int dynrng, int len)
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
enum AVSampleFormat sample_fmt
audio sample format
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static av_cold int end(AVCodecContext *avctx)
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
static uint8_t ungroup_3_in_7_bits_tab[128][3]
table for ungrouping 3 values in 7 bits.
#define AV_CH_LOW_FREQUENCY
Public header for CRC hash function implementation.
double surround_mix_level_ltrt
Absolute scale factor representing the nominal level of the surround channels during an Lt/Rt compati...
static int b1_mantissas[32][3]
tables for ungrouping mantissas
Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible.
#define LEVEL_MINUS_1POINT5DB
static av_always_inline int fixed_sqrt(int x, int bits)
Calculate the square root.
double lfe_mix_level
Absolute scale factor representing the level at which the LFE data is mixed into L/R channels during ...
static void do_imdct(AC3DecodeContext *s, int channels, int offset)
Inverse MDCT Transform.
static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
Grouped mantissas for 3-level 5-level and 11-level quantization.
const uint16_t avpriv_ac3_channel_layout_tab[8]
Map audio coding mode (acmod) to channel layout mask.
This structure describes optional metadata relevant to a downmix procedure.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AC3_DYNAMIC_RANGE1
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
const uint8_t ff_ac3_fast_decay_tab[4]
static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
Decode the transform coefficients.
static const uint8_t dither[8][8]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AC3_MAX_CHANNELS
maximum number of channels, including coupling channel
int flags
AV_CODEC_FLAG_*.
int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask)
Calculate the masking curve.
static int decode_audio_block(AC3DecodeContext *s, int blk, int offset)
Decode a single audio block from the AC-3 bitstream.
static int ac3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single AC-3 frame.
uint64_t channel_layout
Audio channel layout.
#define LEVEL_MINUS_4POINT5DB
static int b3_mantissas[8]
static int set_downmix_coeffs(AC3DecodeContext *s)
Set stereo downmixing coefficients based on frame header info.
static float dynamic_range_tab[256]
dynamic range table.
static void do_rematrixing(AC3DecodeContext *s)
Stereo rematrixing.
#define AC3_HEAVY_RANGE(x)
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
static int b5_mantissas[16]
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Lt/Rt 2-channel downmix, Dolby Surround compatible.
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
const uint16_t ff_ac3_fast_gain_tab[8]
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int b2_mantissas[128][3]
Lo/Ro 2-channel downmix (Stereo).
#define AV_EF_EXPLODE
abort decoding on minor error detection
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
static int b4_mantissas[128][2]
static void decode_band_structure(GetBitContext *gbc, int blk, int eac3, int ecpl, int start_subband, int end_subband, const uint8_t *default_band_struct, int *num_bands, uint8_t *band_sizes, uint8_t *band_struct, int band_struct_size)
Decode band structure for coupling, spectral extension, or enhanced coupling.
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length)
Seed the state of the ALFG using binary data.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
double surround_mix_level
Absolute scale factor representing the nominal level of the surround channels during a regular downmi...
#define CPL_CH
coupling channel index
const uint8_t ff_eac3_default_cpl_band_struct[18]
Table E2.16 Default Coupling Banding Structure.
int sample_rate
samples per second
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
static const float gain_levels[9]
Adjustments in dB gain.
#define AV_EF_CAREFUL
consider things that violate the spec, are fast to calculate and have not been seen in the wild as er...
static unsigned int get_bits1(GetBitContext *s)
static const int end_freq_inv_tab[8]
static void skip_bits(GetBitContext *s, int n)
static int decode_exponents(AC3DecodeContext *s, GetBitContext *gbc, int exp_strategy, int ngrps, uint8_t absexp, int8_t *dexps)
Decode the grouped exponents according to exponent strategy.
static const uint8_t quantization_tab[16]
Quantization table: levels for symmetric.
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
const VDPAUPixFmtMap * map
#define FF_DECODE_ERROR_INVALID_BITSTREAM
const int16_t ff_ac3_floor_tab[8]
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
int av_get_channel_layout_channel_index(uint64_t channel_layout, uint64_t channel)
Get the index of a channel in channel_layout.
static int coupling_coordinates(AC3DecodeContext *s, int blk)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static int ac3_parse_header(AC3DecodeContext *s)
Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVFixedDSPContext * avpriv_alloc_fixed_dsp(int bit_exact)
Allocate and initialize a fixed DSP context.
#define AC3_DYNAMIC_RANGE(x)
const uint64_t ff_eac3_custom_channel_map_locations[16][2]
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
const uint8_t ff_ac3_channels_tab[8]
Map audio coding mode (acmod) to number of full-bandwidth channels.
common internal api header.
static void ac3_downmix_c_fixed16(int16_t **samples, int16_t **matrix, int out_ch, int in_ch, int len)
Downmix samples from original signal to stereo or mono (this is for 16-bit samples and fixed point de...
static av_cold void ac3_tables_init(void)
double center_mix_level
Absolute scale factor representing the nominal level of the center channel during a regular downmix...
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, int16_t *band_psd)
Calculate the log power-spectral density of the input signal.
#define EAC3_MAX_CHANNELS
maximum number of channels in EAC3
static int parse_frame_header(AC3DecodeContext *s)
Common function to parse AC-3 or E-AC-3 frame header.
int channels
number of audio channels
static int ff_thread_once(char *control, void(*routine)(void))
static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
Generate transform coefficients for each coupled channel in the coupling range using the coupling coe...
static const float gain_levels_lfe[32]
Adjustments in dB gain (LFE, +10 to -21 dB)
static int symmetric_dequant(int code, int levels)
Symmetrical Dequantization reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantizati...
static void ac3_upmix_delay(AC3DecodeContext *s)
Upmix delay samples from stereo to original channel layout.
const uint8_t ff_ac3_rematrix_band_tab[5]
Table of bin locations for rematrixing bands reference: Section 7.5.2 Rematrixing : Frequency Band De...
const uint8_t ff_eac3_hebap_tab[64]
#define av_malloc_array(a, b)
const uint8_t ff_ac3_dec_channel_map[8][2][6]
Table to remap channels from AC-3 order to SMPTE order.
static av_cold int ac3_decode_init(AVCodecContext *avctx)
AVCodec initialization.
const uint16_t ff_ac3_db_per_bit_tab[4]
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
#define AV_CH_LAYOUT_MONO
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
static void remove_dithering(AC3DecodeContext *s)
Remove random dithering from coupling range coefficients with zero-bit mantissas for coupled channels...
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
float ff_ac3_heavy_dynamic_range_tab[256]
enum AVDownmixType preferred_downmix_type
Type of downmix preferred by the mastering engineer.