63 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
87 3.162275, 2.818382, 2.511886, 2.238719, 1.995261, 1.778278, 1.584893,
88 1.412536, 1.258924, 1.122018, 1.000000, 0.891251, 0.794328, 0.707946,
89 0.630957, 0.562341, 0.501187, 0.446683, 0.398107, 0.354813, 0.316227,
90 0.281838, 0.251188, 0.223872, 0.199526, 0.177828, 0.158489, 0.141253,
91 0.125892, 0.112201, 0.100000, 0.089125
99 { { 2, 7 }, { 7, 2 }, },
101 { { 2, 7 }, { 7, 2 }, },
102 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },
103 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },
104 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },
105 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
106 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
117 return ((code - (levels >> 1)) * (1 << 24)) / levels;
129 for (i = 0; i < 128; i++) {
137 for (i = 0; i < 32; i++) {
143 for (i = 0; i < 128; i++) {
155 for (i = 0; i < 7; i++) {
159 for (i = 0; i < 15; i++) {
167 for (i = 0; i < 256; i++) {
168 int v = (i >> 5) - ((i >> 7) << 3) - 5;
174 for (i = 0; i < 256; i++) {
175 int v = (i >> 4) - ((i >> 7) << 4) - 4;
222 s->xcfptr[
i] = s->transform_coeffs[
i];
223 s->dlyptr[
i] = s->delay[
i];
240 i = !s->channel_mode;
242 s->dialog_normalization[(!s->channel_mode)-i] = -
get_bits(gbc, 5);
243 if (s->dialog_normalization[(!s->channel_mode)-
i] == 0) {
244 s->dialog_normalization[(!s->channel_mode)-i] = -31;
246 if (s->target_level != 0) {
247 s->level_gain[(!s->channel_mode)-i] =
powf(2.0
f,
248 (
float)(s->target_level -
249 s->dialog_normalization[(!s->channel_mode)-i])/6.0f);
251 if (s->compression_exists[(!s->channel_mode)-
i] =
get_bits1(gbc)) {
252 s->heavy_dynamic_range[(!s->channel_mode)-i] =
264 if (s->bitstream_id != 6) {
271 s->preferred_downmix =
get_bits(gbc, 2);
272 s->center_mix_level_ltrt =
get_bits(gbc, 3);
273 s->surround_mix_level_ltrt = av_clip(
get_bits(gbc, 3), 3, 7);
274 s->center_mix_level =
get_bits(gbc, 3);
275 s->surround_mix_level = av_clip(
get_bits(gbc, 3), 3, 7);
278 s->dolby_surround_ex_mode =
get_bits(gbc, 2);
279 s->dolby_headphone_mode =
get_bits(gbc, 2);
308 s->bit_alloc_params.sr_code = hdr.
sr_code;
313 s->bit_alloc_params.sr_shift = hdr.
sr_shift;
317 s->fbw_channels = s->channels - s->lfe_on;
318 s->lfe_ch = s->fbw_channels + 1;
323 s->center_mix_level_ltrt = 4;
325 s->surround_mix_level_ltrt = 4;
326 s->lfe_mix_level_exists = 0;
335 s->start_freq[s->lfe_ch] = 0;
336 s->end_freq[s->lfe_ch] = 7;
337 s->num_exp_groups[s->lfe_ch] = 2;
338 s->channel_in_cpl[s->lfe_ch] = 0;
341 if (s->bitstream_id <= 10) {
343 s->snr_offset_strategy = 2;
344 s->block_switch_syntax = 1;
345 s->dither_flag_syntax = 1;
346 s->bit_allocation_syntax = 1;
347 s->fast_gain_syntax = 0;
348 s->first_cpl_leak = 0;
351 memset(s->channel_uses_aht, 0,
sizeof(s->channel_uses_aht));
374 if (!s->downmix_coeffs[0]) {
376 sizeof(**s->downmix_coeffs));
377 if (!s->downmix_coeffs[0])
382 for (i = 0; i < s->fbw_channels; i++) {
384 downmix_coeffs[1][
i] =
gain_levels[ac3_default_coeffs[s->channel_mode][
i][1]];
386 if (s->channel_mode > 1 && s->channel_mode & 1) {
387 downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
390 int nf = s->channel_mode - 2;
391 downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix *
LEVEL_MINUS_3DB;
394 int nf = s->channel_mode - 4;
395 downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
400 for (i = 0; i < s->fbw_channels; i++) {
401 norm0 += downmix_coeffs[0][
i];
402 norm1 += downmix_coeffs[1][
i];
404 norm0 = 1.0f / norm0;
405 norm1 = 1.0f / norm1;
406 for (i = 0; i < s->fbw_channels; i++) {
407 downmix_coeffs[0][
i] *= norm0;
408 downmix_coeffs[1][
i] *= norm1;
412 for (i = 0; i < s->fbw_channels; i++)
413 downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
416 for (i = 0; i < s->fbw_channels; i++) {
417 s->downmix_coeffs[0][
i] =
FIXR12(downmix_coeffs[0][i]);
418 s->downmix_coeffs[1][
i] =
FIXR12(downmix_coeffs[1][i]);
432 int i, j, grp, group_size;
437 group_size = exp_strategy + (exp_strategy ==
EXP_D45);
438 for (grp = 0, i = 0; grp < ngrps; grp++) {
451 for (i = 0, j = 0; i < ngrps * 3; i++) {
452 prevexp += dexp[
i] - 2;
457 switch (group_size) {
458 case 4: dexps[j++] = prevexp;
459 dexps[j++] = prevexp;
460 case 2: dexps[j++] = prevexp;
461 case 1: dexps[j++] = prevexp;
476 bin = s->start_freq[
CPL_CH];
477 for (band = 0; band < s->num_cpl_bands; band++) {
478 int band_start = bin;
479 int band_end = bin + s->cpl_band_sizes[band];
480 for (ch = 1; ch <= s->fbw_channels; ch++) {
481 if (s->channel_in_cpl[ch]) {
482 int cpl_coord = s->cpl_coords[ch][band] << 5;
483 for (bin = band_start; bin < band_end; bin++) {
484 s->fixed_coeffs[ch][bin] =
485 MULH(s->fixed_coeffs[
CPL_CH][bin] * (1 << 4), cpl_coord);
487 if (ch == 2 && s->phase_flags[band]) {
488 for (bin = band_start; bin < band_end; bin++)
489 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
515 int start_freq = s->start_freq[ch_index];
516 int end_freq = s->end_freq[ch_index];
517 uint8_t *baps = s->bap[ch_index];
518 int8_t *exps = s->dexps[ch_index];
519 int32_t *coeffs = s->fixed_coeffs[ch_index];
520 int dither = (ch_index ==
CPL_CH) || s->dither_flag[ch_index];
524 for (freq = start_freq; freq < end_freq; freq++) {
525 int bap = baps[freq];
531 mantissa = (((
av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
585 coeffs[freq] = mantissa >> exps[freq];
597 for (ch = 1; ch <= s->fbw_channels; ch++) {
598 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
599 for (i = s->start_freq[
CPL_CH]; i < s->end_freq[
CPL_CH]; i++) {
601 s->fixed_coeffs[ch][
i] = 0;
610 if (!s->channel_uses_aht[ch]) {
618 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
619 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][
blk] >> s->dexps[ch][bin];
635 for (ch = 1; ch <= s->channels; ch++) {
640 if (s->channel_in_cpl[ch]) {
646 end = s->end_freq[
CPL_CH];
648 end = s->end_freq[ch];
651 s->fixed_coeffs[ch][
end] = 0;
668 end =
FFMIN(s->end_freq[1], s->end_freq[2]);
670 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
671 if (s->rematrixing_flags[bnd]) {
674 int tmp0 = s->fixed_coeffs[1][
i];
675 s->fixed_coeffs[1][
i] += s->fixed_coeffs[2][
i];
676 s->fixed_coeffs[2][
i] = tmp0 - s->fixed_coeffs[2][
i];
691 for (ch = 1; ch <=
channels; ch++) {
692 if (s->block_switch[ch]) {
695 for (i = 0; i < 128; i++)
696 x[i] = s->transform_coeffs[ch][2 * i];
697 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
699 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
700 s->tmp_output, s->window, 128, 8);
702 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
703 s->tmp_output, s->window, 128);
705 for (i = 0; i < 128; i++)
706 x[i] = s->transform_coeffs[ch][2 * i + 1];
707 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1 + offset], x);
709 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
711 s->fdsp->vector_fmul_window_scaled(s->outptr[ch - 1], s->delay[ch - 1 + offset],
712 s->tmp_output, s->window, 128, 8);
714 s->fdsp->vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1 + offset],
715 s->tmp_output, s->window, 128);
717 memcpy(s->delay[ch - 1 + offset], s->tmp_output + 128, 128 *
sizeof(
FFTSample));
727 int channel_data_size =
sizeof(s->delay[0]);
728 switch (s->channel_mode) {
732 memcpy(s->delay[1], s->delay[0], channel_data_size);
735 memset(s->delay[3], 0, channel_data_size);
737 memset(s->delay[2], 0, channel_data_size);
740 memset(s->delay[4], 0, channel_data_size);
742 memset(s->delay[3], 0, channel_data_size);
744 memcpy(s->delay[2], s->delay[1], channel_data_size);
745 memset(s->delay[1], 0, channel_data_size);
768 int ecpl,
int start_subband,
int end_subband,
769 const uint8_t *default_band_struct,
770 int *num_bands,
uint8_t *band_sizes,
771 uint8_t *band_struct,
int band_struct_size)
773 int subbnd, bnd, n_subbands, n_bands=0;
776 n_subbands = end_subband - start_subband;
779 memcpy(band_struct, default_band_struct, band_struct_size);
781 av_assert0(band_struct_size >= start_subband + n_subbands);
783 band_struct += start_subband + 1;
787 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
795 if (num_bands || band_sizes ) {
796 n_bands = n_subbands;
797 bnd_sz[0] = ecpl ? 6 : 12;
798 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
799 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
800 if (band_struct[subbnd - 1]) {
802 bnd_sz[bnd] += subbnd_size;
804 bnd_sz[++bnd] = subbnd_size;
811 *num_bands = n_bands;
813 memcpy(band_sizes, bnd_sz, n_bands);
819 int fbw_channels = s->fbw_channels;
820 int dst_start_freq, dst_end_freq, src_start_freq,
821 start_subband, end_subband, ch;
825 s->channel_uses_spx[1] = 1;
827 for (ch = 1; ch <= fbw_channels; ch++)
834 start_subband =
get_bits(bc, 3) + 2;
835 if (start_subband > 7)
836 start_subband += start_subband - 7;
842 end_subband += end_subband - 7;
843 dst_start_freq = dst_start_freq * 12 + 25;
844 src_start_freq = start_subband * 12 + 25;
845 dst_end_freq = end_subband * 12 + 25;
848 if (start_subband >= end_subband) {
850 "range (%d >= %d)\n", start_subband, end_subband);
853 if (dst_start_freq >= src_start_freq) {
855 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
859 s->spx_dst_start_freq = dst_start_freq;
860 s->spx_src_start_freq = src_start_freq;
862 s->spx_dst_end_freq = dst_end_freq;
865 start_subband, end_subband,
869 s->spx_band_struct,
sizeof(s->spx_band_struct));
876 int fbw_channels = s->fbw_channels;
879 for (ch = 1; ch <= fbw_channels; ch++) {
880 if (s->channel_uses_spx[ch]) {
881 if (s->first_spx_coords[ch] ||
get_bits1(bc)) {
883 int bin, master_spx_coord;
885 s->first_spx_coords[ch] = 0;
887 master_spx_coord =
get_bits(bc, 2) * 3;
889 bin = s->spx_src_start_freq;
890 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
891 int bandsize = s->spx_band_sizes[bnd];
892 int spx_coord_exp, spx_coord_mant;
896 int64_t accu = ((bin << 23) + (bandsize << 22))
897 * (
int64_t)s->spx_dst_end_freq;
898 nratio = (
int)(accu >> 32);
899 nratio -= spx_blend << 18;
904 }
else if (nratio > 0x7fffff) {
909 accu = (
int64_t)nblend * 1859775393;
910 nblend = (
int)((accu + (1<<29)) >> 30);
917 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
918 nratio = av_clipf(nratio, 0.0
f, 1.0
f);
919 nblend = sqrtf(3.0
f * nratio);
921 sblend = sqrtf(1.0
f - nratio);
928 if (spx_coord_exp == 15) spx_coord_mant <<= 1;
929 else spx_coord_mant += 4;
930 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
934 accu = (
int64_t)nblend * spx_coord_mant;
935 s->spx_noise_blend[ch][bnd] = (
int)((accu + (1<<22)) >> 23);
936 accu = (
int64_t)sblend * spx_coord_mant;
937 s->spx_signal_blend[ch][bnd] = (
int)((accu + (1<<22)) >> 23);
939 spx_coord = spx_coord_mant * (1.0f / (1 << 23));
940 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
941 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
946 s->first_spx_coords[ch] = 1;
955 int fbw_channels = s->fbw_channels;
956 int channel_mode = s->channel_mode;
962 if (s->cpl_in_use[blk]) {
964 int cpl_start_subband, cpl_end_subband;
980 s->channel_in_cpl[1] = 1;
981 s->channel_in_cpl[2] = 1;
983 for (ch = 1; ch <= fbw_channels; ch++)
992 cpl_start_subband =
get_bits(bc, 4);
993 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
995 if (cpl_start_subband >= cpl_end_subband) {
997 cpl_start_subband, cpl_end_subband);
1000 s->start_freq[
CPL_CH] = cpl_start_subband * 12 + 37;
1001 s->end_freq[
CPL_CH] = cpl_end_subband * 12 + 37;
1006 &s->num_cpl_bands, s->cpl_band_sizes,
1007 s->cpl_band_struct,
sizeof(s->cpl_band_struct));
1010 for (ch = 1; ch <= fbw_channels; ch++) {
1011 s->channel_in_cpl[ch] = 0;
1012 s->first_cpl_coords[ch] = 1;
1014 s->first_cpl_leak = s->eac3;
1015 s->phase_flags_in_use = 0;
1024 int fbw_channels = s->fbw_channels;
1026 int cpl_coords_exist = 0;
1028 for (ch = 1; ch <= fbw_channels; ch++) {
1029 if (s->channel_in_cpl[ch]) {
1030 if ((s->eac3 && s->first_cpl_coords[ch]) ||
get_bits1(bc)) {
1031 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
1032 s->first_cpl_coords[ch] = 0;
1033 cpl_coords_exist = 1;
1034 master_cpl_coord = 3 *
get_bits(bc, 2);
1035 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1038 if (cpl_coord_exp == 15)
1039 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
1041 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
1042 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
1046 "be present in block 0\n");
1051 s->first_cpl_coords[ch] = 1;
1056 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1057 s->phase_flags[bnd] = s->phase_flags_in_use ?
get_bits1(bc) : 0;
1069 int fbw_channels = s->fbw_channels;
1070 int channel_mode = s->channel_mode;
1071 int i, bnd, seg, ch, ret;
1072 int different_transforms;
1079 different_transforms = 0;
1080 if (s->block_switch_syntax) {
1081 for (ch = 1; ch <= fbw_channels; ch++) {
1083 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
1084 different_transforms = 1;
1089 if (s->dither_flag_syntax) {
1090 for (ch = 1; ch <= fbw_channels; ch++) {
1096 i = !s->channel_mode;
1103 if (range_bits <= 127 || s->drc_scale <= 1.0)
1106 s->dynamic_range[
i] = range;
1107 }
else if (blk == 0) {
1113 if (s->eac3 && (!blk ||
get_bits1(gbc))) {
1115 if (s->spx_in_use) {
1120 if (!s->eac3 || !s->spx_in_use) {
1122 for (ch = 1; ch <= fbw_channels; ch++) {
1123 s->channel_uses_spx[ch] = 0;
1124 s->first_spx_coords[ch] = 1;
1133 if (s->eac3 ? s->cpl_strategy_exists[blk] :
get_bits1(gbc)) {
1136 }
else if (!s->eac3) {
1139 "be present in block 0\n");
1142 s->cpl_in_use[
blk] = s->cpl_in_use[blk-1];
1145 cpl_in_use = s->cpl_in_use[
blk];
1155 if ((s->eac3 && !blk) ||
get_bits1(gbc)) {
1156 s->num_rematrixing_bands = 4;
1157 if (cpl_in_use && s->start_freq[
CPL_CH] <= 61) {
1158 s->num_rematrixing_bands -= 1 + (s->start_freq[
CPL_CH] == 37);
1159 }
else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1160 s->num_rematrixing_bands--;
1162 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1163 s->rematrixing_flags[bnd] =
get_bits1(gbc);
1166 "new rematrixing strategy not present in block 0\n");
1167 s->num_rematrixing_bands = 0;
1172 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1174 s->exp_strategy[
blk][ch] =
get_bits(gbc, 2 - (ch == s->lfe_ch));
1175 if (s->exp_strategy[blk][ch] !=
EXP_REUSE)
1176 bit_alloc_stages[ch] = 3;
1180 for (ch = 1; ch <= fbw_channels; ch++) {
1181 s->start_freq[ch] = 0;
1182 if (s->exp_strategy[blk][ch] !=
EXP_REUSE) {
1184 int prev = s->end_freq[ch];
1185 if (s->channel_in_cpl[ch])
1186 s->end_freq[ch] = s->start_freq[
CPL_CH];
1187 else if (s->channel_uses_spx[ch])
1188 s->end_freq[ch] = s->spx_src_start_freq;
1190 int bandwidth_code =
get_bits(gbc, 6);
1191 if (bandwidth_code > 60) {
1195 s->end_freq[ch] = bandwidth_code * 3 + 73;
1197 group_size = 3 << (s->exp_strategy[
blk][ch] - 1);
1198 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1199 if (blk > 0 && s->end_freq[ch] != prev)
1205 (3 << (s->exp_strategy[blk][
CPL_CH] - 1));
1209 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1210 if (s->exp_strategy[blk][ch] !=
EXP_REUSE) {
1211 s->dexps[ch][0] =
get_bits(gbc, 4) << !ch;
1213 s->num_exp_groups[ch], s->dexps[ch][0],
1214 &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1217 if (ch !=
CPL_CH && ch != s->lfe_ch)
1223 if (s->bit_allocation_syntax) {
1230 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1231 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1234 "be present in block 0\n");
1240 if (!s->eac3 || !blk) {
1241 if (s->snr_offset_strategy &&
get_bits1(gbc)) {
1244 csnr = (
get_bits(gbc, 6) - 15) << 4;
1245 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1247 if (ch == i || s->snr_offset_strategy == 2)
1248 snr = (csnr +
get_bits(gbc, 4)) << 2;
1250 if (blk && s->snr_offset[ch] != snr) {
1251 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 1);
1253 s->snr_offset[ch] = snr;
1257 int prev = s->fast_gain[ch];
1260 if (blk && prev != s->fast_gain[ch])
1261 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1264 }
else if (!s->eac3 && !blk) {
1271 if (s->fast_gain_syntax &&
get_bits1(gbc)) {
1272 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1273 int prev = s->fast_gain[ch];
1276 if (blk && prev != s->fast_gain[ch])
1277 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1279 }
else if (s->eac3 && !blk) {
1280 for (ch = !cpl_in_use; ch <= s->channels; ch++)
1291 if (s->first_cpl_leak ||
get_bits1(gbc)) {
1296 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1297 sl != s->bit_alloc_params.cpl_slow_leak)) {
1300 s->bit_alloc_params.cpl_fast_leak = fl;
1301 s->bit_alloc_params.cpl_slow_leak = sl;
1302 }
else if (!s->eac3 && !blk) {
1304 "be present in block 0\n");
1307 s->first_cpl_leak = 0;
1313 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1314 s->dba_mode[ch] =
get_bits(gbc, 2);
1319 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1322 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1323 if (s->dba_mode[ch] ==
DBA_NEW) {
1324 s->dba_nsegs[ch] =
get_bits(gbc, 3) + 1;
1325 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1326 s->dba_offsets[ch][seg] =
get_bits(gbc, 5);
1327 s->dba_lengths[ch][seg] =
get_bits(gbc, 4);
1328 s->dba_values[ch][seg] =
get_bits(gbc, 3);
1331 bit_alloc_stages[ch] =
FFMAX(bit_alloc_stages[ch], 2);
1334 }
else if (blk == 0) {
1335 for (ch = 0; ch <= s->channels; ch++) {
1341 for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1342 if (bit_alloc_stages[ch] > 2) {
1345 s->start_freq[ch], s->end_freq[ch],
1346 s->psd[ch], s->band_psd[ch]);
1348 if (bit_alloc_stages[ch] > 1) {
1352 s->start_freq[ch], s->end_freq[ch],
1353 s->fast_gain[ch], (ch == s->lfe_ch),
1354 s->dba_mode[ch], s->dba_nsegs[ch],
1355 s->dba_offsets[ch], s->dba_lengths[ch],
1356 s->dba_values[ch], s->mask[ch])) {
1361 if (bit_alloc_stages[ch] > 0) {
1365 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1366 s->start_freq[ch], s->end_freq[ch],
1368 s->bit_alloc_params.floor,
1369 bap_tab, s->bap[ch]);
1390 for (ch = 1; ch <= s->channels; ch++) {
1391 int audio_channel = 0;
1394 audio_channel = 2-ch;
1395 if (s->heavy_compression && s->compression_exists[audio_channel])
1396 gain = s->heavy_dynamic_range[audio_channel];
1398 gain = s->dynamic_range[audio_channel];
1401 scale_coefs(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1403 if (s->target_level != 0)
1404 gain = gain * s->level_gain[audio_channel];
1405 gain *= 1.0 / 4194304.0f;
1406 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1407 s->fixed_coeffs[ch], gain, 256);
1419 downmix_output = s->channels != s->out_channels &&
1420 !((s->output_mode & AC3_OUTPUT_LFEON) &&
1421 s->fbw_channels == s->out_channels);
1422 if (different_transforms) {
1432 if (downmix_output) {
1435 s->out_channels, s->fbw_channels, 256);
1438 s->out_channels, s->fbw_channels, 256);
1442 if (downmix_output) {
1444 s->out_channels, s->fbw_channels, 256);
1447 if (downmix_output && !s->downmixed) {
1450 s->out_channels, s->fbw_channels, 128);
1453 do_imdct(s, s->out_channels, offset);
1463 int *got_frame_ptr,
AVPacket *avpkt)
1467 int buf_size, full_buf_size = avpkt->
size;
1471 int skip = 0, got_independent_frame = 0;
1478 s->superframe_size = 0;
1480 buf_size = full_buf_size;
1481 for (i = 1; i < buf_size; i += 2) {
1482 if (buf[i] == 0x77 || buf[i] == 0x0B) {
1483 if ((buf[i] ^ buf[i-1]) == (0x77 ^ 0x0B)) {
1486 }
else if ((buf[i] ^ buf[i+1]) == (0x77 ^ 0x0B)) {
1500 if (buf_size >= 2 &&
AV_RB16(buf) == 0x770B) {
1502 int cnt =
FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1503 s->bdsp.bswap16_buf((uint16_t *) s->input_buffer,
1504 (
const uint16_t *) buf, cnt);
1506 memcpy(s->input_buffer, buf,
FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1511 if (s->consistent_noise_generation)
1514 buf = s->input_buffer;
1540 if (s->substreamid) {
1542 "unsupported substream %d: skipping frame\n",
1559 if (s->frame_size > buf_size) {
1565 s->frame_size - 2)) {
1577 return FFMIN(full_buf_size, s->frame_size);
1581 if (!err || (s->channels && s->out_channels != s->channels)) {
1582 s->out_channels = s->channels;
1583 s->output_mode = s->channel_mode;
1585 s->output_mode |= AC3_OUTPUT_LFEON;
1586 if (s->channels > 1 &&
1588 s->out_channels = 1;
1590 }
else if (s->channels > 2 &&
1592 s->out_channels = 2;
1596 s->loro_center_mix_level =
gain_levels[s-> center_mix_level];
1597 s->loro_surround_mix_level =
gain_levels[s->surround_mix_level];
1601 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1602 s->fbw_channels == s->out_channels)) {
1608 }
else if (!s->channels) {
1614 if (s->output_mode & AC3_OUTPUT_LFEON)
1619 if (s->bitstream_mode == 0x7 && s->channels > 1)
1626 output[ch] = s->output[ch +
offset];
1627 s->outptr[ch] = s->output[ch +
offset];
1629 for (ch = 0; ch < s->channels; ch++) {
1630 if (ch < s->out_channels)
1631 s->outptr[channel_map[ch]] = s->output_buffer[ch +
offset];
1633 for (blk = 0; blk < s->num_blocks; blk++) {
1639 for (ch = 0; ch < s->out_channels; ch++)
1641 for (ch = 0; ch < s->out_channels; ch++)
1642 output[ch] = s->outptr[channel_map[ch]];
1643 for (ch = 0; ch < s->out_channels; ch++) {
1644 if (!ch || channel_map[ch])
1650 for (ch = 0; ch < s->out_channels; ch++)
1654 if (buf_size > s->frame_size) {
1658 if (buf_size - s->frame_size <= 16) {
1663 if ((ret =
init_get_bits8(&s->gbc, buf + s->frame_size, buf_size - s->frame_size)) < 0)
1674 buf += s->frame_size;
1675 buf_size -= s->frame_size;
1676 s->prev_output_mode = s->output_mode;
1677 s->prev_bit_rate = s->bit_rate;
1678 got_independent_frame = 1;
1679 goto dependent_frame;
1690 avctx->
bit_rate = s->bit_rate + s->prev_bit_rate;
1694 extended_channel_map[ch] = ch;
1698 int channel_map_size =
ff_ac3_channels_tab[s->output_mode & ~AC3_OUTPUT_LFEON] + s->lfe_on;
1699 uint64_t channel_layout;
1702 if (s->prev_output_mode & AC3_OUTPUT_LFEON)
1705 channel_layout = ich_layout;
1706 for (ch = 0; ch < 16; ch++) {
1707 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1721 if (s->channel_map & (1 << (EAC3_MAX_CHANNELS - ch - 1))) {
1727 if (extend >= channel_map_size)
1730 extended_channel_map[
index] = offset + channel_map[extend++];
1734 for (i = 0; i < 64; i++) {
1740 if (extend >= channel_map_size)
1743 extended_channel_map[
index] = offset + channel_map[extend++];
1756 for (ch = 0; ch < avctx->
channels; ch++) {
1757 int map = extended_channel_map[ch];
1760 s->output_buffer[map],
1772 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1778 s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1779 switch (s->dolby_surround_ex_mode) {
1795 switch (s->preferred_downmix) {
1813 if (s->lfe_mix_level_exists)
1822 if (!s->superframe_size)
1823 return FFMIN(full_buf_size, s->frame_size + skip);
1825 return FFMIN(full_buf_size, s->superframe_size + skip);
1842 #define OFFSET(x) offsetof(AC3DecodeContext, x) 1843 #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.
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 CONFIG_EAC3_DECODER
#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]
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
static av_cold int end(AVCodecContext *avctx)
static av_cold int ac3_decode_end(AVCodecContext *avctx)
Uninitialize the AC-3 decoder.
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 i(width, name, range_min, range_max)
#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 const uint8_t offset[127][2]
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.
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)
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 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]
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.