2 * Copyright (C) 2016 foo86
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "dca_syncwords.h"
27 static int get_linear(GetBitContext *gb, int n)
29 unsigned int v = get_bits_long(gb, n);
30 return (v >> 1) ^ -(v & 1);
33 static int get_rice_un(GetBitContext *gb, int k)
35 unsigned int v = get_unary(gb, 1, 128);
36 return (v << k) | get_bits_long(gb, k);
39 static int get_rice(GetBitContext *gb, int k)
41 unsigned int v = get_rice_un(gb, k);
42 return (v >> 1) ^ -(v & 1);
45 static void get_array(GetBitContext *gb, int32_t *array, int size, int n)
49 for (i = 0; i < size; i++)
50 array[i] = get_bits(gb, n);
53 static void get_linear_array(GetBitContext *gb, int32_t *array, int size, int n)
58 memset(array, 0, sizeof(*array) * size);
59 else for (i = 0; i < size; i++)
60 array[i] = get_linear(gb, n);
63 static void get_rice_array(GetBitContext *gb, int32_t *array, int size, int k)
67 for (i = 0; i < size; i++)
68 array[i] = get_rice(gb, k);
71 static int parse_dmix_coeffs(DCAXllDecoder *s, DCAXllChSet *c)
73 // Size of downmix coefficient matrix
74 int m = c->primary_chset ? ff_dca_dmix_primary_nch[c->dmix_type] : c->hier_ofs;
75 int i, j, *coeff_ptr = c->dmix_coeff;
77 for (i = 0; i < m; i++) {
78 int code, sign, coeff, scale, scale_inv = 0;
81 // Downmix scale (only for non-primary channel sets)
82 if (!c->primary_chset) {
83 code = get_bits(&s->gb, 9);
84 sign = (code >> 8) - 1;
85 index = (code & 0xff) - FF_DCA_DMIXTABLE_OFFSET;
86 if (index >= FF_DCA_INV_DMIXTABLE_SIZE) {
87 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL downmix scale index\n");
88 return AVERROR_INVALIDDATA;
90 scale = ff_dca_dmixtable[index + FF_DCA_DMIXTABLE_OFFSET];
91 scale_inv = ff_dca_inv_dmixtable[index];
92 c->dmix_scale[i] = (scale ^ sign) - sign;
93 c->dmix_scale_inv[i] = (scale_inv ^ sign) - sign;
96 // Downmix coefficients
97 for (j = 0; j < c->nchannels; j++) {
98 code = get_bits(&s->gb, 9);
99 sign = (code >> 8) - 1;
101 if (index >= FF_DCA_DMIXTABLE_SIZE) {
102 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL downmix coefficient index\n");
103 return AVERROR_INVALIDDATA;
105 coeff = ff_dca_dmixtable[index];
106 if (!c->primary_chset)
107 // Multiply by |InvDmixScale| to get |UndoDmixScale|
108 coeff = mul16(scale_inv, coeff);
109 *coeff_ptr++ = (coeff ^ sign) - sign;
116 static int chs_parse_header(DCAXllDecoder *s, DCAXllChSet *c, DCAExssAsset *asset)
118 int i, j, k, ret, band, header_size, header_pos = get_bits_count(&s->gb);
119 DCAXllChSet *p = &s->chset[0];
122 // Size of channel set sub-header
123 header_size = get_bits(&s->gb, 10) + 1;
126 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
127 && ff_dca_check_crc(&s->gb, header_pos, header_pos + header_size * 8)) {
128 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL sub-header checksum\n");
129 return AVERROR_INVALIDDATA;
132 // Number of channels in the channel set
133 c->nchannels = get_bits(&s->gb, 4) + 1;
134 if (c->nchannels > DCA_XLL_CHANNELS_MAX) {
135 avpriv_request_sample(s->avctx, "%d XLL channels", c->nchannels);
136 return AVERROR_PATCHWELCOME;
140 c->residual_encode = get_bits(&s->gb, c->nchannels);
142 // PCM bit resolution
143 c->pcm_bit_res = get_bits(&s->gb, 5) + 1;
145 // Storage unit width
146 c->storage_bit_res = get_bits(&s->gb, 5) + 1;
147 if (c->storage_bit_res != 16 && c->storage_bit_res != 24) {
148 avpriv_request_sample(s->avctx, "%d-bit XLL storage resolution", c->storage_bit_res);
149 return AVERROR_PATCHWELCOME;
152 if (c->pcm_bit_res > c->storage_bit_res) {
153 av_log(s->avctx, AV_LOG_ERROR, "Invalid PCM bit resolution for XLL channel set (%d > %d)\n", c->pcm_bit_res, c->storage_bit_res);
154 return AVERROR_INVALIDDATA;
157 // Original sampling frequency
158 c->freq = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];
159 if (c->freq > 192000) {
160 avpriv_request_sample(s->avctx, "%d Hz XLL sampling frequency", c->freq);
161 return AVERROR_PATCHWELCOME;
164 // Sampling frequency modifier
165 if (get_bits(&s->gb, 2)) {
166 avpriv_request_sample(s->avctx, "XLL sampling frequency modifier");
167 return AVERROR_PATCHWELCOME;
170 // Which replacement set this channel set is member of
171 if (get_bits(&s->gb, 2)) {
172 avpriv_request_sample(s->avctx, "XLL replacement set");
173 return AVERROR_PATCHWELCOME;
176 if (asset->one_to_one_map_ch_to_spkr) {
177 // Primary channel set flag
178 c->primary_chset = get_bits1(&s->gb);
179 if (c->primary_chset != (c == p)) {
180 av_log(s->avctx, AV_LOG_ERROR, "The first (and only) XLL channel set must be primary\n");
181 return AVERROR_INVALIDDATA;
184 // Downmix coefficients present in stream
185 c->dmix_coeffs_present = get_bits1(&s->gb);
187 // Downmix already performed by encoder
188 c->dmix_embedded = c->dmix_coeffs_present && get_bits1(&s->gb);
191 if (c->dmix_coeffs_present && c->primary_chset) {
192 c->dmix_type = get_bits(&s->gb, 3);
193 if (c->dmix_type >= DCA_DMIX_TYPE_COUNT) {
194 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL primary channel set downmix type\n");
195 return AVERROR_INVALIDDATA;
199 // Whether the channel set is part of a hierarchy
200 c->hier_chset = get_bits1(&s->gb);
201 if (!c->hier_chset && s->nchsets != 1) {
202 avpriv_request_sample(s->avctx, "XLL channel set outside of hierarchy");
203 return AVERROR_PATCHWELCOME;
206 // Downmix coefficients
207 if (c->dmix_coeffs_present && (ret = parse_dmix_coeffs(s, c)) < 0)
210 // Channel mask enabled
211 if (!get_bits1(&s->gb)) {
212 avpriv_request_sample(s->avctx, "Disabled XLL channel mask");
213 return AVERROR_PATCHWELCOME;
216 // Channel mask for set
217 c->ch_mask = get_bits_long(&s->gb, s->ch_mask_nbits);
218 if (av_popcount(c->ch_mask) != c->nchannels) {
219 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL channel mask\n");
220 return AVERROR_INVALIDDATA;
223 // Build the channel to speaker map
224 for (i = 0, j = 0; i < s->ch_mask_nbits; i++)
225 if (c->ch_mask & (1U << i))
226 c->ch_remap[j++] = i;
228 // Mapping coeffs present flag
229 if (c->nchannels != 2 || s->nchsets != 1 || get_bits1(&s->gb)) {
230 avpriv_request_sample(s->avctx, "Custom XLL channel to speaker mapping");
231 return AVERROR_PATCHWELCOME;
234 // Setup for LtRt decoding
235 c->primary_chset = 1;
236 c->dmix_coeffs_present = 0;
237 c->dmix_embedded = 0;
239 c->ch_mask = DCA_SPEAKER_LAYOUT_STEREO;
240 c->ch_remap[0] = DCA_SPEAKER_L;
241 c->ch_remap[1] = DCA_SPEAKER_R;
244 if (c->freq > 96000) {
245 // Extra frequency bands flag
246 if (get_bits1(&s->gb)) {
247 avpriv_request_sample(s->avctx, "Extra XLL frequency bands");
248 return AVERROR_PATCHWELCOME;
255 // Set the sampling frequency to that of the first frequency band.
256 // Frequency will be doubled again after bands assembly.
257 c->freq >>= c->nfreqbands - 1;
259 // Verify that all channel sets have the same audio characteristics
260 if (c != p && (c->nfreqbands != p->nfreqbands || c->freq != p->freq
261 || c->pcm_bit_res != p->pcm_bit_res
262 || c->storage_bit_res != p->storage_bit_res)) {
263 avpriv_request_sample(s->avctx, "Different XLL audio characteristics");
264 return AVERROR_PATCHWELCOME;
267 // Determine number of bits to read bit allocation coding parameter
268 if (c->storage_bit_res > 16)
270 else if (c->storage_bit_res > 8)
275 // Account for embedded downmix and decimator saturation
276 if ((s->nchsets > 1 || c->nfreqbands > 1) && c->nabits < 5)
279 for (band = 0, b = c->bands; band < c->nfreqbands; band++, b++) {
280 // Pairwise channel decorrelation
281 if ((b->decor_enabled = get_bits1(&s->gb)) && c->nchannels > 1) {
282 int ch_nbits = av_ceil_log2(c->nchannels);
284 // Original channel order
285 for (i = 0; i < c->nchannels; i++) {
286 b->orig_order[i] = get_bits(&s->gb, ch_nbits);
287 if (b->orig_order[i] >= c->nchannels) {
288 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL original channel order\n");
289 return AVERROR_INVALIDDATA;
293 // Pairwise channel coefficients
294 for (i = 0; i < c->nchannels / 2; i++)
295 b->decor_coeff[i] = get_bits1(&s->gb) ? get_linear(&s->gb, 7) : 0;
297 for (i = 0; i < c->nchannels; i++)
298 b->orig_order[i] = i;
299 for (i = 0; i < c->nchannels / 2; i++)
300 b->decor_coeff[i] = 0;
303 // Adaptive predictor order
304 b->highest_pred_order = 0;
305 for (i = 0; i < c->nchannels; i++) {
306 b->adapt_pred_order[i] = get_bits(&s->gb, 4);
307 if (b->adapt_pred_order[i] > b->highest_pred_order)
308 b->highest_pred_order = b->adapt_pred_order[i];
310 if (b->highest_pred_order > s->nsegsamples) {
311 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL adaptive predicition order\n");
312 return AVERROR_INVALIDDATA;
315 // Fixed predictor order
316 for (i = 0; i < c->nchannels; i++)
317 b->fixed_pred_order[i] = b->adapt_pred_order[i] ? 0 : get_bits(&s->gb, 2);
319 // Adaptive predictor quantized reflection coefficients
320 for (i = 0; i < c->nchannels; i++) {
321 for (j = 0; j < b->adapt_pred_order[i]; j++) {
322 k = get_linear(&s->gb, 8);
324 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL reflection coefficient index\n");
325 return AVERROR_INVALIDDATA;
328 b->adapt_refl_coeff[i][j] = -(int)ff_dca_xll_refl_coeff[-k];
330 b->adapt_refl_coeff[i][j] = (int)ff_dca_xll_refl_coeff[ k];
334 // Downmix performed by encoder in extension frequency band
335 b->dmix_embedded = c->dmix_embedded && (band == 0 || get_bits1(&s->gb));
337 // MSB/LSB split flag in extension frequency band
338 if ((band == 0 && s->scalable_lsbs) || (band != 0 && get_bits1(&s->gb))) {
339 // Size of LSB section in any segment
340 b->lsb_section_size = get_bits_long(&s->gb, s->seg_size_nbits);
341 if (b->lsb_section_size < 0 || b->lsb_section_size > s->frame_size) {
342 av_log(s->avctx, AV_LOG_ERROR, "Invalid LSB section size\n");
343 return AVERROR_INVALIDDATA;
346 // Account for optional CRC bytes after LSB section
347 if (b->lsb_section_size && (s->band_crc_present > 2 ||
348 (band == 0 && s->band_crc_present > 1)))
349 b->lsb_section_size += 2;
351 // Number of bits to represent the samples in LSB part
352 for (i = 0; i < c->nchannels; i++) {
353 b->nscalablelsbs[i] = get_bits(&s->gb, 4);
354 if (b->nscalablelsbs[i] && !b->lsb_section_size) {
355 av_log(s->avctx, AV_LOG_ERROR, "LSB section missing with non-zero LSB width\n");
356 return AVERROR_INVALIDDATA;
360 b->lsb_section_size = 0;
361 for (i = 0; i < c->nchannels; i++)
362 b->nscalablelsbs[i] = 0;
365 // Scalable resolution flag in extension frequency band
366 if ((band == 0 && s->scalable_lsbs) || (band != 0 && get_bits1(&s->gb))) {
367 // Number of bits discarded by authoring
368 for (i = 0; i < c->nchannels; i++)
369 b->bit_width_adjust[i] = get_bits(&s->gb, 4);
371 for (i = 0; i < c->nchannels; i++)
372 b->bit_width_adjust[i] = 0;
378 // CRC16 of channel set sub-header
379 if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {
380 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL sub-header\n");
381 return AVERROR_INVALIDDATA;
387 static int chs_alloc_msb_band_data(DCAXllDecoder *s, DCAXllChSet *c)
389 int ndecisamples = c->nfreqbands > 1 ? DCA_XLL_DECI_HISTORY_MAX : 0;
390 int nchsamples = s->nframesamples + ndecisamples;
391 int i, j, nsamples = nchsamples * c->nchannels * c->nfreqbands;
394 // Reallocate MSB sample buffer
395 av_fast_malloc(&c->sample_buffer[0], &c->sample_size[0], nsamples * sizeof(int32_t));
396 if (!c->sample_buffer[0])
397 return AVERROR(ENOMEM);
399 ptr = c->sample_buffer[0] + ndecisamples;
400 for (i = 0; i < c->nfreqbands; i++) {
401 for (j = 0; j < c->nchannels; j++) {
402 c->bands[i].msb_sample_buffer[j] = ptr;
410 static int chs_alloc_lsb_band_data(DCAXllDecoder *s, DCAXllChSet *c)
412 int i, j, nsamples = 0;
415 // Determine number of frequency bands that have MSB/LSB split
416 for (i = 0; i < c->nfreqbands; i++)
417 if (c->bands[i].lsb_section_size)
418 nsamples += s->nframesamples * c->nchannels;
422 // Reallocate LSB sample buffer
423 av_fast_malloc(&c->sample_buffer[1], &c->sample_size[1], nsamples * sizeof(int32_t));
424 if (!c->sample_buffer[1])
425 return AVERROR(ENOMEM);
427 ptr = c->sample_buffer[1];
428 for (i = 0; i < c->nfreqbands; i++) {
429 if (c->bands[i].lsb_section_size) {
430 for (j = 0; j < c->nchannels; j++) {
431 c->bands[i].lsb_sample_buffer[j] = ptr;
432 ptr += s->nframesamples;
435 for (j = 0; j < c->nchannels; j++)
436 c->bands[i].lsb_sample_buffer[j] = NULL;
443 static int chs_parse_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg, int band_data_end)
445 DCAXllBand *b = &c->bands[band];
448 // Start unpacking MSB portion of the segment
449 if (!(seg && get_bits1(&s->gb))) {
450 // Unpack segment type
451 // 0 - distinct coding parameters for each channel
452 // 1 - common coding parameters for all channels
453 c->seg_common = get_bits1(&s->gb);
455 // Determine number of coding parameters encoded in segment
456 k = c->seg_common ? 1 : c->nchannels;
458 // Unpack Rice coding parameters
459 for (i = 0; i < k; i++) {
460 // Unpack Rice coding flag
461 // 0 - linear code, 1 - Rice code
462 c->rice_code_flag[i] = get_bits1(&s->gb);
463 if (!c->seg_common && c->rice_code_flag[i]) {
464 // Unpack Hybrid Rice coding flag
465 // 0 - Rice code, 1 - Hybrid Rice code
466 if (get_bits1(&s->gb))
467 // Unpack binary code length for isolated samples
468 c->bitalloc_hybrid_linear[i] = get_bits(&s->gb, c->nabits) + 1;
470 // 0 indicates no Hybrid Rice coding
471 c->bitalloc_hybrid_linear[i] = 0;
473 // 0 indicates no Hybrid Rice coding
474 c->bitalloc_hybrid_linear[i] = 0;
478 // Unpack coding parameters
479 for (i = 0; i < k; i++) {
481 // Unpack coding parameter for part A of segment 0
482 c->bitalloc_part_a[i] = get_bits(&s->gb, c->nabits);
484 // Adjust for the linear code
485 if (!c->rice_code_flag[i] && c->bitalloc_part_a[i])
486 c->bitalloc_part_a[i]++;
489 c->nsamples_part_a[i] = b->adapt_pred_order[i];
491 c->nsamples_part_a[i] = b->highest_pred_order;
493 c->bitalloc_part_a[i] = 0;
494 c->nsamples_part_a[i] = 0;
497 // Unpack coding parameter for part B of segment
498 c->bitalloc_part_b[i] = get_bits(&s->gb, c->nabits);
500 // Adjust for the linear code
501 if (!c->rice_code_flag[i] && c->bitalloc_part_b[i])
502 c->bitalloc_part_b[i]++;
506 // Unpack entropy codes
507 for (i = 0; i < c->nchannels; i++) {
508 int32_t *part_a, *part_b;
511 // Select index of coding parameters
512 k = c->seg_common ? 0 : i;
514 // Slice the segment into parts A and B
515 part_a = b->msb_sample_buffer[i] + seg * s->nsegsamples;
516 part_b = part_a + c->nsamples_part_a[k];
517 nsamples_part_b = s->nsegsamples - c->nsamples_part_a[k];
519 if (get_bits_left(&s->gb) < 0)
520 return AVERROR_INVALIDDATA;
522 if (!c->rice_code_flag[k]) {
524 // Unpack all residuals of part A of segment 0
525 get_linear_array(&s->gb, part_a, c->nsamples_part_a[k],
526 c->bitalloc_part_a[k]);
528 // Unpack all residuals of part B of segment 0 and others
529 get_linear_array(&s->gb, part_b, nsamples_part_b,
530 c->bitalloc_part_b[k]);
533 // Unpack all residuals of part A of segment 0
534 get_rice_array(&s->gb, part_a, c->nsamples_part_a[k],
535 c->bitalloc_part_a[k]);
537 if (c->bitalloc_hybrid_linear[k]) {
539 // Unpack the number of isolated samples
540 int nisosamples = get_bits(&s->gb, s->nsegsamples_log2);
542 // Set all locations to 0
543 memset(part_b, 0, sizeof(*part_b) * nsamples_part_b);
545 // Extract the locations of isolated samples and flag by -1
546 for (j = 0; j < nisosamples; j++) {
547 int loc = get_bits(&s->gb, s->nsegsamples_log2);
548 if (loc >= nsamples_part_b) {
549 av_log(s->avctx, AV_LOG_ERROR, "Invalid isolated sample location\n");
550 return AVERROR_INVALIDDATA;
555 // Unpack all residuals of part B of segment 0 and others
556 for (j = 0; j < nsamples_part_b; j++) {
558 part_b[j] = get_linear(&s->gb, c->bitalloc_hybrid_linear[k]);
560 part_b[j] = get_rice(&s->gb, c->bitalloc_part_b[k]);
564 // Unpack all residuals of part B of segment 0 and others
565 get_rice_array(&s->gb, part_b, nsamples_part_b, c->bitalloc_part_b[k]);
570 // Unpack decimator history for frequency band 1
571 if (seg == 0 && band == 1) {
572 int nbits = get_bits(&s->gb, 5) + 1;
573 for (i = 0; i < c->nchannels; i++)
574 for (j = 1; j < DCA_XLL_DECI_HISTORY_MAX; j++)
575 c->deci_history[i][j] = get_sbits_long(&s->gb, nbits);
578 // Start unpacking LSB portion of the segment
579 if (b->lsb_section_size) {
580 // Skip to the start of LSB portion
581 if (ff_dca_seek_bits(&s->gb, band_data_end - b->lsb_section_size * 8)) {
582 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL band data\n");
583 return AVERROR_INVALIDDATA;
586 // Unpack all LSB parts of residuals of this segment
587 for (i = 0; i < c->nchannels; i++) {
588 if (b->nscalablelsbs[i]) {
590 b->lsb_sample_buffer[i] + seg * s->nsegsamples,
591 s->nsegsamples, b->nscalablelsbs[i]);
596 // Skip to the end of band data
597 if (ff_dca_seek_bits(&s->gb, band_data_end)) {
598 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL band data\n");
599 return AVERROR_INVALIDDATA;
605 static void av_cold chs_clear_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg)
607 DCAXllBand *b = &c->bands[band];
608 int i, offset, nsamples;
612 nsamples = s->nframesamples;
614 offset = seg * s->nsegsamples;
615 nsamples = s->nsegsamples;
618 for (i = 0; i < c->nchannels; i++) {
619 memset(b->msb_sample_buffer[i] + offset, 0, nsamples * sizeof(int32_t));
620 if (b->lsb_section_size)
621 memset(b->lsb_sample_buffer[i] + offset, 0, nsamples * sizeof(int32_t));
624 if (seg <= 0 && band)
625 memset(c->deci_history, 0, sizeof(c->deci_history));
628 memset(b->nscalablelsbs, 0, sizeof(b->nscalablelsbs));
629 memset(b->bit_width_adjust, 0, sizeof(b->bit_width_adjust));
633 static void chs_filter_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band)
635 DCAXllBand *b = &c->bands[band];
636 int nsamples = s->nframesamples;
639 // Inverse adaptive or fixed prediction
640 for (i = 0; i < c->nchannels; i++) {
641 int32_t *buf = b->msb_sample_buffer[i];
642 int order = b->adapt_pred_order[i];
644 int coeff[DCA_XLL_ADAPT_PRED_ORDER_MAX];
645 // Conversion from reflection coefficients to direct form coefficients
646 for (j = 0; j < order; j++) {
647 int rc = b->adapt_refl_coeff[i][j];
648 for (k = 0; k < (j + 1) / 2; k++) {
649 int tmp1 = coeff[ k ];
650 int tmp2 = coeff[j - k - 1];
651 coeff[ k ] = tmp1 + mul16(rc, tmp2);
652 coeff[j - k - 1] = tmp2 + mul16(rc, tmp1);
656 // Inverse adaptive prediction
657 for (j = 0; j < nsamples - order; j++) {
659 for (k = 0; k < order; k++)
660 err += (int64_t)buf[j + k] * coeff[order - k - 1];
661 buf[j + k] -= clip23(norm16(err));
664 // Inverse fixed coefficient prediction
665 for (j = 0; j < b->fixed_pred_order[i]; j++)
666 for (k = 1; k < nsamples; k++)
667 buf[k] += buf[k - 1];
671 // Inverse pairwise channel decorrellation
672 if (b->decor_enabled) {
673 int32_t *tmp[DCA_XLL_CHANNELS_MAX];
675 for (i = 0; i < c->nchannels / 2; i++) {
676 int coeff = b->decor_coeff[i];
678 s->dcadsp->decor(b->msb_sample_buffer[i * 2 + 1],
679 b->msb_sample_buffer[i * 2 ],
684 // Reorder channel pointers to the original order
685 for (i = 0; i < c->nchannels; i++)
686 tmp[i] = b->msb_sample_buffer[i];
688 for (i = 0; i < c->nchannels; i++)
689 b->msb_sample_buffer[b->orig_order[i]] = tmp[i];
692 // Map output channel pointers for frequency band 0
693 if (c->nfreqbands == 1)
694 for (i = 0; i < c->nchannels; i++)
695 s->output_samples[c->ch_remap[i]] = b->msb_sample_buffer[i];
698 static int chs_get_lsb_width(DCAXllDecoder *s, DCAXllChSet *c, int band, int ch)
700 int adj = c->bands[band].bit_width_adjust[ch];
701 int shift = c->bands[band].nscalablelsbs[ch];
703 if (s->fixed_lsb_width)
704 shift = s->fixed_lsb_width;
705 else if (shift && adj)
713 static void chs_assemble_msbs_lsbs(DCAXllDecoder *s, DCAXllChSet *c, int band)
715 DCAXllBand *b = &c->bands[band];
716 int n, ch, nsamples = s->nframesamples;
718 for (ch = 0; ch < c->nchannels; ch++) {
719 int shift = chs_get_lsb_width(s, c, band, ch);
721 int32_t *msb = b->msb_sample_buffer[ch];
722 if (b->nscalablelsbs[ch]) {
723 int32_t *lsb = b->lsb_sample_buffer[ch];
724 int adj = b->bit_width_adjust[ch];
725 for (n = 0; n < nsamples; n++)
726 msb[n] = msb[n] * (1 << shift) + (lsb[n] << adj);
728 for (n = 0; n < nsamples; n++)
729 msb[n] = msb[n] * (1 << shift);
735 static int chs_assemble_freq_bands(DCAXllDecoder *s, DCAXllChSet *c)
737 int ch, nsamples = s->nframesamples;
740 av_assert1(c->nfreqbands > 1);
742 // Reallocate frequency band assembly buffer
743 av_fast_malloc(&c->sample_buffer[2], &c->sample_size[2],
744 2 * nsamples * c->nchannels * sizeof(int32_t));
745 if (!c->sample_buffer[2])
746 return AVERROR(ENOMEM);
748 // Assemble frequency bands 0 and 1
749 ptr = c->sample_buffer[2];
750 for (ch = 0; ch < c->nchannels; ch++) {
751 int32_t *band0 = c->bands[0].msb_sample_buffer[ch];
752 int32_t *band1 = c->bands[1].msb_sample_buffer[ch];
754 // Copy decimator history
755 memcpy(band0 - DCA_XLL_DECI_HISTORY_MAX,
756 c->deci_history[ch], sizeof(c->deci_history[0]));
759 s->dcadsp->assemble_freq_bands(ptr, band0, band1,
760 ff_dca_xll_band_coeff,
763 // Remap output channel pointer to assembly buffer
764 s->output_samples[c->ch_remap[ch]] = ptr;
771 static int parse_common_header(DCAXllDecoder *s)
773 int stream_ver, header_size, frame_size_nbits, nframesegs_log2;
775 // XLL extension sync word
776 if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_XLL) {
777 av_log(s->avctx, AV_LOG_VERBOSE, "Invalid XLL sync word\n");
778 return AVERROR(EAGAIN);
782 stream_ver = get_bits(&s->gb, 4) + 1;
783 if (stream_ver > 1) {
784 avpriv_request_sample(s->avctx, "XLL stream version %d", stream_ver);
785 return AVERROR_PATCHWELCOME;
788 // Lossless frame header length
789 header_size = get_bits(&s->gb, 8) + 1;
792 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
793 && ff_dca_check_crc(&s->gb, 32, header_size * 8)) {
794 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL common header checksum\n");
795 return AVERROR_INVALIDDATA;
798 // Number of bits used to read frame size
799 frame_size_nbits = get_bits(&s->gb, 5) + 1;
801 // Number of bytes in a lossless frame
802 s->frame_size = get_bits_long(&s->gb, frame_size_nbits);
803 if (s->frame_size < 0 || s->frame_size >= DCA_XLL_PBR_BUFFER_MAX) {
804 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL frame size (%d bytes)\n", s->frame_size);
805 return AVERROR_INVALIDDATA;
809 // Number of channels sets per frame
810 s->nchsets = get_bits(&s->gb, 4) + 1;
811 if (s->nchsets > DCA_XLL_CHSETS_MAX) {
812 avpriv_request_sample(s->avctx, "%d XLL channel sets", s->nchsets);
813 return AVERROR_PATCHWELCOME;
816 // Number of segments per frame
817 nframesegs_log2 = get_bits(&s->gb, 4);
818 s->nframesegs = 1 << nframesegs_log2;
819 if (s->nframesegs > 1024) {
820 av_log(s->avctx, AV_LOG_ERROR, "Too many segments per XLL frame\n");
821 return AVERROR_INVALIDDATA;
824 // Samples in segment per one frequency band for the first channel set
825 // Maximum value is 256 for sampling frequencies <= 48 kHz
826 // Maximum value is 512 for sampling frequencies > 48 kHz
827 s->nsegsamples_log2 = get_bits(&s->gb, 4);
828 if (!s->nsegsamples_log2) {
829 av_log(s->avctx, AV_LOG_ERROR, "Too few samples per XLL segment\n");
830 return AVERROR_INVALIDDATA;
832 s->nsegsamples = 1 << s->nsegsamples_log2;
833 if (s->nsegsamples > 512) {
834 av_log(s->avctx, AV_LOG_ERROR, "Too many samples per XLL segment\n");
835 return AVERROR_INVALIDDATA;
838 // Samples in frame per one frequency band for the first channel set
839 s->nframesamples_log2 = s->nsegsamples_log2 + nframesegs_log2;
840 s->nframesamples = 1 << s->nframesamples_log2;
841 if (s->nframesamples > 65536) {
842 av_log(s->avctx, AV_LOG_ERROR, "Too many samples per XLL frame\n");
843 return AVERROR_INVALIDDATA;
846 // Number of bits used to read segment size
847 s->seg_size_nbits = get_bits(&s->gb, 5) + 1;
849 // Presence of CRC16 within each frequency band
850 // 0 - No CRC16 within band
851 // 1 - CRC16 placed at the end of MSB0
852 // 2 - CRC16 placed at the end of MSB0 and LSB0
853 // 3 - CRC16 placed at the end of MSB0 and LSB0 and other frequency bands
854 s->band_crc_present = get_bits(&s->gb, 2);
856 // MSB/LSB split flag
857 s->scalable_lsbs = get_bits1(&s->gb);
859 // Channel position mask
860 s->ch_mask_nbits = get_bits(&s->gb, 5) + 1;
863 if (s->scalable_lsbs)
864 s->fixed_lsb_width = get_bits(&s->gb, 4);
866 s->fixed_lsb_width = 0;
870 // Header CRC16 protection
871 if (ff_dca_seek_bits(&s->gb, header_size * 8)) {
872 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL common header\n");
873 return AVERROR_INVALIDDATA;
879 static int is_hier_dmix_chset(DCAXllChSet *c)
881 return !c->primary_chset && c->dmix_embedded && c->hier_chset;
884 static DCAXllChSet *find_next_hier_dmix_chset(DCAXllDecoder *s, DCAXllChSet *c)
887 while (++c < &s->chset[s->nchsets])
888 if (is_hier_dmix_chset(c))
894 static void prescale_down_mix(DCAXllChSet *c, DCAXllChSet *o)
896 int i, j, *coeff_ptr = c->dmix_coeff;
898 for (i = 0; i < c->hier_ofs; i++) {
899 int scale = o->dmix_scale[i];
900 int scale_inv = o->dmix_scale_inv[i];
901 c->dmix_scale[i] = mul15(c->dmix_scale[i], scale);
902 c->dmix_scale_inv[i] = mul16(c->dmix_scale_inv[i], scale_inv);
903 for (j = 0; j < c->nchannels; j++) {
904 int coeff = mul16(*coeff_ptr, scale_inv);
905 *coeff_ptr++ = mul15(coeff, o->dmix_scale[c->hier_ofs + j]);
910 static int parse_sub_headers(DCAXllDecoder *s, DCAExssAsset *asset)
912 DCAContext *dca = s->avctx->priv_data;
916 // Parse channel set headers
920 for (i = 0, c = s->chset; i < s->nchsets; i++, c++) {
921 c->hier_ofs = s->nchannels;
922 if ((ret = chs_parse_header(s, c, asset)) < 0)
924 if (c->nfreqbands > s->nfreqbands)
925 s->nfreqbands = c->nfreqbands;
927 s->nchannels += c->nchannels;
928 if (c->residual_encode != (1 << c->nchannels) - 1)
932 // Pre-scale downmixing coefficients for all non-primary channel sets
933 for (i = s->nchsets - 1, c = &s->chset[i]; i > 0; i--, c--) {
934 if (is_hier_dmix_chset(c)) {
935 DCAXllChSet *o = find_next_hier_dmix_chset(s, c);
937 prescale_down_mix(c, o);
941 // Determine number of active channel sets to decode
942 switch (dca->request_channel_layout) {
943 case DCA_SPEAKER_LAYOUT_STEREO:
944 s->nactivechsets = 1;
946 case DCA_SPEAKER_LAYOUT_5POINT0:
947 case DCA_SPEAKER_LAYOUT_5POINT1:
948 s->nactivechsets = (s->chset[0].nchannels < 5 && s->nchsets > 1) ? 2 : 1;
951 s->nactivechsets = s->nchsets;
958 static int parse_navi_table(DCAXllDecoder *s)
960 int chs, seg, band, navi_nb, navi_pos, *navi_ptr;
963 // Determine size of NAVI table
964 navi_nb = s->nfreqbands * s->nframesegs * s->nchsets;
965 if (navi_nb > 1024) {
966 av_log(s->avctx, AV_LOG_ERROR, "Too many NAVI entries (%d)\n", navi_nb);
967 return AVERROR_INVALIDDATA;
970 // Reallocate NAVI table
971 av_fast_malloc(&s->navi, &s->navi_size, navi_nb * sizeof(*s->navi));
973 return AVERROR(ENOMEM);
976 navi_pos = get_bits_count(&s->gb);
978 for (band = 0; band < s->nfreqbands; band++) {
979 for (seg = 0; seg < s->nframesegs; seg++) {
980 for (chs = 0, c = s->chset; chs < s->nchsets; chs++, c++) {
982 if (c->nfreqbands > band) {
983 size = get_bits_long(&s->gb, s->seg_size_nbits);
984 if (size < 0 || size >= s->frame_size) {
985 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI segment size (%d bytes)\n", size);
986 return AVERROR_INVALIDDATA;
997 skip_bits(&s->gb, -get_bits_count(&s->gb) & 7);
998 skip_bits(&s->gb, 16);
1001 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
1002 && ff_dca_check_crc(&s->gb, navi_pos, get_bits_count(&s->gb))) {
1003 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI checksum\n");
1004 return AVERROR_INVALIDDATA;
1010 static int parse_band_data(DCAXllDecoder *s)
1012 int ret, chs, seg, band, navi_pos, *navi_ptr;
1015 for (chs = 0, c = s->chset; chs < s->nactivechsets; chs++, c++) {
1016 if ((ret = chs_alloc_msb_band_data(s, c)) < 0)
1018 if ((ret = chs_alloc_lsb_band_data(s, c)) < 0)
1022 navi_pos = get_bits_count(&s->gb);
1024 for (band = 0; band < s->nfreqbands; band++) {
1025 for (seg = 0; seg < s->nframesegs; seg++) {
1026 for (chs = 0, c = s->chset; chs < s->nchsets; chs++, c++) {
1027 if (c->nfreqbands > band) {
1028 navi_pos += *navi_ptr * 8;
1029 if (navi_pos > s->gb.size_in_bits) {
1030 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI position\n");
1031 return AVERROR_INVALIDDATA;
1033 if (chs < s->nactivechsets &&
1034 (ret = chs_parse_band_data(s, c, band, seg, navi_pos)) < 0) {
1035 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1037 chs_clear_band_data(s, c, band, seg);
1039 s->gb.index = navi_pos;
1049 static int parse_frame(DCAXllDecoder *s, uint8_t *data, int size, DCAExssAsset *asset)
1053 if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
1055 if ((ret = parse_common_header(s)) < 0)
1057 if ((ret = parse_sub_headers(s, asset)) < 0)
1059 if ((ret = parse_navi_table(s)) < 0)
1061 if ((ret = parse_band_data(s)) < 0)
1063 if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) {
1064 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL frame\n");
1065 return AVERROR_INVALIDDATA;
1070 static void clear_pbr(DCAXllDecoder *s)
1076 static int copy_to_pbr(DCAXllDecoder *s, uint8_t *data, int size, int delay)
1078 if (size > DCA_XLL_PBR_BUFFER_MAX)
1079 return AVERROR(ENOSPC);
1081 if (!s->pbr_buffer && !(s->pbr_buffer = av_malloc(DCA_XLL_PBR_BUFFER_MAX + DCA_BUFFER_PADDING_SIZE)))
1082 return AVERROR(ENOMEM);
1084 memcpy(s->pbr_buffer, data, size);
1085 s->pbr_length = size;
1086 s->pbr_delay = delay;
1090 static int parse_frame_no_pbr(DCAXllDecoder *s, uint8_t *data, int size, DCAExssAsset *asset)
1092 int ret = parse_frame(s, data, size, asset);
1094 // If XLL packet data didn't start with a sync word, we must have jumped
1095 // right into the middle of PBR smoothing period
1096 if (ret == AVERROR(EAGAIN) && asset->xll_sync_present && asset->xll_sync_offset < size) {
1097 // Skip to the next sync word in this packet
1098 data += asset->xll_sync_offset;
1099 size -= asset->xll_sync_offset;
1101 // If decoding delay is set, put the frame into PBR buffer and return
1102 // failure code. Higher level decoder is expected to switch to lossy
1103 // core decoding or mute its output until decoding delay expires.
1104 if (asset->xll_delay_nframes > 0) {
1105 if ((ret = copy_to_pbr(s, data, size, asset->xll_delay_nframes)) < 0)
1107 return AVERROR(EAGAIN);
1110 // No decoding delay, just parse the frame in place
1111 ret = parse_frame(s, data, size, asset);
1117 if (s->frame_size > size)
1118 return AVERROR(EINVAL);
1120 // If the XLL decoder didn't consume full packet, start PBR smoothing period
1121 if (s->frame_size < size)
1122 if ((ret = copy_to_pbr(s, data + s->frame_size, size - s->frame_size, 0)) < 0)
1128 static int parse_frame_pbr(DCAXllDecoder *s, uint8_t *data, int size, DCAExssAsset *asset)
1132 if (size > DCA_XLL_PBR_BUFFER_MAX - s->pbr_length) {
1133 ret = AVERROR(ENOSPC);
1137 memcpy(s->pbr_buffer + s->pbr_length, data, size);
1138 s->pbr_length += size;
1140 // Respect decoding delay after synchronization error
1141 if (s->pbr_delay > 0 && --s->pbr_delay)
1142 return AVERROR(EAGAIN);
1144 if ((ret = parse_frame(s, s->pbr_buffer, s->pbr_length, asset)) < 0)
1147 if (s->frame_size > s->pbr_length) {
1148 ret = AVERROR(EINVAL);
1152 if (s->frame_size == s->pbr_length) {
1153 // End of PBR smoothing period
1156 s->pbr_length -= s->frame_size;
1157 memmove(s->pbr_buffer, s->pbr_buffer + s->frame_size, s->pbr_length);
1163 // For now, throw out all PBR state on failure.
1164 // Perhaps we can be smarter and try to resync somehow.
1169 int ff_dca_xll_parse(DCAXllDecoder *s, uint8_t *data, DCAExssAsset *asset)
1173 if (s->hd_stream_id != asset->hd_stream_id) {
1175 s->hd_stream_id = asset->hd_stream_id;
1179 ret = parse_frame_pbr(s, data + asset->xll_offset, asset->xll_size, asset);
1181 ret = parse_frame_no_pbr(s, data + asset->xll_offset, asset->xll_size, asset);
1186 static void undo_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band)
1188 int i, j, k, nchannels = 0, *coeff_ptr = o->dmix_coeff;
1191 for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) {
1195 av_assert1(band < c->nfreqbands);
1196 for (j = 0; j < c->nchannels; j++) {
1197 for (k = 0; k < o->nchannels; k++) {
1198 int coeff = *coeff_ptr++;
1200 s->dcadsp->dmix_sub(c->bands[band].msb_sample_buffer[j],
1201 o->bands[band].msb_sample_buffer[k],
1202 coeff, s->nframesamples);
1204 s->dcadsp->dmix_sub(c->deci_history[j],
1206 coeff, DCA_XLL_DECI_HISTORY_MAX);
1211 nchannels += c->nchannels;
1212 if (nchannels >= o->hier_ofs)
1217 static void scale_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band)
1219 int i, j, nchannels = 0;
1222 for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) {
1226 av_assert1(band < c->nfreqbands);
1227 for (j = 0; j < c->nchannels; j++) {
1228 int scale = o->dmix_scale[nchannels++];
1229 if (scale != (1 << 15)) {
1230 s->dcadsp->dmix_scale(c->bands[band].msb_sample_buffer[j],
1231 scale, s->nframesamples);
1233 s->dcadsp->dmix_scale(c->deci_history[j],
1234 scale, DCA_XLL_DECI_HISTORY_MAX);
1238 if (nchannels >= o->hier_ofs)
1243 // Clear all band data and replace non-residual encoded channels with lossy
1245 static void av_cold force_lossy_output(DCAXllDecoder *s, DCAXllChSet *c)
1247 DCAContext *dca = s->avctx->priv_data;
1250 for (band = 0; band < c->nfreqbands; band++)
1251 chs_clear_band_data(s, c, band, -1);
1253 for (ch = 0; ch < c->nchannels; ch++) {
1254 if (!(c->residual_encode & (1 << ch)))
1256 if (ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]) < 0)
1258 c->residual_encode &= ~(1 << ch);
1262 static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c)
1264 DCAContext *dca = s->avctx->priv_data;
1265 int ch, nsamples = s->nframesamples;
1268 // Verify that core is compatible
1269 if (!(dca->packet & DCA_PACKET_CORE)) {
1270 av_log(s->avctx, AV_LOG_ERROR, "Residual encoded channels are present without core\n");
1271 return AVERROR(EINVAL);
1274 if (c->freq != dca->core.output_rate) {
1275 av_log(s->avctx, AV_LOG_WARNING, "Sample rate mismatch between core (%d Hz) and XLL (%d Hz)\n", dca->core.output_rate, c->freq);
1276 return AVERROR_INVALIDDATA;
1279 if (nsamples != dca->core.npcmsamples) {
1280 av_log(s->avctx, AV_LOG_WARNING, "Number of samples per frame mismatch between core (%d) and XLL (%d)\n", dca->core.npcmsamples, nsamples);
1281 return AVERROR_INVALIDDATA;
1284 // See if this channel set is downmixed and find the next channel set in
1285 // hierarchy. If downmixed, undo core pre-scaling before combining with
1286 // residual (residual is not scaled).
1287 o = find_next_hier_dmix_chset(s, c);
1289 // Reduce core bit width and combine with residual
1290 for (ch = 0; ch < c->nchannels; ch++) {
1291 int n, spkr, shift, round;
1294 if (c->residual_encode & (1 << ch))
1297 // Map this channel to core speaker
1298 spkr = ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]);
1300 av_log(s->avctx, AV_LOG_WARNING, "Residual encoded channel (%d) references unavailable core channel\n", c->ch_remap[ch]);
1301 return AVERROR_INVALIDDATA;
1304 // Account for LSB width
1305 shift = 24 - c->pcm_bit_res + chs_get_lsb_width(s, c, 0, ch);
1307 av_log(s->avctx, AV_LOG_WARNING, "Invalid core shift (%d bits)\n", shift);
1308 return AVERROR_INVALIDDATA;
1311 round = shift > 0 ? 1 << (shift - 1) : 0;
1313 src = dca->core.output_samples[spkr];
1314 dst = c->bands[0].msb_sample_buffer[ch];
1316 // Undo embedded core downmix pre-scaling
1317 int scale_inv = o->dmix_scale_inv[c->hier_ofs + ch];
1318 for (n = 0; n < nsamples; n++)
1319 dst[n] += clip23((mul16(src[n], scale_inv) + round) >> shift);
1321 // No downmix scaling
1322 for (n = 0; n < nsamples; n++)
1323 dst[n] += (src[n] + round) >> shift;
1330 int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
1332 AVCodecContext *avctx = s->avctx;
1333 DCAContext *dca = avctx->priv_data;
1334 DCAExssAsset *asset = &dca->exss.assets[0];
1335 DCAXllChSet *p = &s->chset[0], *c;
1336 enum AVMatrixEncoding matrix_encoding = AV_MATRIX_ENCODING_NONE;
1337 int i, j, k, ret, shift, nsamples, request_mask;
1338 int ch_remap[DCA_SPEAKER_COUNT];
1340 // Force lossy downmixed output during recovery
1341 if (dca->packet & DCA_PACKET_RECOVERY) {
1342 for (i = 0, c = s->chset; i < s->nchsets; i++, c++) {
1343 if (i < s->nactivechsets)
1344 force_lossy_output(s, c);
1346 if (!c->primary_chset)
1347 c->dmix_embedded = 0;
1350 s->scalable_lsbs = 0;
1351 s->fixed_lsb_width = 0;
1354 // Filter frequency bands for active channel sets
1356 for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) {
1357 chs_filter_band_data(s, c, 0);
1359 if (c->residual_encode != (1 << c->nchannels) - 1
1360 && (ret = combine_residual_frame(s, c)) < 0)
1363 if (s->scalable_lsbs)
1364 chs_assemble_msbs_lsbs(s, c, 0);
1366 if (c->nfreqbands > 1) {
1367 chs_filter_band_data(s, c, 1);
1368 chs_assemble_msbs_lsbs(s, c, 1);
1371 s->output_mask |= c->ch_mask;
1374 // Undo hierarchial downmix and/or apply scaling
1375 for (i = 1, c = &s->chset[1]; i < s->nchsets; i++, c++) {
1376 if (!is_hier_dmix_chset(c))
1379 if (i >= s->nactivechsets) {
1380 for (j = 0; j < c->nfreqbands; j++)
1381 if (c->bands[j].dmix_embedded)
1382 scale_down_mix(s, c, j);
1386 for (j = 0; j < c->nfreqbands; j++)
1387 if (c->bands[j].dmix_embedded)
1388 undo_down_mix(s, c, j);
1391 // Assemble frequency bands for active channel sets
1392 if (s->nfreqbands > 1) {
1393 for (i = 0; i < s->nactivechsets; i++)
1394 if ((ret = chs_assemble_freq_bands(s, &s->chset[i])) < 0)
1398 // Normalize to regular 5.1 layout if downmixing
1399 if (dca->request_channel_layout) {
1400 if (s->output_mask & DCA_SPEAKER_MASK_Lss) {
1401 s->output_samples[DCA_SPEAKER_Ls] = s->output_samples[DCA_SPEAKER_Lss];
1402 s->output_mask = (s->output_mask & ~DCA_SPEAKER_MASK_Lss) | DCA_SPEAKER_MASK_Ls;
1404 if (s->output_mask & DCA_SPEAKER_MASK_Rss) {
1405 s->output_samples[DCA_SPEAKER_Rs] = s->output_samples[DCA_SPEAKER_Rss];
1406 s->output_mask = (s->output_mask & ~DCA_SPEAKER_MASK_Rss) | DCA_SPEAKER_MASK_Rs;
1410 // Handle downmixing to stereo request
1411 if (dca->request_channel_layout == DCA_SPEAKER_LAYOUT_STEREO
1412 && DCA_HAS_STEREO(s->output_mask) && p->dmix_embedded
1413 && (p->dmix_type == DCA_DMIX_TYPE_LoRo ||
1414 p->dmix_type == DCA_DMIX_TYPE_LtRt))
1415 request_mask = DCA_SPEAKER_LAYOUT_STEREO;
1417 request_mask = s->output_mask;
1418 if (!ff_dca_set_channel_layout(avctx, ch_remap, request_mask))
1419 return AVERROR(EINVAL);
1421 avctx->sample_rate = p->freq << (s->nfreqbands - 1);
1423 switch (p->storage_bit_res) {
1425 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
1428 avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
1431 return AVERROR(EINVAL);
1434 avctx->bits_per_raw_sample = p->storage_bit_res;
1435 avctx->profile = FF_PROFILE_DTS_HD_MA;
1436 avctx->bit_rate = 0;
1438 frame->nb_samples = nsamples = s->nframesamples << (s->nfreqbands - 1);
1439 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1442 // Downmix primary channel set to stereo
1443 if (request_mask != s->output_mask) {
1444 ff_dca_downmix_to_stereo_fixed(s->dcadsp, s->output_samples,
1445 p->dmix_coeff, nsamples,
1449 shift = p->storage_bit_res - p->pcm_bit_res;
1450 for (i = 0; i < avctx->channels; i++) {
1451 int32_t *samples = s->output_samples[ch_remap[i]];
1452 if (frame->format == AV_SAMPLE_FMT_S16P) {
1453 int16_t *plane = (int16_t *)frame->extended_data[i];
1454 for (k = 0; k < nsamples; k++)
1455 plane[k] = av_clip_int16(samples[k] * (1 << shift));
1457 int32_t *plane = (int32_t *)frame->extended_data[i];
1458 for (k = 0; k < nsamples; k++)
1459 plane[k] = clip23(samples[k] * (1 << shift)) * (1 << 8);
1463 if (!asset->one_to_one_map_ch_to_spkr) {
1464 if (asset->representation_type == DCA_REPR_TYPE_LtRt)
1465 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1466 else if (asset->representation_type == DCA_REPR_TYPE_LhRh)
1467 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1468 } else if (request_mask != s->output_mask && p->dmix_type == DCA_DMIX_TYPE_LtRt) {
1469 matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1471 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1477 av_cold void ff_dca_xll_flush(DCAXllDecoder *s)
1482 av_cold void ff_dca_xll_close(DCAXllDecoder *s)
1487 for (i = 0, c = s->chset; i < DCA_XLL_CHSETS_MAX; i++, c++) {
1488 for (j = 0; j < DCA_XLL_SAMPLE_BUFFERS_MAX; j++) {
1489 av_freep(&c->sample_buffer[j]);
1490 c->sample_size[j] = 0;
1497 av_freep(&s->pbr_buffer);