27 #include "config_components.h"
69 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
93 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
94 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
95 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
96 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
97 0.125892, 0.112201, 0.100000, 0.089125
105 { { 2, 7 }, { 7, 2 }, },
107 { { 2, 7 }, { 7, 2 }, },
108 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
109 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
110 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
111 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
112 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
123 return ((
code - (levels >> 1)) * (1 << 24)) / levels;
135 for (
i = 0;
i < 128;
i++) {
143 for (
i = 0;
i < 32;
i++) {
149 for (
i = 0;
i < 128;
i++) {
161 for (
i = 0;
i < 7;
i++) {
165 for (
i = 0;
i < 15;
i++) {
173 for (
i = 0;
i < 256;
i++) {
174 int v = (
i >> 5) - ((
i >> 7) << 3) - 5;
180 for (
i = 0;
i < 256;
i++) {
181 int v = (
i >> 4) - ((
i >> 7) << 4) - 4;
213 const float scale = 1.0f;
247 s->xcfptr[
i] =
s->transform_coeffs[
i];
248 s->dlyptr[
i] =
s->delay[
i];
267 i = !
s->channel_mode;
269 s->dialog_normalization[(!
s->channel_mode)-
i] = -
get_bits(gbc, 5);
270 if (
s->dialog_normalization[(!
s->channel_mode)-
i] == 0) {
271 s->dialog_normalization[(!
s->channel_mode)-
i] = -31;
273 if (
s->target_level != 0) {
274 s->level_gain[(!
s->channel_mode)-
i] =
powf(2.0
f,
275 (
float)(
s->target_level -
276 s->dialog_normalization[(!
s->channel_mode)-
i])/6.0f);
278 if (
s->compression_exists[(!
s->channel_mode)-
i] =
get_bits1(gbc)) {
279 s->heavy_dynamic_range[(!
s->channel_mode)-
i] =
291 if (
s->bitstream_id != 6) {
299 s->center_mix_level_ltrt =
get_bits(gbc, 3);
305 s->dolby_surround_ex_mode =
get_bits(gbc, 2);
306 s->dolby_headphone_mode =
get_bits(gbc, 2);
335 s->bit_alloc_params.sr_code = hdr.
sr_code;
340 s->bit_alloc_params.sr_shift = hdr.
sr_shift;
344 s->fbw_channels =
s->channels -
s->lfe_on;
345 s->lfe_ch =
s->fbw_channels + 1;
350 s->center_mix_level_ltrt = 4;
352 s->surround_mix_level_ltrt = 4;
353 s->lfe_mix_level_exists = 0;
362 s->start_freq[
s->lfe_ch] = 0;
363 s->end_freq[
s->lfe_ch] = 7;
364 s->num_exp_groups[
s->lfe_ch] = 2;
365 s->channel_in_cpl[
s->lfe_ch] = 0;
368 if (
s->bitstream_id <= 10) {
370 s->snr_offset_strategy = 2;
371 s->block_switch_syntax = 1;
372 s->dither_flag_syntax = 1;
373 s->bit_allocation_syntax = 1;
374 s->fast_gain_syntax = 0;
375 s->first_cpl_leak = 0;
378 memset(
s->channel_uses_aht, 0,
sizeof(
s->channel_uses_aht));
380 }
else if (CONFIG_EAC3_DECODER) {
401 if (!
s->downmix_coeffs[0]) {
403 sizeof(**
s->downmix_coeffs));
404 if (!
s->downmix_coeffs[0])
409 for (
i = 0;
i <
s->fbw_channels;
i++) {
413 if (
s->channel_mode > 1 &&
s->channel_mode & 1) {
414 downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
417 int nf =
s->channel_mode - 2;
418 downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix *
LEVEL_MINUS_3DB;
421 int nf =
s->channel_mode - 4;
422 downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
427 for (
i = 0;
i <
s->fbw_channels;
i++) {
428 norm0 += downmix_coeffs[0][
i];
429 norm1 += downmix_coeffs[1][
i];
431 norm0 = 1.0f / norm0;
432 norm1 = 1.0f / norm1;
433 for (
i = 0;
i <
s->fbw_channels;
i++) {
434 downmix_coeffs[0][
i] *= norm0;
435 downmix_coeffs[1][
i] *= norm1;
439 for (
i = 0;
i <
s->fbw_channels;
i++)
440 downmix_coeffs[0][
i] = (downmix_coeffs[0][
i] +
443 for (
i = 0;
i <
s->fbw_channels;
i++) {
444 s->downmix_coeffs[0][
i] =
FIXR12(downmix_coeffs[0][
i]);
445 s->downmix_coeffs[1][
i] =
FIXR12(downmix_coeffs[1][
i]);
457 uint8_t absexp, int8_t *dexps)
459 int i, j, grp, group_size;
464 group_size = exp_strategy + (exp_strategy ==
EXP_D45);
465 for (grp = 0,
i = 0; grp < ngrps; grp++) {
478 for (
i = 0, j = 0;
i < ngrps * 3;
i++) {
479 prevexp += dexp[
i] - 2;
484 switch (group_size) {
485 case 4: dexps[j++] = prevexp;
486 dexps[j++] = prevexp;
487 case 2: dexps[j++] = prevexp;
488 case 1: dexps[j++] = prevexp;
504 for (band = 0; band <
s->num_cpl_bands; band++) {
505 int band_start = bin;
506 int band_end = bin +
s->cpl_band_sizes[band];
507 for (ch = 1; ch <=
s->fbw_channels; ch++) {
508 if (
s->channel_in_cpl[ch]) {
509 int cpl_coord =
s->cpl_coords[ch][band] << 5;
510 for (bin = band_start; bin < band_end; bin++) {
511 s->fixed_coeffs[ch][bin] =
512 MULH(
s->fixed_coeffs[
CPL_CH][bin] * (1 << 4), cpl_coord);
514 if (ch == 2 &&
s->phase_flags[band]) {
515 for (bin = band_start; bin < band_end; bin++)
516 s->fixed_coeffs[2][bin] = -
s->fixed_coeffs[2][bin];
542 int start_freq =
s->start_freq[ch_index];
543 int end_freq =
s->end_freq[ch_index];
544 uint8_t *baps =
s->bap[ch_index];
545 int8_t *exps =
s->dexps[ch_index];
546 int32_t *coeffs =
s->fixed_coeffs[ch_index];
547 int dither = (ch_index ==
CPL_CH) ||
s->dither_flag[ch_index];
551 for (freq = start_freq; freq < end_freq; freq++) {
552 int bap = baps[freq];
558 mantissa = (((
av_lfg_get(&
s->dith_state)>>8)*181)>>8) - 5931008;
612 coeffs[freq] = mantissa >> exps[freq];
624 for (ch = 1; ch <=
s->fbw_channels; ch++) {
625 if (!
s->dither_flag[ch] &&
s->channel_in_cpl[ch]) {
628 s->fixed_coeffs[ch][
i] = 0;
637 if (!
s->channel_uses_aht[ch]) {
643 if (CONFIG_EAC3_DECODER && !
blk)
645 for (bin =
s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
646 s->fixed_coeffs[ch][bin] =
s->pre_mantissa[ch][bin][
blk] >>
s->dexps[ch][bin];
662 for (ch = 1; ch <=
s->channels; ch++) {
667 if (
s->channel_in_cpl[ch]) {
675 end =
s->end_freq[ch];
678 s->fixed_coeffs[ch][end] = 0;
695 end =
FFMIN(
s->end_freq[1],
s->end_freq[2]);
697 for (bnd = 0; bnd <
s->num_rematrixing_bands; bnd++) {
698 if (
s->rematrixing_flags[bnd]) {
701 int tmp0 =
s->fixed_coeffs[1][
i];
702 s->fixed_coeffs[1][
i] +=
s->fixed_coeffs[2][
i];
703 s->fixed_coeffs[2][
i] = tmp0 -
s->fixed_coeffs[2][
i];
718 for (ch = 1; ch <=
channels; ch++) {
719 if (
s->block_switch[ch]) {
722 for (
i = 0;
i < 128;
i++)
723 x[
i] =
s->transform_coeffs[ch][2 *
i];
724 s->tx_fn_128(
s->tx_128,
s->tmp_output, x,
sizeof(
INTFLOAT));
726 s->fdsp->vector_fmul_window_scaled(
s->outptr[ch - 1],
s->delay[ch - 1 +
offset],
727 s->tmp_output,
s->window, 128, 8);
729 s->fdsp->vector_fmul_window(
s->outptr[ch - 1],
s->delay[ch - 1 +
offset],
730 s->tmp_output,
s->window, 128);
732 for (
i = 0;
i < 128;
i++)
733 x[
i] =
s->transform_coeffs[ch][2 *
i + 1];
736 s->tx_fn_256(
s->tx_256,
s->tmp_output,
s->transform_coeffs[ch],
sizeof(
INTFLOAT));
738 s->fdsp->vector_fmul_window_scaled(
s->outptr[ch - 1],
s->delay[ch - 1 +
offset],
739 s->tmp_output,
s->window, 128, 8);
741 s->fdsp->vector_fmul_window(
s->outptr[ch - 1],
s->delay[ch - 1 +
offset],
742 s->tmp_output,
s->window, 128);
744 memcpy(
s->delay[ch - 1 +
offset],
s->tmp_output + 128, 128 *
sizeof(
INTFLOAT));
754 int channel_data_size =
sizeof(
s->delay[0]);
755 switch (
s->channel_mode) {
759 memcpy(
s->delay[1],
s->delay[0], channel_data_size);
762 memset(
s->delay[3], 0, channel_data_size);
764 memset(
s->delay[2], 0, channel_data_size);
767 memset(
s->delay[4], 0, channel_data_size);
769 memset(
s->delay[3], 0, channel_data_size);
771 memcpy(
s->delay[2],
s->delay[1], channel_data_size);
772 memset(
s->delay[1], 0, channel_data_size);
795 int ecpl,
int start_subband,
int end_subband,
796 const uint8_t *default_band_struct,
797 int *num_bands, uint8_t *band_sizes,
798 uint8_t *band_struct,
int band_struct_size)
800 int subbnd, bnd, n_subbands, n_bands=0;
803 n_subbands = end_subband - start_subband;
806 memcpy(band_struct, default_band_struct, band_struct_size);
808 av_assert0(band_struct_size >= start_subband + n_subbands);
810 band_struct += start_subband + 1;
814 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
822 if (num_bands || band_sizes ) {
823 n_bands = n_subbands;
824 bnd_sz[0] = ecpl ? 6 : 12;
825 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
826 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
827 if (band_struct[subbnd - 1]) {
829 bnd_sz[bnd] += subbnd_size;
831 bnd_sz[++bnd] = subbnd_size;
838 *num_bands = n_bands;
840 memcpy(band_sizes, bnd_sz, n_bands);
846 int fbw_channels =
s->fbw_channels;
847 int dst_start_freq, dst_end_freq, src_start_freq,
848 start_subband, end_subband, ch;
852 s->channel_uses_spx[1] = 1;
854 for (ch = 1; ch <= fbw_channels; ch++)
861 start_subband =
get_bits(bc, 3) + 2;
862 if (start_subband > 7)
863 start_subband += start_subband - 7;
869 end_subband += end_subband - 7;
870 dst_start_freq = dst_start_freq * 12 + 25;
871 src_start_freq = start_subband * 12 + 25;
872 dst_end_freq = end_subband * 12 + 25;
875 if (start_subband >= end_subband) {
877 "range (%d >= %d)\n", start_subband, end_subband);
880 if (dst_start_freq >= src_start_freq) {
882 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
886 s->spx_dst_start_freq = dst_start_freq;
887 s->spx_src_start_freq = src_start_freq;
889 s->spx_dst_end_freq = dst_end_freq;
892 start_subband, end_subband,
896 s->spx_band_struct,
sizeof(
s->spx_band_struct));
903 int fbw_channels =
s->fbw_channels;
906 for (ch = 1; ch <= fbw_channels; ch++) {
907 if (
s->channel_uses_spx[ch]) {
908 if (
s->first_spx_coords[ch] ||
get_bits1(bc)) {
910 int bin, master_spx_coord;
912 s->first_spx_coords[ch] = 0;
914 master_spx_coord =
get_bits(bc, 2) * 3;
916 bin =
s->spx_src_start_freq;
917 for (bnd = 0; bnd <
s->num_spx_bands; bnd++) {
918 int bandsize =
s->spx_band_sizes[bnd];
919 int spx_coord_exp, spx_coord_mant;
923 int64_t accu = ((bin << 23) + (bandsize << 22))
924 * (int64_t)
s->spx_dst_end_freq;
925 nratio = (
int)(accu >> 32);
926 nratio -= spx_blend << 18;
931 }
else if (nratio > 0x7fffff) {
936 accu = (int64_t)nblend * 1859775393;
937 nblend = (
int)((accu + (1<<29)) >> 30);
944 nratio = ((
float)((bin + (bandsize >> 1))) /
s->spx_dst_end_freq) - spx_blend;
946 nblend =
sqrtf(3.0
f * nratio);
948 sblend =
sqrtf(1.0
f - nratio);
955 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
956 else spx_coord_mant += 4;
957 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
961 accu = (int64_t)nblend * spx_coord_mant;
962 s->spx_noise_blend[ch][bnd] = (
int)((accu + (1<<22)) >> 23);
963 accu = (int64_t)sblend * spx_coord_mant;
964 s->spx_signal_blend[ch][bnd] = (
int)((accu + (1<<22)) >> 23);
966 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
967 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
968 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
973 s->first_spx_coords[ch] = 1;
979 uint8_t *bit_alloc_stages)
982 int fbw_channels =
s->fbw_channels;
983 int channel_mode =
s->channel_mode;
989 if (
s->cpl_in_use[
blk]) {
991 int cpl_start_subband, cpl_end_subband;
1007 s->channel_in_cpl[1] = 1;
1008 s->channel_in_cpl[2] = 1;
1010 for (ch = 1; ch <= fbw_channels; ch++)
1019 cpl_start_subband =
get_bits(bc, 4);
1020 cpl_end_subband =
s->spx_in_use ? (
s->spx_src_start_freq - 37) / 12 :
1022 if (cpl_start_subband >= cpl_end_subband) {
1024 cpl_start_subband, cpl_end_subband);
1027 s->start_freq[
CPL_CH] = cpl_start_subband * 12 + 37;
1028 s->end_freq[
CPL_CH] = cpl_end_subband * 12 + 37;
1033 &
s->num_cpl_bands,
s->cpl_band_sizes,
1034 s->cpl_band_struct,
sizeof(
s->cpl_band_struct));
1037 for (ch = 1; ch <= fbw_channels; ch++) {
1038 s->channel_in_cpl[ch] = 0;
1039 s->first_cpl_coords[ch] = 1;
1041 s->first_cpl_leak =
s->eac3;
1042 s->phase_flags_in_use = 0;
1051 int fbw_channels =
s->fbw_channels;
1053 int cpl_coords_exist = 0;
1055 for (ch = 1; ch <= fbw_channels; ch++) {
1056 if (
s->channel_in_cpl[ch]) {
1057 if ((
s->eac3 &&
s->first_cpl_coords[ch]) ||
get_bits1(bc)) {
1058 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1059 s->first_cpl_coords[ch] = 0;
1060 cpl_coords_exist = 1;
1061 master_cpl_coord = 3 *
get_bits(bc, 2);
1062 for (bnd = 0; bnd <
s->num_cpl_bands; bnd++) {
1065 if (cpl_coord_exp == 15)
1066 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1068 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1069 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1073 "be present in block 0\n");
1078 s->first_cpl_coords[ch] = 1;
1083 for (bnd = 0; bnd <
s->num_cpl_bands; bnd++) {
1084 s->phase_flags[bnd] =
s->phase_flags_in_use ?
get_bits1(bc) : 0;
1096 int fbw_channels =
s->fbw_channels;
1097 int channel_mode =
s->channel_mode;
1098 int i, bnd, seg, ch,
ret;
1099 int different_transforms;
1106 different_transforms = 0;
1107 if (
s->block_switch_syntax) {
1108 for (ch = 1; ch <= fbw_channels; ch++) {
1110 if (ch > 1 &&
s->block_switch[ch] !=
s->block_switch[1])
1111 different_transforms = 1;
1116 if (
s->dither_flag_syntax) {
1117 for (ch = 1; ch <= fbw_channels; ch++) {
1123 i = !
s->channel_mode;
1130 if (range_bits <= 127 || s->drc_scale <= 1.0)
1134 }
else if (
blk == 0) {
1142 if (
s->spx_in_use) {
1147 if (!
s->eac3 || !
s->spx_in_use) {
1149 for (ch = 1; ch <= fbw_channels; ch++) {
1150 s->channel_uses_spx[ch] = 0;
1151 s->first_spx_coords[ch] = 1;
1163 }
else if (!
s->eac3) {
1166 "be present in block 0\n");
1169 s->cpl_in_use[
blk] =
s->cpl_in_use[
blk-1];
1172 cpl_in_use =
s->cpl_in_use[
blk];
1183 s->num_rematrixing_bands = 4;
1184 if (cpl_in_use &&
s->start_freq[
CPL_CH] <= 61) {
1185 s->num_rematrixing_bands -= 1 + (
s->start_freq[
CPL_CH] == 37);
1186 }
else if (
s->spx_in_use &&
s->spx_src_start_freq <= 61) {
1187 s->num_rematrixing_bands--;
1189 for (bnd = 0; bnd <
s->num_rematrixing_bands; bnd++)
1193 "new rematrixing strategy not present in block 0\n");
1194 s->num_rematrixing_bands = 0;
1199 for (ch = !cpl_in_use; ch <=
s->channels; ch++) {
1201 s->exp_strategy[
blk][ch] =
get_bits(gbc, 2 - (ch ==
s->lfe_ch));
1203 bit_alloc_stages[ch] = 3;
1207 for (ch = 1; ch <= fbw_channels; ch++) {
1208 s->start_freq[ch] = 0;
1211 int prev =
s->end_freq[ch];
1212 if (
s->channel_in_cpl[ch])
1213 s->end_freq[ch] =
s->start_freq[
CPL_CH];
1214 else if (
s->channel_uses_spx[ch])
1215 s->end_freq[ch] =
s->spx_src_start_freq;
1217 int bandwidth_code =
get_bits(gbc, 6);
1218 if (bandwidth_code > 60) {
1222 s->end_freq[ch] = bandwidth_code * 3 + 73;
1224 group_size = 3 << (
s->exp_strategy[
blk][ch] - 1);
1225 s->num_exp_groups[ch] = (
s->end_freq[ch] + group_size-4) / group_size;
1226 if (
blk > 0 &&
s->end_freq[ch] != prev)
1236 for (ch = !cpl_in_use; ch <=
s->channels; ch++) {
1238 s->dexps[ch][0] =
get_bits(gbc, 4) << !ch;
1240 s->num_exp_groups[ch],
s->dexps[ch][0],
1241 &
s->dexps[ch][
s->start_freq[ch]+!!ch])) {
1244 if (ch !=
CPL_CH && ch !=
s->lfe_ch)
1250 if (
s->bit_allocation_syntax) {
1257 for (ch = !cpl_in_use; ch <=
s->channels; ch++)
1258 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1261 "be present in block 0\n");
1267 if (!
s->eac3 || !
blk) {
1268 if (
s->snr_offset_strategy &&
get_bits1(gbc)) {
1271 csnr = (
get_bits(gbc, 6) - 15) << 4;
1272 for (
i = ch = !cpl_in_use; ch <=
s->channels; ch++) {
1274 if (ch ==
i ||
s->snr_offset_strategy == 2)
1275 snr = (csnr +
get_bits(gbc, 4)) << 2;
1277 if (
blk &&
s->snr_offset[ch] != snr) {
1278 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 1);
1280 s->snr_offset[ch] = snr;
1284 int prev =
s->fast_gain[ch];
1287 if (
blk && prev !=
s->fast_gain[ch])
1288 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1291 }
else if (!
s->eac3 && !
blk) {
1299 for (ch = !cpl_in_use; ch <=
s->channels; ch++) {
1300 int prev =
s->fast_gain[ch];
1303 if (
blk && prev !=
s->fast_gain[ch])
1304 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1306 }
else if (
s->eac3 && !
blk) {
1307 for (ch = !cpl_in_use; ch <=
s->channels; ch++)
1323 if (
blk && (fl !=
s->bit_alloc_params.cpl_fast_leak ||
1324 sl !=
s->bit_alloc_params.cpl_slow_leak)) {
1327 s->bit_alloc_params.cpl_fast_leak = fl;
1328 s->bit_alloc_params.cpl_slow_leak = sl;
1329 }
else if (!
s->eac3 && !
blk) {
1331 "be present in block 0\n");
1334 s->first_cpl_leak = 0;
1340 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1346 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1349 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1351 s->dba_nsegs[ch] =
get_bits(gbc, 3) + 1;
1352 for (seg = 0; seg <
s->dba_nsegs[ch]; seg++) {
1353 s->dba_offsets[ch][seg] =
get_bits(gbc, 5);
1354 s->dba_lengths[ch][seg] =
get_bits(gbc, 4);
1355 s->dba_values[ch][seg] =
get_bits(gbc, 3);
1358 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1361 }
else if (
blk == 0) {
1362 for (ch = 0; ch <=
s->channels; ch++) {
1368 for (ch = !cpl_in_use; ch <=
s->channels; ch++) {
1369 if (bit_alloc_stages[ch] > 2) {
1372 s->start_freq[ch],
s->end_freq[ch],
1373 s->psd[ch],
s->band_psd[ch]);
1375 if (bit_alloc_stages[ch] > 1) {
1379 s->start_freq[ch],
s->end_freq[ch],
1380 s->fast_gain[ch], (ch ==
s->lfe_ch),
1381 s->dba_mode[ch],
s->dba_nsegs[ch],
1382 s->dba_offsets[ch],
s->dba_lengths[ch],
1383 s->dba_values[ch],
s->mask[ch])) {
1388 if (bit_alloc_stages[ch] > 0) {
1390 const uint8_t *
bap_tab =
s->channel_uses_aht[ch] ?
1392 s->ac3dsp.bit_alloc_calc_bap(
s->mask[ch],
s->psd[ch],
1393 s->start_freq[ch],
s->end_freq[ch],
1395 s->bit_alloc_params.floor,
1417 for (ch = 1; ch <=
s->channels; ch++) {
1418 int audio_channel = 0;
1421 audio_channel = 2-ch;
1422 if (
s->heavy_compression &&
s->compression_exists[audio_channel])
1423 gain =
s->heavy_dynamic_range[audio_channel];
1425 gain =
s->dynamic_range[audio_channel];
1428 scale_coefs(
s->transform_coeffs[ch],
s->fixed_coeffs[ch], gain, 256);
1430 if (
s->target_level != 0)
1431 gain = gain *
s->level_gain[audio_channel];
1432 gain *= 1.0 / 4194304.0f;
1433 s->fmt_conv.int32_to_float_fmul_scalar(
s->transform_coeffs[ch],
1434 s->fixed_coeffs[ch], gain, 256);
1439 if (CONFIG_EAC3_DECODER &&
s->spx_in_use) {
1446 downmix_output =
s->channels !=
s->out_channels &&
1447 !((
s->output_mode & AC3_OUTPUT_LFEON) &&
1448 s->fbw_channels ==
s->out_channels);
1449 if (different_transforms) {
1459 if (downmix_output) {
1462 s->out_channels,
s->fbw_channels, 256);
1465 s->out_channels,
s->fbw_channels, 256);
1469 if (downmix_output) {
1471 s->out_channels,
s->fbw_channels, 256);
1474 if (downmix_output && !
s->downmixed) {
1477 s->out_channels,
s->fbw_channels, 128);
1490 int *got_frame_ptr,
AVPacket *avpkt)
1492 const uint8_t *buf = avpkt->
data;
1493 int buf_size, full_buf_size = avpkt->
size;
1497 int skip = 0, got_independent_frame = 0;
1505 s->superframe_size = 0;
1507 buf_size = full_buf_size;
1509 if (i < 0 || i > 10)
1516 if (buf_size >= 2 &&
AV_RB16(buf) == 0x770B) {
1518 int cnt =
FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1519 s->bdsp.bswap16_buf((uint16_t *)
s->input_buffer,
1520 (
const uint16_t *) buf, cnt);
1522 memcpy(
s->input_buffer, buf,
FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1527 if (
s->consistent_noise_generation)
1530 buf =
s->input_buffer;
1556 if (
s->substreamid) {
1558 "unsupported substream %d: skipping frame\n",
1575 if (
s->frame_size > buf_size) {
1581 s->frame_size - 2)) {
1593 return FFMIN(full_buf_size,
s->frame_size);
1597 if (!err || (
s->channels &&
s->out_channels !=
s->channels)) {
1598 s->out_channels =
s->channels;
1599 s->output_mode =
s->channel_mode;
1601 s->output_mode |= AC3_OUTPUT_LFEON;
1602 if (
s->channels > 1 &&
1604 s->out_channels = 1;
1606 }
else if (
s->channels > 2 &&
1608 s->out_channels = 2;
1612 s->loro_center_mix_level =
gain_levels[
s-> center_mix_level];
1613 s->loro_surround_mix_level =
gain_levels[
s->surround_mix_level];
1617 if (
s->channels !=
s->out_channels && !((
s->output_mode & AC3_OUTPUT_LFEON) &&
1618 s->fbw_channels ==
s->out_channels)) {
1624 }
else if (!
s->channels) {
1630 if (
s->output_mode & AC3_OUTPUT_LFEON)
1638 if (
s->bitstream_mode == 0x7 &&
s->channels > 1)
1646 s->outptr[ch] =
s->output[ch +
offset];
1648 for (ch = 0; ch <
s->channels; ch++) {
1649 if (ch < s->out_channels)
1658 for (ch = 0; ch <
s->out_channels; ch++)
1660 for (ch = 0; ch <
s->out_channels; ch++)
1662 for (ch = 0; ch <
s->out_channels; ch++) {
1669 for (ch = 0; ch <
s->out_channels; ch++)
1673 if (buf_size >
s->frame_size) {
1677 if (buf_size -
s->frame_size <= 16) {
1678 skip = buf_size -
s->frame_size;
1693 buf +=
s->frame_size;
1694 buf_size -=
s->frame_size;
1695 s->prev_output_mode =
s->output_mode;
1696 s->prev_bit_rate =
s->bit_rate;
1697 got_independent_frame = 1;
1698 goto dependent_frame;
1709 avctx->
bit_rate =
s->bit_rate +
s->prev_bit_rate;
1719 extended_channel_map[ch] = ch;
1724 uint64_t channel_layout;
1727 if (
s->prev_output_mode & AC3_OUTPUT_LFEON)
1730 channel_layout = ich_layout;
1731 for (ch = 0; ch < 16; ch++) {
1752 if (extend >= channel_map_size)
1759 for (
i = 0;
i < 64;
i++) {
1764 if (extend >= channel_map_size)
1783 int map = extended_channel_map[ch];
1786 s->output_buffer[
map],
1798 s->channel_mode == (
s->output_mode & ~AC3_OUTPUT_LFEON)) {
1804 s->channel_mode == (
s->output_mode & ~AC3_OUTPUT_LFEON)) {
1805 switch (
s->dolby_surround_ex_mode) {
1821 switch (
s->preferred_downmix) {
1839 if (
s->lfe_mix_level_exists)
1848 if (!
s->superframe_size)
1849 return FFMIN(full_buf_size,
s->frame_size +
skip);
1851 return FFMIN(full_buf_size,
s->superframe_size +
skip);
1868 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1869 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)