65 7, 10, 12, 13, 15, 17, 19
127 s->crc_present =
h.crc_present;
128 s->npcmblocks =
h.npcmblocks;
129 s->frame_size =
h.frame_size;
130 s->audio_mode =
h.audio_mode;
133 s->drc_present =
h.drc_present;
134 s->ts_present =
h.ts_present;
135 s->aux_present =
h.aux_present;
136 s->ext_audio_type =
h.ext_audio_type;
137 s->ext_audio_present =
h.ext_audio_present;
138 s->sync_ssf =
h.sync_ssf;
139 s->lfe_present =
h.lfe_present;
140 s->predictor_history =
h.predictor_history;
141 s->filter_perfect =
h.filter_perfect;
143 s->es_format =
h.pcmr_code & 1;
144 s->sumdiff_front =
h.sumdiff_front;
145 s->sumdiff_surround =
h.sumdiff_surround;
153 int n, ch, nchannels, header_size = 0, header_pos =
get_bits_count(&
s->gb);
167 av_log(
s->avctx,
AV_LOG_ERROR,
"Invalid number of primary audio channels (%d) for audio channel arrangement (%d)\n",
s->nchannels,
s->audio_mode);
190 if (
s->xxch_crc_present
209 if (av_popcount(
s->xxch_spkr_mask) != nchannels) {
214 if (
s->xxch_core_mask &
s->xxch_spkr_mask) {
215 av_log(
s->avctx,
AV_LOG_ERROR,
"XXCH speaker layout mask (%#x) overlaps with core (%#x)\n",
s->xxch_spkr_mask,
s->xxch_core_mask);
220 s->ch_mask =
s->xxch_core_mask |
s->xxch_spkr_mask;
224 int *coeff_ptr =
s->xxch_dmix_coeff;
238 for (ch = 0; ch < nchannels; ch++) {
240 if ((
mask &
s->xxch_core_mask) !=
mask) {
244 s->xxch_dmix_mask[ch] =
mask;
248 for (ch = 0; ch < nchannels; ch++) {
249 for (n = 0; n <
s->xxch_mask_nbits; n++) {
250 if (
s->xxch_dmix_mask[ch] & (1
U << n)) {
252 int sign = (
code >> 6) - 1;
267 s->xxch_dmix_embedded = 0;
274 for (ch = xch_base; ch <
s->nchannels; ch++) {
283 for (ch = xch_base; ch <
s->nchannels; ch++)
284 s->subband_vq_start[ch] =
get_bits(&
s->gb, 5) + 1;
287 for (ch = xch_base; ch <
s->nchannels; ch++) {
290 if (n >
s->nchannels) {
294 s->joint_intensity_index[ch] = n;
298 for (ch = xch_base; ch <
s->nchannels; ch++)
299 s->transition_mode_sel[ch] =
get_bits(&
s->gb, 2);
302 for (ch = xch_base; ch <
s->nchannels; ch++) {
303 s->scale_factor_sel[ch] =
get_bits(&
s->gb, 3);
304 if (
s->scale_factor_sel[ch] == 7) {
311 for (ch = xch_base; ch <
s->nchannels; ch++) {
312 s->bit_allocation_sel[ch] =
get_bits(&
s->gb, 3);
313 if (
s->bit_allocation_sel[ch] == 7) {
321 for (ch = xch_base; ch <
s->nchannels; ch++)
326 for (ch = xch_base; ch <
s->nchannels; ch++)
350 unsigned int scale_size;
365 *scale_index =
get_bits(&
s->gb, sel + 1);
368 if ((
unsigned int)*scale_index >= scale_size) {
409 s->nsubsubframes[sf] =
get_bits(&
s->gb, 2) + 1;
416 for (ch = xch_base; ch <
s->nchannels; ch++)
417 for (band = 0; band <
s->nsubbands[ch]; band++)
421 for (ch = xch_base; ch <
s->nchannels; ch++)
422 for (band = 0; band <
s->nsubbands[ch]; band++)
423 if (
s->prediction_mode[ch][band])
424 s->prediction_vq_index[ch][band] =
get_bits(&
s->gb, 12);
427 for (ch = xch_base; ch <
s->nchannels; ch++) {
428 int sel =
s->bit_allocation_sel[ch];
430 for (band = 0; band <
s->subband_vq_start[ch]; band++) {
443 s->bit_allocation[ch][band] = abits;
448 for (ch = xch_base; ch <
s->nchannels; ch++) {
450 memset(
s->transition_mode[sf][ch], 0,
sizeof(
s->transition_mode[0][0]));
453 if (
s->nsubsubframes[sf] > 1) {
454 int sel =
s->transition_mode_sel[ch];
455 for (band = 0; band <
s->subband_vq_start[ch]; band++)
456 if (
s->bit_allocation[ch][band])
462 for (ch = xch_base; ch <
s->nchannels; ch++) {
463 int sel =
s->scale_factor_sel[ch];
467 for (band = 0; band <
s->subband_vq_start[ch]; band++) {
468 if (
s->bit_allocation[ch][band]) {
471 s->scale_factors[ch][band][0] =
ret;
472 if (
s->transition_mode[sf][ch][band]) {
475 s->scale_factors[ch][band][1] =
ret;
478 s->scale_factors[ch][band][0] = 0;
483 for (band =
s->subband_vq_start[ch]; band < s->nsubbands[ch]; band++) {
486 s->scale_factors[ch][band][0] =
ret;
491 for (ch = xch_base; ch <
s->nchannels; ch++) {
492 if (
s->joint_intensity_index[ch]) {
494 if (
s->joint_scale_sel[ch] == 7) {
502 for (ch = xch_base; ch <
s->nchannels; ch++) {
503 int src_ch =
s->joint_intensity_index[ch] - 1;
505 int sel =
s->joint_scale_sel[ch];
506 for (band =
s->nsubbands[ch]; band < s->nsubbands[src_ch]; band++) {
509 s->joint_scale_factors[ch][band] =
ret;
525 #ifndef decode_blockcodes
528 int offset = (levels - 1) / 2;
533 audio[n] = code1 - div * levels -
offset;
538 audio[n] = code2 - div * levels -
offset;
542 return code1 | code2;
584 int sel =
s->quant_index_sel[ch][abits - 1];
601 const int16_t *vq_index,
602 const int8_t *prediction_mode,
603 int sb_start,
int sb_end,
608 for (
i = sb_start;
i < sb_end;
i++) {
609 if (prediction_mode[
i]) {
610 const int pred_id = vq_index[
i];
611 int32_t *ptr = subband_samples[
i] + ofs;
612 for (j = 0; j <
len; j++) {
614 ptr[j] =
clip23(ptr[j] + x);
622 int xch_base,
int *sub_pos,
int *lfe_pos)
625 int n, ssf, ofs, ch, band;
629 if (*sub_pos + nsamples >
s->npcmblocks) {
638 for (ch = xch_base; ch <
s->nchannels; ch++) {
641 for (band =
s->subband_vq_start[ch]; band < s->nsubbands[ch]; band++)
645 if (
s->subband_vq_start[ch] <
s->nsubbands[ch]) {
646 s->dcadsp->decode_hf(
s->subband_samples[ch], vq_index,
648 s->subband_vq_start[ch],
s->nsubbands[ch],
658 int nlfesamples = 2 *
s->lfe_present *
s->nsubsubframes[sf];
675 scale =
mul23(4697620 , scale);
678 for (n = 0, ofs = *lfe_pos; n < nlfesamples; n++, ofs++)
679 s->lfe_samples[ofs] =
clip23(audio[n] * scale >> 4);
686 for (ssf = 0, ofs = *sub_pos; ssf <
s->nsubsubframes[sf]; ssf++) {
687 for (ch = xch_base; ch <
s->nchannels; ch++) {
692 for (band = 0; band <
s->subband_vq_start[ch]; band++) {
693 int ret, trans_ssf, abits =
s->bit_allocation[ch][band];
702 if (
s->bit_rate == 3)
708 trans_ssf =
s->transition_mode[sf][ch][band];
711 if (trans_ssf == 0 || ssf < trans_ssf)
712 scale =
s->scale_factors[ch][band][0];
714 scale =
s->scale_factors[ch][band][1];
718 int64_t adj =
s->scale_factor_adj[ch][abits - 1];
719 scale =
clip23(adj * scale >> 22);
728 if ((ssf ==
s->nsubsubframes[sf] - 1 ||
s->sync_ssf) &&
get_bits(&
s->gb, 16) != 0xffff) {
737 for (ch = xch_base; ch <
s->nchannels; ch++) {
739 s->prediction_mode[ch], 0,
s->nsubbands[ch],
744 for (ch = xch_base; ch <
s->nchannels; ch++) {
745 int src_ch =
s->joint_intensity_index[ch] - 1;
747 s->dcadsp->decode_joint(
s->subband_samples[ch],
s->subband_samples[src_ch],
748 s->joint_scale_factors[ch],
s->nsubbands[ch],
749 s->nsubbands[src_ch], *sub_pos, nsamples);
776 unsigned int size =
s->subband_size;
781 (nframesamples + nlfesamples) *
sizeof(
int32_t));
782 if (!
s->subband_buffer)
785 if (
size !=
s->subband_size) {
788 s->subband_samples[ch][band] =
s->subband_buffer +
790 s->lfe_samples =
s->subband_buffer + nframesamples;
793 if (!
s->predictor_history)
801 int sf, ch,
ret, band, sub_pos, lfe_pos;
806 for (sf = 0, sub_pos = 0, lfe_pos =
DCA_LFE_HISTORY; sf <
s->nsubframes; sf++) {
813 for (ch = xch_base; ch <
s->nchannels; ch++) {
815 int nsubbands =
s->nsubbands[ch];
816 if (
s->joint_intensity_index[ch])
817 nsubbands =
FFMAX(nsubbands,
s->nsubbands[
s->joint_intensity_index[ch] - 1]);
820 for (band = 0; band < nsubbands; band++) {
860 int xxch_nchsets, xxch_frame_size;
873 if (
ff_dca_check_crc(
s->avctx, &
s->gb, header_pos + 32, header_pos + header_size * 8)) {
884 av_log(
s->avctx,
AV_LOG_ERROR,
"Invalid number of bits for XXCH speaker mask (%d)\n",
s->xxch_mask_nbits);
890 if (xxch_nchsets > 1) {
896 xxch_frame_size =
get_bits(&
s->gb, 14) + 1;
910 if (
mask !=
s->xxch_core_mask) {
911 av_log(
s->avctx,
AV_LOG_ERROR,
"XXCH core speaker activity mask (%#x) disagrees with core (%#x)\n",
s->xxch_core_mask,
mask);
927 if (
ff_dca_seek_bits(&
s->gb, header_pos + header_size * 8 + xxch_frame_size * 8)) {
936 int *xbr_nsubbands,
int xbr_transition_mode,
int sf,
int *sub_pos)
942 int ssf, ch, band, ofs;
954 for (ch = xbr_base_ch; ch < xbr_nchannels; ch++)
955 xbr_nabits[ch] =
get_bits(&
s->gb, 2) + 2;
958 for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
959 for (band = 0; band < xbr_nsubbands[ch]; band++) {
960 xbr_bit_allocation[ch][band] =
get_bits(&
s->gb, xbr_nabits[ch]);
969 for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
970 xbr_scale_nbits[ch] =
get_bits(&
s->gb, 3);
971 if (!xbr_scale_nbits[ch]) {
978 for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
983 if (
s->scale_factor_sel[ch] > 5) {
993 for (band = 0; band < xbr_nsubbands[ch]; band++) {
994 if (xbr_bit_allocation[ch][band]) {
995 int scale_index =
get_bits(&
s->gb, xbr_scale_nbits[ch]);
996 if (scale_index >= scale_size) {
1000 xbr_scale_factors[ch][band][0] =
scale_table[scale_index];
1001 if (xbr_transition_mode &&
s->transition_mode[sf][ch][band]) {
1002 scale_index =
get_bits(&
s->gb, xbr_scale_nbits[ch]);
1003 if (scale_index >= scale_size) {
1007 xbr_scale_factors[ch][band][1] =
scale_table[scale_index];
1014 for (ssf = 0, ofs = *sub_pos; ssf <
s->nsubsubframes[sf]; ssf++) {
1015 for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
1019 for (band = 0; band < xbr_nsubbands[ch]; band++) {
1020 int ret, trans_ssf, abits = xbr_bit_allocation[ch][band];
1027 }
else if (abits > 0) {
1040 if (xbr_transition_mode)
1041 trans_ssf =
s->transition_mode[sf][ch][band];
1046 if (trans_ssf == 0 || ssf < trans_ssf)
1047 scale = xbr_scale_factors[ch][band][0];
1049 scale = xbr_scale_factors[ch][band][1];
1057 if ((ssf ==
s->nsubsubframes[sf] - 1 ||
s->sync_ssf) &&
get_bits(&
s->gb, 16) != 0xffff) {
1075 int xbr_nchsets, xbr_transition_mode, xbr_band_nbits, xbr_base_ch;
1088 if (
ff_dca_check_crc(
s->avctx, &
s->gb, header_pos + 32, header_pos + header_size * 8)) {
1097 for (
i = 0;
i < xbr_nchsets;
i++)
1098 xbr_frame_size[
i] =
get_bits(&
s->gb, 14) + 1;
1104 for (
i = 0, ch2 = 0;
i < xbr_nchsets;
i++) {
1106 xbr_band_nbits =
get_bits(&
s->gb, 2) + 5;
1107 for (ch1 = 0; ch1 < xbr_nchannels[
i]; ch1++, ch2++) {
1108 xbr_nsubbands[ch2] =
get_bits(&
s->gb, xbr_band_nbits) + 1;
1110 av_log(
s->avctx,
AV_LOG_ERROR,
"Invalid number of active XBR subbands (%d)\n", xbr_nsubbands[ch2]);
1125 for (
i = 0, xbr_base_ch = 0;
i < xbr_nchsets;
i++) {
1128 if (xbr_base_ch + xbr_nchannels[
i] <=
s->nchannels) {
1131 for (sf = 0, sub_pos = 0; sf <
s->nsubframes; sf++) {
1133 xbr_base_ch + xbr_nchannels[
i],
1134 xbr_nsubbands, xbr_transition_mode,
1140 xbr_base_ch += xbr_nchannels[
i];
1155 s->x96_rand = 1103515245
U *
s->x96_rand + 12345
U;
1156 return (
s->x96_rand & 0x7fffffff) - 0x40000000;
1161 int n, ssf, ch, band, ofs;
1165 if (*sub_pos + nsamples >
s->npcmblocks) {
1174 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1175 for (band =
s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1178 int32_t scale =
s->scale_factors[ch][band >> 1][band & 1];
1180 switch (
s->bit_allocation[ch][band]) {
1184 else for (n = 0; n < nsamples; n++)
1190 for (ssf = 0; ssf < (
s->nsubsubframes[sf] + 1) / 2; ssf++) {
1195 for (n = 0; n <
FFMIN(nsamples - ssf * 16, 16); n++)
1204 for (ssf = 0, ofs = *sub_pos; ssf <
s->nsubsubframes[sf]; ssf++) {
1205 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1209 for (band =
s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1210 int ret, abits =
s->bit_allocation[ch][band] - 1;
1223 if (
s->bit_rate == 3)
1229 scale =
s->scale_factors[ch][band >> 1][band & 1];
1237 if ((ssf ==
s->nsubsubframes[sf] - 1 ||
s->sync_ssf) &&
get_bits(&
s->gb, 16) != 0xffff) {
1246 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1248 s->prediction_mode[ch],
s->x96_subband_start,
s->nsubbands[ch],
1249 *sub_pos, nsamples);
1253 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1254 int src_ch =
s->joint_intensity_index[ch] - 1;
1256 s->dcadsp->decode_joint(
s->x96_subband_samples[ch],
s->x96_subband_samples[src_ch],
1257 s->joint_scale_factors[ch],
s->nsubbands[ch],
1258 s->nsubbands[src_ch], *sub_pos, nsamples);
1284 unsigned int size =
s->x96_subband_size;
1289 nframesamples *
sizeof(
int32_t));
1290 if (!
s->x96_subband_buffer)
1293 if (
size !=
s->x96_subband_size) {
1296 s->x96_subband_samples[ch][band] =
s->x96_subband_buffer +
1300 if (!
s->predictor_history)
1314 for (ch = xch_base; ch <
s->x96_nchannels; ch++)
1315 for (band =
s->x96_subband_start; band < s->nsubbands[ch]; band++)
1319 for (ch = xch_base; ch <
s->x96_nchannels; ch++)
1320 for (band =
s->x96_subband_start; band < s->nsubbands[ch]; band++)
1321 if (
s->prediction_mode[ch][band])
1322 s->prediction_vq_index[ch][band] =
get_bits(&
s->gb, 12);
1325 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1326 int sel =
s->bit_allocation_sel[ch];
1329 for (band =
s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1334 abits =
get_bits(&
s->gb, 3 +
s->x96_high_res);
1336 if (abits < 0 || abits > 7 + 8 *
s->x96_high_res) {
1341 s->bit_allocation[ch][band] = abits;
1346 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1347 int sel =
s->scale_factor_sel[ch];
1348 int scale_index = 0;
1352 for (band =
s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1355 s->scale_factors[ch][band >> 1][band & 1] =
ret;
1360 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1361 if (
s->joint_intensity_index[ch]) {
1362 s->joint_scale_sel[ch] =
get_bits(&
s->gb, 3);
1363 if (
s->joint_scale_sel[ch] == 7) {
1371 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1372 int src_ch =
s->joint_intensity_index[ch] - 1;
1374 int sel =
s->joint_scale_sel[ch];
1375 for (band =
s->nsubbands[ch]; band < s->nsubbands[src_ch]; band++) {
1378 s->joint_scale_factors[ch][band] =
ret;
1402 if (
s->x96_crc_present
1413 if (
s->x96_rev_no < 8) {
1415 if (
s->x96_subband_start > 27) {
1416 av_log(
s->avctx,
AV_LOG_ERROR,
"Invalid X96 subband start index (%d)\n",
s->x96_subband_start);
1424 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1433 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1434 if ((n =
get_bits(&
s->gb, 3)) && xch_base)
1436 if (n >
s->x96_nchannels) {
1440 s->joint_intensity_index[ch] = n;
1444 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1445 s->scale_factor_sel[ch] =
get_bits(&
s->gb, 3);
1446 if (
s->scale_factor_sel[ch] >= 6) {
1453 for (ch = xch_base; ch <
s->x96_nchannels; ch++)
1454 s->bit_allocation_sel[ch] =
get_bits(&
s->gb, 3);
1457 for (n = 0; n < 6 + 4 *
s->x96_high_res; n++)
1458 for (ch = xch_base; ch <
s->x96_nchannels; ch++)
1479 int sf, ch,
ret, band, sub_pos;
1484 for (sf = 0, sub_pos = 0; sf <
s->nsubframes; sf++) {
1491 for (ch = xch_base; ch <
s->x96_nchannels; ch++) {
1493 int nsubbands =
s->nsubbands[ch];
1494 if (
s->joint_intensity_index[ch])
1495 nsubbands =
FFMAX(nsubbands,
s->nsubbands[
s->joint_intensity_index[ch] - 1]);
1500 if (band >=
s->x96_subband_start && band < nsubbands)
1518 if (
s->x96_rev_no < 1 ||
s->x96_rev_no > 8) {
1523 s->x96_crc_present = 0;
1524 s->x96_nchannels =
s->nchannels;
1545 int x96_nchsets, x96_base_ch;
1558 if (
ff_dca_check_crc(
s->avctx, &
s->gb, header_pos + 32, header_pos + header_size * 8)) {
1565 if (
s->x96_rev_no < 1 ||
s->x96_rev_no > 8) {
1577 for (
i = 0;
i < x96_nchsets;
i++)
1578 x96_frame_size[
i] =
get_bits(&
s->gb, 12) + 1;
1581 for (
i = 0;
i < x96_nchsets;
i++)
1596 s->x96_nchannels = 0;
1597 for (
i = 0, x96_base_ch = 0;
i < x96_nchsets;
i++) {
1600 if (x96_base_ch + x96_nchannels[
i] <=
s->nchannels) {
1601 s->x96_nchannels = x96_base_ch + x96_nchannels[
i];
1606 x96_base_ch += x96_nchannels[
i];
1658 for (
i = 0;
i < m * n;
i++) {
1660 int sign = (
code >> 8) - 1;
1700 s->prim_dmix_embedded = 0;
1703 if (
s->ext_audio_present && !dca->
core_only) {
1704 int sync_pos =
FFMIN(
s->frame_size / 4,
s->gb.size_in_bits / 32) - 1;
1707 uint32_t w1, w2 = 0;
1712 switch (
s->ext_audio_type) {
1722 for (; sync_pos >= last_pos; sync_pos--, w2 = w1) {
1723 w1 =
AV_RB32(
s->gb.buffer + sync_pos * 4);
1725 size = (w2 >> 22) + 1;
1726 dist =
s->frame_size - sync_pos * 4;
1728 && (
size == dist ||
size - 1 == dist)
1729 && (w2 >> 15 & 0x7f) == 0x08) {
1730 s->xch_pos = sync_pos * 32 + 49;
1747 for (; sync_pos >= last_pos; sync_pos--, w2 = w1) {
1748 w1 =
AV_RB32(
s->gb.buffer + sync_pos * 4);
1750 size = (w2 >> 20) + 1;
1751 dist =
s->frame_size - sync_pos * 4;
1753 s->x96_pos = sync_pos * 32 + 44;
1772 for (; sync_pos >= last_pos; sync_pos--, w2 = w1) {
1773 w1 =
AV_RB32(
s->gb.buffer + sync_pos * 4);
1775 size = (w2 >> 26) + 1;
1776 dist =
s->gb.size_in_bits / 8 - sync_pos * 4;
1779 (sync_pos + 1) * 4,
size - 4)) {
1780 s->xxch_pos = sync_pos * 32;
1802 s->ext_audio_mask = 0;
1803 s->xch_pos =
s->xxch_pos =
s->x96_pos = 0;
1819 if (
s->frame_size >
size)
1820 s->frame_size =
size;
1836 int ret = 0, ext = 0;
1845 }
else if (
s->xxch_pos) {
1850 }
else if (
s->xch_pos) {
1866 s->ext_audio_mask |= ext;
1893 }
else if (
s->x96_pos) {
1917 if (
s->xxch_core_mask & (1
U << spkr))
1935 if (
s->xxch_spkr_mask & (1
U << spkr))
1946 memset(
s->dcadsp_data, 0,
sizeof(
s->dcadsp_data));
1947 s->output_history_lfe_fixed = 0;
1948 s->output_history_lfe_float = 0;
1953 if (
s->filter_mode !=
mode) {
1955 s->filter_mode =
mode;
1961 int n, ch, spkr, nsamples, x96_nchannels = 0;
1970 x96_nchannels =
s->x96_nchannels;
1976 s->output_rate =
s->sample_rate << x96_synth;
1981 nsamples * av_popcount(
s->ch_mask) *
sizeof(
int32_t));
1982 if (!
s->output_buffer)
1987 if (
s->ch_mask & (1
U << spkr)) {
1988 s->output_samples[spkr] = ptr;
1991 s->output_samples[spkr] =
NULL;
2001 else if (
s->filter_perfect)
2007 for (ch = 0; ch <
s->nchannels; ch++) {
2014 s->dcadsp->sub_qmf_fixed[x96_synth](
2017 s->output_samples[spkr],
2018 s->subband_samples[ch],
2019 ch < x96_nchannels ?
s->x96_subband_samples[ch] :
NULL,
2020 s->dcadsp_data[ch].u.fix.hist1,
2021 &
s->dcadsp_data[ch].offset,
2022 s->dcadsp_data[ch].u.fix.hist2,
2028 if (
s->lfe_present) {
2030 int nlfesamples =
s->npcmblocks >> 1;
2050 samples, &
s->output_history_lfe_fixed,
2057 s->lfe_samples[n] =
s->lfe_samples[nlfesamples + n];
2067 int i, n, ch,
ret, spkr, nsamples;
2077 frame->nb_samples = nsamples =
s->npcmsamples;
2093 &&
s->xxch_dmix_embedded) {
2094 int scale_inv =
s->xxch_dmix_scale_inv;
2095 int *coeff_ptr =
s->xxch_dmix_coeff;
2100 for (spkr = 0; spkr <
s->xxch_mask_nbits; spkr++) {
2101 if (
s->xxch_core_mask & (1
U << spkr)) {
2102 s->dcadsp->dmix_scale_inv(
s->output_samples[spkr],
2103 scale_inv, nsamples);
2108 for (ch = xch_base; ch <
s->nchannels; ch++) {
2112 for (spkr = 0; spkr <
s->xxch_mask_nbits; spkr++) {
2113 if (
s->xxch_dmix_mask[ch - xch_base] & (1
U << spkr)) {
2116 s->dcadsp->dmix_sub(
s->output_samples[spkr ],
2117 s->output_samples[src_spkr],
2143 if (
s->request_mask !=
s->ch_mask) {
2147 nsamples,
s->ch_mask);
2153 for (n = 0; n < nsamples; n++)
2163 int x96_nchannels = 0, x96_synth = 0;
2164 int i, n, ch,
ret, spkr, nsamples, nchannels;
2166 const float *filter_coeff;
2169 x96_nchannels =
s->x96_nchannels;
2183 output_samples[
s->ch_remap[
i]] = (
float *)
frame->extended_data[
i];
2186 nchannels = av_popcount(
s->ch_mask) - avctx->
channels;
2187 if (nchannels > 0) {
2189 nsamples * nchannels *
sizeof(
float));
2190 if (!
s->output_buffer)
2193 ptr = (
float *)
s->output_buffer;
2195 if (!(
s->ch_mask & (1
U << spkr)))
2197 if (output_samples[spkr])
2199 output_samples[spkr] = ptr;
2210 else if (
s->filter_perfect)
2216 for (ch = 0; ch <
s->nchannels; ch++) {
2223 s->dcadsp->sub_qmf_float[x96_synth](
2225 &
s->imdct[x96_synth],
2226 output_samples[spkr],
2227 s->subband_samples[ch],
2228 ch < x96_nchannels ?
s->x96_subband_samples[ch] :
NULL,
2229 s->dcadsp_data[ch].u.flt.hist1,
2230 &
s->dcadsp_data[ch].offset,
2231 s->dcadsp_data[ch].u.flt.hist2,
2234 1.0f / (1 << (17 - x96_synth)));
2238 if (
s->lfe_present) {
2241 int nlfesamples =
s->npcmblocks >> (dec_select + 1);
2254 s->dcadsp->lfe_fir_float[dec_select](
2256 filter_coeff,
s->npcmblocks);
2262 samples, &
s->output_history_lfe_float,
2268 s->lfe_samples[n] =
s->lfe_samples[nlfesamples + n];
2284 &&
s->xxch_dmix_embedded) {
2285 float scale_inv =
s->xxch_dmix_scale_inv * (1.0f / (1 << 16));
2286 int *coeff_ptr =
s->xxch_dmix_coeff;
2291 for (ch = xch_base; ch <
s->nchannels; ch++) {
2295 for (spkr = 0; spkr <
s->xxch_mask_nbits; spkr++) {
2296 if (
s->xxch_dmix_mask[ch - xch_base] & (1
U << spkr)) {
2297 int coeff = *coeff_ptr++;
2299 s->float_dsp->vector_fmac_scalar(output_samples[ spkr],
2300 output_samples[src_spkr],
2301 coeff * (-1.0
f / (1 << 15)),
2309 for (spkr = 0; spkr <
s->xxch_mask_nbits; spkr++) {
2310 if (
s->xxch_core_mask & (1
U << spkr)) {
2311 s->float_dsp->vector_fmul_scalar(output_samples[spkr],
2312 output_samples[spkr],
2313 scale_inv, nsamples);
2336 if (
s->request_mask !=
s->ch_mask) {
2339 nsamples,
s->ch_mask);
2360 s->request_mask =
s->ch_mask;
2401 if (
s->subband_buffer) {
2406 if (
s->x96_subband_buffer)
2439 s->subband_size = 0;
2442 s->x96_subband_size = 0;