avcodec/dca: add new decoder based on libdcadec
[ffmpeg.git] / libavcodec / dca_core.c
1 /*
2  * Copyright (C) 2016 foo86
3  *
4  * This file is part of FFmpeg.
5  *
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.
10  *
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.
15  *
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
19  */
20
21 #include "dcadec.h"
22 #include "dcadata.h"
23 #include "dcahuff.h"
24 #include "dcamath.h"
25 #include "dca_syncwords.h"
26
27 #if ARCH_ARM
28 #include "arm/dca.h"
29 #endif
30
31 enum HeaderType {
32     HEADER_CORE,
33     HEADER_XCH,
34     HEADER_XXCH
35 };
36
37 enum AudioMode {
38     AMODE_MONO,             // Mode 0: A (mono)
39     AMODE_MONO_DUAL,        // Mode 1: A + B (dual mono)
40     AMODE_STEREO,           // Mode 2: L + R (stereo)
41     AMODE_STEREO_SUMDIFF,   // Mode 3: (L+R) + (L-R) (sum-diff)
42     AMODE_STEREO_TOTAL,     // Mode 4: LT + RT (left and right total)
43     AMODE_3F,               // Mode 5: C + L + R
44     AMODE_2F1R,             // Mode 6: L + R + S
45     AMODE_3F1R,             // Mode 7: C + L + R + S
46     AMODE_2F2R,             // Mode 8: L + R + SL + SR
47     AMODE_3F2R,             // Mode 9: C + L + R + SL + SR
48
49     AMODE_COUNT
50 };
51
52 enum ExtAudioType {
53     EXT_AUDIO_XCH   = 0,
54     EXT_AUDIO_X96   = 2,
55     EXT_AUDIO_XXCH  = 6
56 };
57
58 enum LFEFlag {
59     LFE_FLAG_NONE,
60     LFE_FLAG_128,
61     LFE_FLAG_64,
62     LFE_FLAG_INVALID
63 };
64
65 static const int8_t prm_ch_to_spkr_map[AMODE_COUNT][5] = {
66     { DCA_SPEAKER_C,            -1,             -1,             -1,             -1 },
67     { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },
68     { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },
69     { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },
70     { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },
71     { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R ,             -1,             -1 },
72     { DCA_SPEAKER_L, DCA_SPEAKER_R, DCA_SPEAKER_Cs,             -1,             -1 },
73     { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R , DCA_SPEAKER_Cs,             -1 },
74     { DCA_SPEAKER_L, DCA_SPEAKER_R, DCA_SPEAKER_Ls, DCA_SPEAKER_Rs,             -1 },
75     { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R,  DCA_SPEAKER_Ls, DCA_SPEAKER_Rs }
76 };
77
78 static const uint8_t audio_mode_ch_mask[AMODE_COUNT] = {
79     DCA_SPEAKER_LAYOUT_MONO,
80     DCA_SPEAKER_LAYOUT_STEREO,
81     DCA_SPEAKER_LAYOUT_STEREO,
82     DCA_SPEAKER_LAYOUT_STEREO,
83     DCA_SPEAKER_LAYOUT_STEREO,
84     DCA_SPEAKER_LAYOUT_3_0,
85     DCA_SPEAKER_LAYOUT_2_1,
86     DCA_SPEAKER_LAYOUT_3_1,
87     DCA_SPEAKER_LAYOUT_2_2,
88     DCA_SPEAKER_LAYOUT_5POINT0
89 };
90
91 static const uint8_t block_code_nbits[7] = {
92     7, 10, 12, 13, 15, 17, 19
93 };
94
95 static const uint8_t quant_index_sel_nbits[DCA_CODE_BOOKS] = {
96     1, 2, 2, 2, 2, 3, 3, 3, 3, 3
97 };
98
99 static const uint8_t quant_index_group_size[DCA_CODE_BOOKS] = {
100     1, 3, 3, 3, 3, 7, 7, 7, 7, 7
101 };
102
103 typedef struct DCAVLC {
104     int offset;         ///< Code values offset
105     int max_depth;      ///< Parameter for get_vlc2()
106     VLC vlc[7];         ///< Actual codes
107 } DCAVLC;
108
109 static DCAVLC   vlc_bit_allocation;
110 static DCAVLC   vlc_transition_mode;
111 static DCAVLC   vlc_scale_factor;
112 static DCAVLC   vlc_quant_index[DCA_CODE_BOOKS];
113
114 static av_cold void dca_init_vlcs(void)
115 {
116     static VLC_TYPE dca_table[23622][2];
117     static int vlcs_initialized = 0;
118     int i, j, k;
119
120     if (vlcs_initialized)
121         return;
122
123 #define DCA_INIT_VLC(vlc, a, b, c, d)                                      \
124     do {                                                                   \
125         vlc.table           = &dca_table[ff_dca_vlc_offs[k]];              \
126         vlc.table_allocated = ff_dca_vlc_offs[k + 1] - ff_dca_vlc_offs[k]; \
127         init_vlc(&vlc, a, b, c, 1, 1, d, 2, 2, INIT_VLC_USE_NEW_STATIC);   \
128     } while (0)
129
130     vlc_bit_allocation.offset    = 1;
131     vlc_bit_allocation.max_depth = 2;
132     for (i = 0, k = 0; i < 5; i++, k++)
133         DCA_INIT_VLC(vlc_bit_allocation.vlc[i], bitalloc_12_vlc_bits[i], 12,
134                      bitalloc_12_bits[i], bitalloc_12_codes[i]);
135
136     vlc_scale_factor.offset    = -64;
137     vlc_scale_factor.max_depth = 2;
138     for (i = 0; i < 5; i++, k++)
139         DCA_INIT_VLC(vlc_scale_factor.vlc[i], SCALES_VLC_BITS, 129,
140                      scales_bits[i], scales_codes[i]);
141
142     vlc_transition_mode.offset    = 0;
143     vlc_transition_mode.max_depth = 1;
144     for (i = 0; i < 4; i++, k++)
145         DCA_INIT_VLC(vlc_transition_mode.vlc[i], tmode_vlc_bits[i], 4,
146                      tmode_bits[i], tmode_codes[i]);
147
148     for (i = 0; i < DCA_CODE_BOOKS; i++) {
149         vlc_quant_index[i].offset    = bitalloc_offsets[i];
150         vlc_quant_index[i].max_depth = 1 + (i > 4);
151         for (j = 0; j < quant_index_group_size[i]; j++, k++)
152             DCA_INIT_VLC(vlc_quant_index[i].vlc[j], bitalloc_maxbits[i][j],
153                          bitalloc_sizes[i], bitalloc_bits[i][j], bitalloc_codes[i][j]);
154     }
155
156     vlcs_initialized = 1;
157 }
158
159 static int get_vlc(GetBitContext *s, DCAVLC *v, int i)
160 {
161     return get_vlc2(s, v->vlc[i].table, v->vlc[i].bits, v->max_depth) + v->offset;
162 }
163
164 static void get_array(GetBitContext *s, int32_t *array, int size, int n)
165 {
166     int i;
167
168     for (i = 0; i < size; i++)
169         array[i] = get_sbits(s, n);
170 }
171
172 // 5.3.1 - Bit stream header
173 static int parse_frame_header(DCACoreDecoder *s)
174 {
175     int normal_frame, pcmr_index;
176
177     // Frame type
178     normal_frame = get_bits1(&s->gb);
179
180     // Deficit sample count
181     if (get_bits(&s->gb, 5) != DCA_PCMBLOCK_SAMPLES - 1) {
182         av_log(s->avctx, AV_LOG_ERROR, "Deficit samples are not supported\n");
183         return normal_frame ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;
184     }
185
186     // CRC present flag
187     s->crc_present = get_bits1(&s->gb);
188
189     // Number of PCM sample blocks
190     s->npcmblocks = get_bits(&s->gb, 7) + 1;
191     if (s->npcmblocks & (DCA_SUBBAND_SAMPLES - 1)) {
192         av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of PCM sample blocks (%d)\n", s->npcmblocks);
193         return (s->npcmblocks < 6 || normal_frame) ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;
194     }
195
196     // Primary frame byte size
197     s->frame_size = get_bits(&s->gb, 14) + 1;
198     if (s->frame_size < 96) {
199         av_log(s->avctx, AV_LOG_ERROR, "Invalid core frame size (%d bytes)\n", s->frame_size);
200         return AVERROR_INVALIDDATA;
201     }
202
203     // Audio channel arrangement
204     s->audio_mode = get_bits(&s->gb, 6);
205     if (s->audio_mode >= AMODE_COUNT) {
206         av_log(s->avctx, AV_LOG_ERROR, "Unsupported audio channel arrangement (%d)\n", s->audio_mode);
207         return AVERROR_PATCHWELCOME;
208     }
209
210     // Core audio sampling frequency
211     s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
212     if (!s->sample_rate) {
213         av_log(s->avctx, AV_LOG_ERROR, "Invalid core audio sampling frequency\n");
214         return AVERROR_INVALIDDATA;
215     }
216
217     // Transmission bit rate
218     s->bit_rate = ff_dca_bit_rates[get_bits(&s->gb, 5)];
219
220     // Reserved field
221     skip_bits1(&s->gb);
222
223     // Embedded dynamic range flag
224     s->drc_present = get_bits1(&s->gb);
225
226     // Embedded time stamp flag
227     s->ts_present = get_bits1(&s->gb);
228
229     // Auxiliary data flag
230     s->aux_present = get_bits1(&s->gb);
231
232     // HDCD mastering flag
233     skip_bits1(&s->gb);
234
235     // Extension audio descriptor flag
236     s->ext_audio_type = get_bits(&s->gb, 3);
237
238     // Extended coding flag
239     s->ext_audio_present = get_bits1(&s->gb);
240
241     // Audio sync word insertion flag
242     s->sync_ssf = get_bits1(&s->gb);
243
244     // Low frequency effects flag
245     s->lfe_present = get_bits(&s->gb, 2);
246     if (s->lfe_present == LFE_FLAG_INVALID) {
247         av_log(s->avctx, AV_LOG_ERROR, "Invalid low frequency effects flag\n");
248         return AVERROR_INVALIDDATA;
249     }
250
251     // Predictor history flag switch
252     s->predictor_history = get_bits1(&s->gb);
253
254     // Header CRC check bytes
255     if (s->crc_present)
256         skip_bits(&s->gb, 16);
257
258     // Multirate interpolator switch
259     s->filter_perfect = get_bits1(&s->gb);
260
261     // Encoder software revision
262     skip_bits(&s->gb, 4);
263
264     // Copy history
265     skip_bits(&s->gb, 2);
266
267     // Source PCM resolution
268     s->source_pcm_res = ff_dca_bits_per_sample[pcmr_index = get_bits(&s->gb, 3)];
269     if (!s->source_pcm_res) {
270         av_log(s->avctx, AV_LOG_ERROR, "Invalid source PCM resolution\n");
271         return AVERROR_INVALIDDATA;
272     }
273     s->es_format = pcmr_index & 1;
274
275     // Front sum/difference flag
276     s->sumdiff_front = get_bits1(&s->gb);
277
278     // Surround sum/difference flag
279     s->sumdiff_surround = get_bits1(&s->gb);
280
281     // Dialog normalization / unspecified
282     skip_bits(&s->gb, 4);
283
284     return 0;
285 }
286
287 // 5.3.2 - Primary audio coding header
288 static int parse_coding_header(DCACoreDecoder *s, enum HeaderType header, int xch_base)
289 {
290     int n, ch, nchannels, header_size = 0, header_pos = get_bits_count(&s->gb);
291     unsigned int mask, index;
292
293     if (get_bits_left(&s->gb) < 0)
294         return AVERROR_INVALIDDATA;
295
296     switch (header) {
297     case HEADER_CORE:
298         // Number of subframes
299         s->nsubframes = get_bits(&s->gb, 4) + 1;
300
301         // Number of primary audio channels
302         s->nchannels = get_bits(&s->gb, 3) + 1;
303         if (s->nchannels != ff_dca_channels[s->audio_mode]) {
304             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);
305             return AVERROR_INVALIDDATA;
306         }
307         av_assert1(s->nchannels <= DCA_CHANNELS - 2);
308
309         s->ch_mask = audio_mode_ch_mask[s->audio_mode];
310
311         // Add LFE channel if present
312         if (s->lfe_present)
313             s->ch_mask |= DCA_SPEAKER_MASK_LFE1;
314         break;
315
316     case HEADER_XCH:
317         s->nchannels = ff_dca_channels[s->audio_mode] + 1;
318         av_assert1(s->nchannels <= DCA_CHANNELS - 1);
319         s->ch_mask |= DCA_SPEAKER_MASK_Cs;
320         break;
321
322     case HEADER_XXCH:
323         // Channel set header length
324         header_size = get_bits(&s->gb, 7) + 1;
325
326         // Check CRC
327         if (s->xxch_crc_present
328             && (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
329             && ff_dca_check_crc(&s->gb, header_pos, header_pos + header_size * 8)) {
330             av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH channel set header checksum\n");
331             return AVERROR_INVALIDDATA;
332         }
333
334         // Number of channels in a channel set
335         nchannels = get_bits(&s->gb, 3) + 1;
336         if (nchannels > DCA_XXCH_CHANNELS_MAX) {
337             avpriv_request_sample(s->avctx, "%d XXCH channels", nchannels);
338             return AVERROR_PATCHWELCOME;
339         }
340         s->nchannels = ff_dca_channels[s->audio_mode] + nchannels;
341         av_assert1(s->nchannels <= DCA_CHANNELS);
342
343         // Loudspeaker layout mask
344         mask = get_bits_long(&s->gb, s->xxch_mask_nbits - DCA_SPEAKER_Cs);
345         s->xxch_spkr_mask = mask << DCA_SPEAKER_Cs;
346
347         if (av_popcount(s->xxch_spkr_mask) != nchannels) {
348             av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH speaker layout mask (%#x)\n", s->xxch_spkr_mask);
349             return AVERROR_INVALIDDATA;
350         }
351
352         if (s->xxch_core_mask & s->xxch_spkr_mask) {
353             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);
354             return AVERROR_INVALIDDATA;
355         }
356
357         // Combine core and XXCH masks together
358         s->ch_mask = s->xxch_core_mask | s->xxch_spkr_mask;
359
360         // Downmix coefficients present in stream
361         if (get_bits1(&s->gb)) {
362             int *coeff_ptr = s->xxch_dmix_coeff;
363
364             // Downmix already performed by encoder
365             s->xxch_dmix_embedded = get_bits1(&s->gb);
366
367             // Downmix scale factor
368             index = get_bits(&s->gb, 6) * 4 - FF_DCA_DMIXTABLE_OFFSET - 3;
369             if (index >= FF_DCA_INV_DMIXTABLE_SIZE) {
370                 av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH downmix scale index (%d)\n", index);
371                 return AVERROR_INVALIDDATA;
372             }
373             s->xxch_dmix_scale_inv = ff_dca_inv_dmixtable[index];
374
375             // Downmix channel mapping mask
376             for (ch = 0; ch < nchannels; ch++) {
377                 mask = get_bits_long(&s->gb, s->xxch_mask_nbits);
378                 if ((mask & s->xxch_core_mask) != mask) {
379                     av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH downmix channel mapping mask (%#x)\n", mask);
380                     return AVERROR_INVALIDDATA;
381                 }
382                 s->xxch_dmix_mask[ch] = mask;
383             }
384
385             // Downmix coefficients
386             for (ch = 0; ch < nchannels; ch++) {
387                 for (n = 0; n < s->xxch_mask_nbits; n++) {
388                     if (s->xxch_dmix_mask[ch] & (1U << n)) {
389                         int code = get_bits(&s->gb, 7);
390                         int sign = (code >> 6) - 1;
391                         if (code &= 63) {
392                             index = code * 4 - 3;
393                             if (index >= FF_DCA_DMIXTABLE_SIZE) {
394                                 av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH downmix coefficient index (%d)\n", index);
395                                 return AVERROR_INVALIDDATA;
396                             }
397                             *coeff_ptr++ = (ff_dca_dmixtable[index] ^ sign) - sign;
398                         } else {
399                             *coeff_ptr++ = 0;
400                         }
401                     }
402                 }
403             }
404         } else {
405             s->xxch_dmix_embedded = 0;
406         }
407
408         break;
409     }
410
411     // Subband activity count
412     for (ch = xch_base; ch < s->nchannels; ch++) {
413         s->nsubbands[ch] = get_bits(&s->gb, 5) + 2;
414         if (s->nsubbands[ch] > DCA_SUBBANDS) {
415             av_log(s->avctx, AV_LOG_ERROR, "Invalid subband activity count\n");
416             return AVERROR_INVALIDDATA;
417         }
418     }
419
420     // High frequency VQ start subband
421     for (ch = xch_base; ch < s->nchannels; ch++)
422         s->subband_vq_start[ch] = get_bits(&s->gb, 5) + 1;
423
424     // Joint intensity coding index
425     for (ch = xch_base; ch < s->nchannels; ch++) {
426         if ((n = get_bits(&s->gb, 3)) && header == HEADER_XXCH)
427             n += xch_base - 1;
428         if (n > s->nchannels) {
429             av_log(s->avctx, AV_LOG_ERROR, "Invalid joint intensity coding index\n");
430             return AVERROR_INVALIDDATA;
431         }
432         s->joint_intensity_index[ch] = n;
433     }
434
435     // Transient mode code book
436     for (ch = xch_base; ch < s->nchannels; ch++)
437         s->transition_mode_sel[ch] = get_bits(&s->gb, 2);
438
439     // Scale factor code book
440     for (ch = xch_base; ch < s->nchannels; ch++) {
441         s->scale_factor_sel[ch] = get_bits(&s->gb, 3);
442         if (s->scale_factor_sel[ch] == 7) {
443             av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor code book\n");
444             return AVERROR_INVALIDDATA;
445         }
446     }
447
448     // Bit allocation quantizer select
449     for (ch = xch_base; ch < s->nchannels; ch++) {
450         s->bit_allocation_sel[ch] = get_bits(&s->gb, 3);
451         if (s->bit_allocation_sel[ch] == 7) {
452             av_log(s->avctx, AV_LOG_ERROR, "Invalid bit allocation quantizer select\n");
453             return AVERROR_INVALIDDATA;
454         }
455     }
456
457     // Quantization index codebook select
458     for (n = 0; n < DCA_CODE_BOOKS; n++)
459         for (ch = xch_base; ch < s->nchannels; ch++)
460             s->quant_index_sel[ch][n] = get_bits(&s->gb, quant_index_sel_nbits[n]);
461
462     // Scale factor adjustment index
463     for (n = 0; n < DCA_CODE_BOOKS; n++)
464         for (ch = xch_base; ch < s->nchannels; ch++)
465             if (s->quant_index_sel[ch][n] < quant_index_group_size[n])
466                 s->scale_factor_adj[ch][n] = ff_dca_scale_factor_adj[get_bits(&s->gb, 2)];
467
468     if (header == HEADER_XXCH) {
469         // Reserved
470         // Byte align
471         // CRC16 of channel set header
472         if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {
473             av_log(s->avctx, AV_LOG_ERROR, "Read past end of XXCH channel set header\n");
474             return AVERROR_INVALIDDATA;
475         }
476     } else {
477         // Audio header CRC check word
478         if (s->crc_present)
479             skip_bits(&s->gb, 16);
480     }
481
482     return 0;
483 }
484
485 static inline int parse_scale(DCACoreDecoder *s, int *scale_index, int sel)
486 {
487     const uint32_t *scale_table;
488     unsigned int scale_size;
489
490     // Select the root square table
491     if (sel > 5) {
492         scale_table = ff_dca_scale_factor_quant7;
493         scale_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant7);
494     } else {
495         scale_table = ff_dca_scale_factor_quant6;
496         scale_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant6);
497     }
498
499     // If Huffman code was used, the difference of scales was encoded
500     if (sel < 5)
501         *scale_index += get_vlc(&s->gb, &vlc_scale_factor, sel);
502     else
503         *scale_index = get_bits(&s->gb, sel + 1);
504
505     // Look up scale factor from the root square table
506     if ((unsigned int)*scale_index >= scale_size) {
507         av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor index\n");
508         return AVERROR_INVALIDDATA;
509     }
510
511     return scale_table[*scale_index];
512 }
513
514 static inline int parse_joint_scale(DCACoreDecoder *s, int sel)
515 {
516     int scale_index;
517
518     // Absolute value was encoded even when Huffman code was used
519     if (sel < 5)
520         scale_index = get_vlc(&s->gb, &vlc_scale_factor, sel);
521     else
522         scale_index = get_bits(&s->gb, sel + 1);
523
524     // Bias by 64
525     scale_index += 64;
526
527     // Look up joint scale factor
528     if ((unsigned int)scale_index >= FF_ARRAY_ELEMS(ff_dca_joint_scale_factors)) {
529         av_log(s->avctx, AV_LOG_ERROR, "Invalid joint scale factor index\n");
530         return AVERROR_INVALIDDATA;
531     }
532
533     return ff_dca_joint_scale_factors[scale_index];
534 }
535
536 // 5.4.1 - Primary audio coding side information
537 static int parse_subframe_header(DCACoreDecoder *s, int sf,
538                                  enum HeaderType header, int xch_base)
539 {
540     int ch, band, ret;
541
542     if (get_bits_left(&s->gb) < 0)
543         return AVERROR_INVALIDDATA;
544
545     if (header == HEADER_CORE) {
546         // Subsubframe count
547         s->nsubsubframes[sf] = get_bits(&s->gb, 2) + 1;
548
549         // Partial subsubframe sample count
550         skip_bits(&s->gb, 3);
551     }
552
553     // Prediction mode
554     for (ch = xch_base; ch < s->nchannels; ch++)
555         for (band = 0; band < s->nsubbands[ch]; band++)
556             s->prediction_mode[ch][band] = get_bits1(&s->gb);
557
558     // Prediction coefficients VQ address
559     for (ch = xch_base; ch < s->nchannels; ch++)
560         for (band = 0; band < s->nsubbands[ch]; band++)
561             if (s->prediction_mode[ch][band])
562                 s->prediction_vq_index[ch][band] = get_bits(&s->gb, 12);
563
564     // Bit allocation index
565     for (ch = xch_base; ch < s->nchannels; ch++) {
566         int sel = s->bit_allocation_sel[ch];
567
568         for (band = 0; band < s->subband_vq_start[ch]; band++) {
569             int abits;
570
571             if (sel < 5)
572                 abits = get_vlc(&s->gb, &vlc_bit_allocation, sel);
573             else
574                 abits = get_bits(&s->gb, sel - 1);
575
576             if (abits > DCA_ABITS_MAX) {
577                 av_log(s->avctx, AV_LOG_ERROR, "Invalid bit allocation index\n");
578                 return AVERROR_INVALIDDATA;
579             }
580
581             s->bit_allocation[ch][band] = abits;
582         }
583     }
584
585     // Transition mode
586     for (ch = xch_base; ch < s->nchannels; ch++) {
587         // Clear transition mode for all subbands
588         memset(s->transition_mode[sf][ch], 0, sizeof(s->transition_mode[0][0]));
589
590         // Transient possible only if more than one subsubframe
591         if (s->nsubsubframes[sf] > 1) {
592             int sel = s->transition_mode_sel[ch];
593             for (band = 0; band < s->subband_vq_start[ch]; band++)
594                 if (s->bit_allocation[ch][band])
595                     s->transition_mode[sf][ch][band] = get_vlc(&s->gb, &vlc_transition_mode, sel);
596         }
597     }
598
599     // Scale factors
600     for (ch = xch_base; ch < s->nchannels; ch++) {
601         int sel = s->scale_factor_sel[ch];
602         int scale_index = 0;
603
604         // Extract scales for subbands up to VQ
605         for (band = 0; band < s->subband_vq_start[ch]; band++) {
606             if (s->bit_allocation[ch][band]) {
607                 if ((ret = parse_scale(s, &scale_index, sel)) < 0)
608                     return ret;
609                 s->scale_factors[ch][band][0] = ret;
610                 if (s->transition_mode[sf][ch][band]) {
611                     if ((ret = parse_scale(s, &scale_index, sel)) < 0)
612                         return ret;
613                     s->scale_factors[ch][band][1] = ret;
614                 }
615             } else {
616                 s->scale_factors[ch][band][0] = 0;
617             }
618         }
619
620         // High frequency VQ subbands
621         for (band = s->subband_vq_start[ch]; band < s->nsubbands[ch]; band++) {
622             if ((ret = parse_scale(s, &scale_index, sel)) < 0)
623                 return ret;
624             s->scale_factors[ch][band][0] = ret;
625         }
626     }
627
628     // Joint subband codebook select
629     for (ch = xch_base; ch < s->nchannels; ch++) {
630         if (s->joint_intensity_index[ch]) {
631             s->joint_scale_sel[ch] = get_bits(&s->gb, 3);
632             if (s->joint_scale_sel[ch] == 7) {
633                 av_log(s->avctx, AV_LOG_ERROR, "Invalid joint scale factor code book\n");
634                 return AVERROR_INVALIDDATA;
635             }
636         }
637     }
638
639     // Scale factors for joint subband coding
640     for (ch = xch_base; ch < s->nchannels; ch++) {
641         int src_ch = s->joint_intensity_index[ch] - 1;
642         if (src_ch >= 0) {
643             int sel = s->joint_scale_sel[ch];
644             for (band = s->nsubbands[ch]; band < s->nsubbands[src_ch]; band++) {
645                 if ((ret = parse_joint_scale(s, sel)) < 0)
646                     return ret;
647                 s->joint_scale_factors[ch][band] = ret;
648             }
649         }
650     }
651
652     // Dynamic range coefficient
653     if (s->drc_present && header == HEADER_CORE)
654         skip_bits(&s->gb, 8);
655
656     // Side information CRC check word
657     if (s->crc_present)
658         skip_bits(&s->gb, 16);
659
660     return 0;
661 }
662
663 #ifndef decode_blockcodes
664 static inline int decode_blockcodes(int code1, int code2, int levels, int32_t *audio)
665 {
666     int offset = (levels - 1) / 2;
667     int n, div;
668
669     for (n = 0; n < DCA_SUBBAND_SAMPLES / 2; n++) {
670         div = FASTDIV(code1, levels);
671         audio[n] = code1 - div * levels - offset;
672         code1 = div;
673     }
674     for (; n < DCA_SUBBAND_SAMPLES; n++) {
675         div = FASTDIV(code2, levels);
676         audio[n] = code2 - div * levels - offset;
677         code2 = div;
678     }
679
680     return code1 | code2;
681 }
682 #endif
683
684 static inline int parse_block_codes(DCACoreDecoder *s, int32_t *audio, int abits)
685 {
686     // Extract block code indices from the bit stream
687     int code1 = get_bits(&s->gb, block_code_nbits[abits - 1]);
688     int code2 = get_bits(&s->gb, block_code_nbits[abits - 1]);
689     int levels = ff_dca_quant_levels[abits];
690
691     // Look up samples from the block code book
692     if (decode_blockcodes(code1, code2, levels, audio)) {
693         av_log(s->avctx, AV_LOG_ERROR, "Failed to decode block code(s)\n");
694         return AVERROR_INVALIDDATA;
695     }
696
697     return 0;
698 }
699
700 static inline int parse_huffman_codes(DCACoreDecoder *s, int32_t *audio, int abits, int sel)
701 {
702     int i;
703
704     // Extract Huffman codes from the bit stream
705     for (i = 0; i < DCA_SUBBAND_SAMPLES; i++)
706         audio[i] = get_vlc(&s->gb, &vlc_quant_index[abits - 1], sel);
707
708     return 1;
709 }
710
711 static inline int extract_audio(DCACoreDecoder *s, int32_t *audio, int abits, int ch)
712 {
713     av_assert1(abits >= 0 && abits <= DCA_ABITS_MAX);
714
715     if (abits == 0) {
716         // No bits allocated
717         memset(audio, 0, DCA_SUBBAND_SAMPLES * sizeof(*audio));
718         return 0;
719     }
720
721     if (abits <= DCA_CODE_BOOKS) {
722         int sel = s->quant_index_sel[ch][abits - 1];
723         if (sel < quant_index_group_size[abits - 1]) {
724             // Huffman codes
725             return parse_huffman_codes(s, audio, abits, sel);
726         }
727         if (abits <= 7) {
728             // Block codes
729             return parse_block_codes(s, audio, abits);
730         }
731     }
732
733     // No further encoding
734     get_array(&s->gb, audio, DCA_SUBBAND_SAMPLES, abits - 3);
735     return 0;
736 }
737
738 static inline void dequantize(int32_t *output, const int32_t *input,
739                               int32_t step_size, int32_t scale, int residual)
740 {
741     // Account for quantizer step size
742     int64_t step_scale = (int64_t)step_size * scale;
743     int n, shift = 0;
744
745     // Limit scale factor resolution to 22 bits
746     if (step_scale > (1 << 23)) {
747         shift = av_log2(step_scale >> 23) + 1;
748         step_scale >>= shift;
749     }
750
751     // Scale the samples
752     if (residual) {
753         for (n = 0; n < DCA_SUBBAND_SAMPLES; n++)
754             output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));
755     } else {
756         for (n = 0; n < DCA_SUBBAND_SAMPLES; n++)
757             output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));
758     }
759 }
760
761 static inline void inverse_adpcm(int32_t **subband_samples,
762                                  const int16_t *vq_index,
763                                  const int8_t *prediction_mode,
764                                  int sb_start, int sb_end,
765                                  int ofs, int len)
766 {
767     int i, j, k;
768
769     for (i = sb_start; i < sb_end; i++) {
770         if (prediction_mode[i]) {
771             const int16_t *coeff = ff_dca_adpcm_vb[vq_index[i]];
772             int32_t *ptr = subband_samples[i] + ofs;
773             for (j = 0; j < len; j++) {
774                 int64_t err = 0;
775                 for (k = 0; k < DCA_ADPCM_COEFFS; k++)
776                     err += (int64_t)ptr[j - k - 1] * coeff[k];
777                 ptr[j] = clip23(ptr[j] + clip23(norm13(err)));
778             }
779         }
780     }
781 }
782
783 // 5.5 - Primary audio data arrays
784 static int parse_subframe_audio(DCACoreDecoder *s, int sf, enum HeaderType header,
785                                 int xch_base, int *sub_pos, int *lfe_pos)
786 {
787     int32_t audio[16], scale;
788     int n, ssf, ofs, ch, band;
789
790     // Check number of subband samples in this subframe
791     int nsamples = s->nsubsubframes[sf] * DCA_SUBBAND_SAMPLES;
792     if (*sub_pos + nsamples > s->npcmblocks) {
793         av_log(s->avctx, AV_LOG_ERROR, "Subband sample buffer overflow\n");
794         return AVERROR_INVALIDDATA;
795     }
796
797     if (get_bits_left(&s->gb) < 0)
798         return AVERROR_INVALIDDATA;
799
800     // VQ encoded subbands
801     for (ch = xch_base; ch < s->nchannels; ch++) {
802         int32_t vq_index[DCA_SUBBANDS];
803
804         for (band = s->subband_vq_start[ch]; band < s->nsubbands[ch]; band++)
805             // Extract the VQ address from the bit stream
806             vq_index[band] = get_bits(&s->gb, 10);
807
808         if (s->subband_vq_start[ch] < s->nsubbands[ch]) {
809             s->dcadsp->decode_hf(s->subband_samples[ch], vq_index,
810                                  ff_dca_high_freq_vq, s->scale_factors[ch],
811                                  s->subband_vq_start[ch], s->nsubbands[ch],
812                                  *sub_pos, nsamples);
813         }
814     }
815
816     // Low frequency effect data
817     if (s->lfe_present && header == HEADER_CORE) {
818         unsigned int index;
819
820         // Determine number of LFE samples in this subframe
821         int nlfesamples = 2 * s->lfe_present * s->nsubsubframes[sf];
822         av_assert1((unsigned int)nlfesamples <= FF_ARRAY_ELEMS(audio));
823
824         // Extract LFE samples from the bit stream
825         get_array(&s->gb, audio, nlfesamples, 8);
826
827         // Extract scale factor index from the bit stream
828         index = get_bits(&s->gb, 8);
829         if (index >= FF_ARRAY_ELEMS(ff_dca_scale_factor_quant7)) {
830             av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE scale factor index\n");
831             return AVERROR_INVALIDDATA;
832         }
833
834         // Look up the 7-bit root square quantization table
835         scale = ff_dca_scale_factor_quant7[index];
836
837         // Account for quantizer step size which is 0.035
838         scale = mul23(4697620 /* 0.035 * (1 << 27) */, scale);
839
840         // Scale and take the LFE samples
841         for (n = 0, ofs = *lfe_pos; n < nlfesamples; n++, ofs++)
842             s->lfe_samples[ofs] = clip23(audio[n] * scale >> 4);
843
844         // Advance LFE sample pointer for the next subframe
845         *lfe_pos = ofs;
846     }
847
848     // Audio data
849     for (ssf = 0, ofs = *sub_pos; ssf < s->nsubsubframes[sf]; ssf++) {
850         for (ch = xch_base; ch < s->nchannels; ch++) {
851             if (get_bits_left(&s->gb) < 0)
852                 return AVERROR_INVALIDDATA;
853
854             // Not high frequency VQ subbands
855             for (band = 0; band < s->subband_vq_start[ch]; band++) {
856                 int ret, trans_ssf, abits = s->bit_allocation[ch][band];
857                 int32_t step_size;
858
859                 // Extract bits from the bit stream
860                 if ((ret = extract_audio(s, audio, abits, ch)) < 0)
861                     return ret;
862
863                 // Select quantization step size table and look up
864                 // quantization step size
865                 if (s->bit_rate == 3)
866                     step_size = ff_dca_lossless_quant[abits];
867                 else
868                     step_size = ff_dca_lossy_quant[abits];
869
870                 // Identify transient location
871                 trans_ssf = s->transition_mode[sf][ch][band];
872
873                 // Determine proper scale factor
874                 if (trans_ssf == 0 || ssf < trans_ssf)
875                     scale = s->scale_factors[ch][band][0];
876                 else
877                     scale = s->scale_factors[ch][band][1];
878
879                 // Adjust scale factor when SEL indicates Huffman code
880                 if (ret > 0) {
881                     int64_t adj = s->scale_factor_adj[ch][abits - 1];
882                     scale = clip23(adj * scale >> 22);
883                 }
884
885                 dequantize(s->subband_samples[ch][band] + ofs,
886                            audio, step_size, scale, 0);
887             }
888         }
889
890         // DSYNC
891         if ((ssf == s->nsubsubframes[sf] - 1 || s->sync_ssf) && get_bits(&s->gb, 16) != 0xffff) {
892             av_log(s->avctx, AV_LOG_ERROR, "DSYNC check failed\n");
893             return AVERROR_INVALIDDATA;
894         }
895
896         ofs += DCA_SUBBAND_SAMPLES;
897     }
898
899     // Inverse ADPCM
900     for (ch = xch_base; ch < s->nchannels; ch++) {
901         inverse_adpcm(s->subband_samples[ch], s->prediction_vq_index[ch],
902                       s->prediction_mode[ch], 0, s->nsubbands[ch],
903                       *sub_pos, nsamples);
904     }
905
906     // Joint subband coding
907     for (ch = xch_base; ch < s->nchannels; ch++) {
908         int src_ch = s->joint_intensity_index[ch] - 1;
909         if (src_ch >= 0) {
910             s->dcadsp->decode_joint(s->subband_samples[ch], s->subband_samples[src_ch],
911                                     s->joint_scale_factors[ch], s->nsubbands[ch],
912                                     s->nsubbands[src_ch], *sub_pos, nsamples);
913         }
914     }
915
916     // Advance subband sample pointer for the next subframe
917     *sub_pos = ofs;
918     return 0;
919 }
920
921 static void erase_adpcm_history(DCACoreDecoder *s)
922 {
923     int ch, band;
924
925     // Erase ADPCM history from previous frame if
926     // predictor history switch was disabled
927     for (ch = 0; ch < DCA_CHANNELS; ch++)
928         for (band = 0; band < DCA_SUBBANDS; band++)
929             AV_ZERO128(s->subband_samples[ch][band] - DCA_ADPCM_COEFFS);
930 }
931
932 static int alloc_sample_buffer(DCACoreDecoder *s)
933 {
934     int nchsamples = DCA_ADPCM_COEFFS + s->npcmblocks;
935     int nframesamples = nchsamples * DCA_CHANNELS * DCA_SUBBANDS;
936     int nlfesamples = DCA_LFE_HISTORY + s->npcmblocks / 2;
937     unsigned int size = s->subband_size;
938     int ch, band;
939
940     // Reallocate subband sample buffer
941     av_fast_mallocz(&s->subband_buffer, &s->subband_size,
942                     (nframesamples + nlfesamples) * sizeof(int32_t));
943     if (!s->subband_buffer)
944         return AVERROR(ENOMEM);
945
946     if (size != s->subband_size) {
947         for (ch = 0; ch < DCA_CHANNELS; ch++)
948             for (band = 0; band < DCA_SUBBANDS; band++)
949                 s->subband_samples[ch][band] = s->subband_buffer +
950                     (ch * DCA_SUBBANDS + band) * nchsamples + DCA_ADPCM_COEFFS;
951         s->lfe_samples = s->subband_buffer + nframesamples;
952     }
953
954     if (!s->predictor_history)
955         erase_adpcm_history(s);
956
957     return 0;
958 }
959
960 static int parse_frame_data(DCACoreDecoder *s, enum HeaderType header, int xch_base)
961 {
962     int sf, ch, ret, band, sub_pos, lfe_pos;
963
964     if ((ret = parse_coding_header(s, header, xch_base)) < 0)
965         return ret;
966
967     for (sf = 0, sub_pos = 0, lfe_pos = DCA_LFE_HISTORY; sf < s->nsubframes; sf++) {
968         if ((ret = parse_subframe_header(s, sf, header, xch_base)) < 0)
969             return ret;
970         if ((ret = parse_subframe_audio(s, sf, header, xch_base, &sub_pos, &lfe_pos)) < 0)
971             return ret;
972     }
973
974     for (ch = xch_base; ch < s->nchannels; ch++) {
975         // Determine number of active subbands for this channel
976         int nsubbands = s->nsubbands[ch];
977         if (s->joint_intensity_index[ch])
978             nsubbands = FFMAX(nsubbands, s->nsubbands[s->joint_intensity_index[ch] - 1]);
979
980         // Update history for ADPCM
981         for (band = 0; band < nsubbands; band++) {
982             int32_t *samples = s->subband_samples[ch][band] - DCA_ADPCM_COEFFS;
983             AV_COPY128(samples, samples + s->npcmblocks);
984         }
985
986         // Clear inactive subbands
987         for (; band < DCA_SUBBANDS; band++) {
988             int32_t *samples = s->subband_samples[ch][band] - DCA_ADPCM_COEFFS;
989             memset(samples, 0, (DCA_ADPCM_COEFFS + s->npcmblocks) * sizeof(int32_t));
990         }
991     }
992
993     return 0;
994 }
995
996 static int parse_xch_frame(DCACoreDecoder *s)
997 {
998     int ret;
999
1000     if (s->ch_mask & DCA_SPEAKER_MASK_Cs) {
1001         av_log(s->avctx, AV_LOG_ERROR, "XCH with Cs speaker already present\n");
1002         return AVERROR_INVALIDDATA;
1003     }
1004
1005     if ((ret = parse_frame_data(s, HEADER_XCH, s->nchannels)) < 0)
1006         return ret;
1007
1008     // Seek to the end of core frame, don't trust XCH frame size
1009     if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) {
1010         av_log(s->avctx, AV_LOG_ERROR, "Read past end of XCH frame\n");
1011         return AVERROR_INVALIDDATA;
1012     }
1013
1014     return 0;
1015 }
1016
1017 static int parse_xxch_frame(DCACoreDecoder *s)
1018 {
1019     int xxch_nchsets, xxch_frame_size;
1020     int ret, mask, header_size, header_pos = get_bits_count(&s->gb);
1021
1022     // XXCH sync word
1023     if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_XXCH) {
1024         av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH sync word\n");
1025         return AVERROR_INVALIDDATA;
1026     }
1027
1028     // XXCH frame header length
1029     header_size = get_bits(&s->gb, 6) + 1;
1030
1031     // Check XXCH frame header CRC
1032     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
1033         && ff_dca_check_crc(&s->gb, header_pos + 32, header_pos + header_size * 8)) {
1034         av_log(s->avctx, AV_LOG_ERROR, "Invalid XXCH frame header checksum\n");
1035         return AVERROR_INVALIDDATA;
1036     }
1037
1038     // CRC presence flag for channel set header
1039     s->xxch_crc_present = get_bits1(&s->gb);
1040
1041     // Number of bits for loudspeaker mask
1042     s->xxch_mask_nbits = get_bits(&s->gb, 5) + 1;
1043     if (s->xxch_mask_nbits <= DCA_SPEAKER_Cs) {
1044         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of bits for XXCH speaker mask (%d)\n", s->xxch_mask_nbits);
1045         return AVERROR_INVALIDDATA;
1046     }
1047
1048     // Number of channel sets
1049     xxch_nchsets = get_bits(&s->gb, 2) + 1;
1050     if (xxch_nchsets > 1) {
1051         avpriv_request_sample(s->avctx, "%d XXCH channel sets", xxch_nchsets);
1052         return AVERROR_PATCHWELCOME;
1053     }
1054
1055     // Channel set 0 data byte size
1056     xxch_frame_size = get_bits(&s->gb, 14) + 1;
1057
1058     // Core loudspeaker activity mask
1059     s->xxch_core_mask = get_bits_long(&s->gb, s->xxch_mask_nbits);
1060
1061     // Validate the core mask
1062     mask = s->ch_mask;
1063
1064     if ((mask & DCA_SPEAKER_MASK_Ls) && (s->xxch_core_mask & DCA_SPEAKER_MASK_Lss))
1065         mask = (mask & ~DCA_SPEAKER_MASK_Ls) | DCA_SPEAKER_MASK_Lss;
1066
1067     if ((mask & DCA_SPEAKER_MASK_Rs) && (s->xxch_core_mask & DCA_SPEAKER_MASK_Rss))
1068         mask = (mask & ~DCA_SPEAKER_MASK_Rs) | DCA_SPEAKER_MASK_Rss;
1069
1070     if (mask != s->xxch_core_mask) {
1071         av_log(s->avctx, AV_LOG_ERROR, "XXCH core speaker activity mask (%#x) disagrees with core (%#x)\n", s->xxch_core_mask, mask);
1072         return AVERROR_INVALIDDATA;
1073     }
1074
1075     // Reserved
1076     // Byte align
1077     // CRC16 of XXCH frame header
1078     if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {
1079         av_log(s->avctx, AV_LOG_ERROR, "Read past end of XXCH frame header\n");
1080         return AVERROR_INVALIDDATA;
1081     }
1082
1083     // Parse XXCH channel set 0
1084     if ((ret = parse_frame_data(s, HEADER_XXCH, s->nchannels)) < 0)
1085         return ret;
1086
1087     if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8 + xxch_frame_size * 8)) {
1088         av_log(s->avctx, AV_LOG_ERROR, "Read past end of XXCH channel set\n");
1089         return AVERROR_INVALIDDATA;
1090     }
1091
1092     return 0;
1093 }
1094
1095 static int parse_xbr_subframe(DCACoreDecoder *s, int xbr_base_ch, int xbr_nchannels,
1096                               int *xbr_nsubbands, int xbr_transition_mode, int sf, int *sub_pos)
1097 {
1098     int     xbr_nabits[DCA_CHANNELS];
1099     int     xbr_bit_allocation[DCA_CHANNELS][DCA_SUBBANDS];
1100     int     xbr_scale_nbits[DCA_CHANNELS];
1101     int32_t xbr_scale_factors[DCA_CHANNELS][DCA_SUBBANDS][2];
1102     int     ssf, ch, band, ofs;
1103
1104     // Check number of subband samples in this subframe
1105     if (*sub_pos + s->nsubsubframes[sf] * DCA_SUBBAND_SAMPLES > s->npcmblocks) {
1106         av_log(s->avctx, AV_LOG_ERROR, "Subband sample buffer overflow\n");
1107         return AVERROR_INVALIDDATA;
1108     }
1109
1110     if (get_bits_left(&s->gb) < 0)
1111         return AVERROR_INVALIDDATA;
1112
1113     // Number of bits for XBR bit allocation index
1114     for (ch = xbr_base_ch; ch < xbr_nchannels; ch++)
1115         xbr_nabits[ch] = get_bits(&s->gb, 2) + 2;
1116
1117     // XBR bit allocation index
1118     for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
1119         for (band = 0; band < xbr_nsubbands[ch]; band++) {
1120             xbr_bit_allocation[ch][band] = get_bits(&s->gb, xbr_nabits[ch]);
1121             if (xbr_bit_allocation[ch][band] > DCA_ABITS_MAX) {
1122                 av_log(s->avctx, AV_LOG_ERROR, "Invalid XBR bit allocation index\n");
1123                 return AVERROR_INVALIDDATA;
1124             }
1125         }
1126     }
1127
1128     // Number of bits for scale indices
1129     for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
1130         xbr_scale_nbits[ch] = get_bits(&s->gb, 3);
1131         if (!xbr_scale_nbits[ch]) {
1132             av_log(s->avctx, AV_LOG_ERROR, "Invalid number of bits for XBR scale factor index\n");
1133             return AVERROR_INVALIDDATA;
1134         }
1135     }
1136
1137     // XBR scale factors
1138     for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
1139         const uint32_t *scale_table;
1140         int scale_size;
1141
1142         // Select the root square table
1143         if (s->scale_factor_sel[ch] > 5) {
1144             scale_table = ff_dca_scale_factor_quant7;
1145             scale_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant7);
1146         } else {
1147             scale_table = ff_dca_scale_factor_quant6;
1148             scale_size = FF_ARRAY_ELEMS(ff_dca_scale_factor_quant6);
1149         }
1150
1151         // Parse scale factor indices and look up scale factors from the root
1152         // square table
1153         for (band = 0; band < xbr_nsubbands[ch]; band++) {
1154             if (xbr_bit_allocation[ch][band]) {
1155                 int scale_index = get_bits(&s->gb, xbr_scale_nbits[ch]);
1156                 if (scale_index >= scale_size) {
1157                     av_log(s->avctx, AV_LOG_ERROR, "Invalid XBR scale factor index\n");
1158                     return AVERROR_INVALIDDATA;
1159                 }
1160                 xbr_scale_factors[ch][band][0] = scale_table[scale_index];
1161                 if (xbr_transition_mode && s->transition_mode[sf][ch][band]) {
1162                     scale_index = get_bits(&s->gb, xbr_scale_nbits[ch]);
1163                     if (scale_index >= scale_size) {
1164                         av_log(s->avctx, AV_LOG_ERROR, "Invalid XBR scale factor index\n");
1165                         return AVERROR_INVALIDDATA;
1166                     }
1167                     xbr_scale_factors[ch][band][1] = scale_table[scale_index];
1168                 }
1169             }
1170         }
1171     }
1172
1173     // Audio data
1174     for (ssf = 0, ofs = *sub_pos; ssf < s->nsubsubframes[sf]; ssf++) {
1175         for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
1176             if (get_bits_left(&s->gb) < 0)
1177                 return AVERROR_INVALIDDATA;
1178
1179             for (band = 0; band < xbr_nsubbands[ch]; band++) {
1180                 int ret, trans_ssf, abits = xbr_bit_allocation[ch][band];
1181                 int32_t audio[DCA_SUBBAND_SAMPLES], step_size, scale;
1182
1183                 // Extract bits from the bit stream
1184                 if (abits > 7) {
1185                     // No further encoding
1186                     get_array(&s->gb, audio, DCA_SUBBAND_SAMPLES, abits - 3);
1187                 } else if (abits > 0) {
1188                     // Block codes
1189                     if ((ret = parse_block_codes(s, audio, abits)) < 0)
1190                         return ret;
1191                 } else {
1192                     // No bits allocated
1193                     continue;
1194                 }
1195
1196                 // Look up quantization step size
1197                 step_size = ff_dca_lossless_quant[abits];
1198
1199                 // Identify transient location
1200                 if (xbr_transition_mode)
1201                     trans_ssf = s->transition_mode[sf][ch][band];
1202                 else
1203                     trans_ssf = 0;
1204
1205                 // Determine proper scale factor
1206                 if (trans_ssf == 0 || ssf < trans_ssf)
1207                     scale = xbr_scale_factors[ch][band][0];
1208                 else
1209                     scale = xbr_scale_factors[ch][band][1];
1210
1211                 dequantize(s->subband_samples[ch][band] + ofs,
1212                            audio, step_size, scale, 1);
1213             }
1214         }
1215
1216         // DSYNC
1217         if ((ssf == s->nsubsubframes[sf] - 1 || s->sync_ssf) && get_bits(&s->gb, 16) != 0xffff) {
1218             av_log(s->avctx, AV_LOG_ERROR, "XBR-DSYNC check failed\n");
1219             return AVERROR_INVALIDDATA;
1220         }
1221
1222         ofs += DCA_SUBBAND_SAMPLES;
1223     }
1224
1225     // Advance subband sample pointer for the next subframe
1226     *sub_pos = ofs;
1227     return 0;
1228 }
1229
1230 static int parse_xbr_frame(DCACoreDecoder *s)
1231 {
1232     int     xbr_frame_size[DCA_EXSS_CHSETS_MAX];
1233     int     xbr_nchannels[DCA_EXSS_CHSETS_MAX];
1234     int     xbr_nsubbands[DCA_EXSS_CHSETS_MAX * DCA_EXSS_CHANNELS_MAX];
1235     int     xbr_nchsets, xbr_transition_mode, xbr_band_nbits, xbr_base_ch;
1236     int     i, ch1, ch2, ret, header_size, header_pos = get_bits_count(&s->gb);
1237
1238     // XBR sync word
1239     if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_XBR) {
1240         av_log(s->avctx, AV_LOG_ERROR, "Invalid XBR sync word\n");
1241         return AVERROR_INVALIDDATA;
1242     }
1243
1244     // XBR frame header length
1245     header_size = get_bits(&s->gb, 6) + 1;
1246
1247     // Check XBR frame header CRC
1248     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
1249         && ff_dca_check_crc(&s->gb, header_pos + 32, header_pos + header_size * 8)) {
1250         av_log(s->avctx, AV_LOG_ERROR, "Invalid XBR frame header checksum\n");
1251         return AVERROR_INVALIDDATA;
1252     }
1253
1254     // Number of channel sets
1255     xbr_nchsets = get_bits(&s->gb, 2) + 1;
1256
1257     // Channel set data byte size
1258     for (i = 0; i < xbr_nchsets; i++)
1259         xbr_frame_size[i] = get_bits(&s->gb, 14) + 1;
1260
1261     // Transition mode flag
1262     xbr_transition_mode = get_bits1(&s->gb);
1263
1264     // Channel set headers
1265     for (i = 0, ch2 = 0; i < xbr_nchsets; i++) {
1266         xbr_nchannels[i] = get_bits(&s->gb, 3) + 1;
1267         xbr_band_nbits = get_bits(&s->gb, 2) + 5;
1268         for (ch1 = 0; ch1 < xbr_nchannels[i]; ch1++, ch2++) {
1269             xbr_nsubbands[ch2] = get_bits(&s->gb, xbr_band_nbits) + 1;
1270             if (xbr_nsubbands[ch2] > DCA_SUBBANDS) {
1271                 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of active XBR subbands (%d)\n", xbr_nsubbands[ch2]);
1272                 return AVERROR_INVALIDDATA;
1273             }
1274         }
1275     }
1276
1277     // Reserved
1278     // Byte align
1279     // CRC16 of XBR frame header
1280     if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {
1281         av_log(s->avctx, AV_LOG_ERROR, "Read past end of XBR frame header\n");
1282         return AVERROR_INVALIDDATA;
1283     }
1284
1285     // Channel set data
1286     for (i = 0, xbr_base_ch = 0; i < xbr_nchsets; i++) {
1287         header_pos = get_bits_count(&s->gb);
1288
1289         if (xbr_base_ch + xbr_nchannels[i] <= s->nchannels) {
1290             int sf, sub_pos;
1291
1292             for (sf = 0, sub_pos = 0; sf < s->nsubframes; sf++) {
1293                 if ((ret = parse_xbr_subframe(s, xbr_base_ch,
1294                                               xbr_base_ch + xbr_nchannels[i],
1295                                               xbr_nsubbands, xbr_transition_mode,
1296                                               sf, &sub_pos)) < 0)
1297                     return ret;
1298             }
1299         }
1300
1301         xbr_base_ch += xbr_nchannels[i];
1302
1303         if (ff_dca_seek_bits(&s->gb, header_pos + xbr_frame_size[i] * 8)) {
1304             av_log(s->avctx, AV_LOG_ERROR, "Read past end of XBR channel set\n");
1305             return AVERROR_INVALIDDATA;
1306         }
1307     }
1308
1309     return 0;
1310 }
1311
1312 // Modified ISO/IEC 9899 linear congruential generator
1313 // Returns pseudorandom integer in range [-2^30, 2^30 - 1]
1314 static int rand_x96(DCACoreDecoder *s)
1315 {
1316     s->x96_rand = 1103515245U * s->x96_rand + 12345U;
1317     return (s->x96_rand & 0x7fffffff) - 0x40000000;
1318 }
1319
1320 static int parse_x96_subframe_audio(DCACoreDecoder *s, int sf, int xch_base, int *sub_pos)
1321 {
1322     int n, ssf, ch, band, ofs;
1323
1324     // Check number of subband samples in this subframe
1325     int nsamples = s->nsubsubframes[sf] * DCA_SUBBAND_SAMPLES;
1326     if (*sub_pos + nsamples > s->npcmblocks) {
1327         av_log(s->avctx, AV_LOG_ERROR, "Subband sample buffer overflow\n");
1328         return AVERROR_INVALIDDATA;
1329     }
1330
1331     if (get_bits_left(&s->gb) < 0)
1332         return AVERROR_INVALIDDATA;
1333
1334     // VQ encoded or unallocated subbands
1335     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1336         for (band = s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1337             // Get the sample pointer and scale factor
1338             int32_t *samples = s->x96_subband_samples[ch][band] + *sub_pos;
1339             int32_t scale    = s->scale_factors[ch][band >> 1][band & 1];
1340
1341             switch (s->bit_allocation[ch][band]) {
1342             case 0: // No bits allocated for subband
1343                 if (scale <= 1)
1344                     memset(samples, 0, nsamples * sizeof(int32_t));
1345                 else for (n = 0; n < nsamples; n++)
1346                     // Generate scaled random samples
1347                     samples[n] = mul31(rand_x96(s), scale);
1348                 break;
1349
1350             case 1: // VQ encoded subband
1351                 for (ssf = 0; ssf < (s->nsubsubframes[sf] + 1) / 2; ssf++) {
1352                     // Extract the VQ address from the bit stream and look up
1353                     // the VQ code book for up to 16 subband samples
1354                     const int8_t *vq_samples = ff_dca_high_freq_vq[get_bits(&s->gb, 10)];
1355                     // Scale and take the samples
1356                     for (n = 0; n < FFMIN(nsamples - ssf * 16, 16); n++)
1357                         *samples++ = clip23(vq_samples[n] * scale + (1 << 3) >> 4);
1358                 }
1359                 break;
1360             }
1361         }
1362     }
1363
1364     // Audio data
1365     for (ssf = 0, ofs = *sub_pos; ssf < s->nsubsubframes[sf]; ssf++) {
1366         for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1367             if (get_bits_left(&s->gb) < 0)
1368                 return AVERROR_INVALIDDATA;
1369
1370             for (band = s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1371                 int ret, abits = s->bit_allocation[ch][band] - 1;
1372                 int32_t audio[DCA_SUBBAND_SAMPLES], step_size, scale;
1373
1374                 // Not VQ encoded or unallocated subbands
1375                 if (abits < 1)
1376                     continue;
1377
1378                 // Extract bits from the bit stream
1379                 if ((ret = extract_audio(s, audio, abits, ch)) < 0)
1380                     return ret;
1381
1382                 // Select quantization step size table and look up quantization
1383                 // step size
1384                 if (s->bit_rate == 3)
1385                     step_size = ff_dca_lossless_quant[abits];
1386                 else
1387                     step_size = ff_dca_lossy_quant[abits];
1388
1389                 // Get the scale factor
1390                 scale = s->scale_factors[ch][band >> 1][band & 1];
1391
1392                 dequantize(s->x96_subband_samples[ch][band] + ofs,
1393                            audio, step_size, scale, 0);
1394             }
1395         }
1396
1397         // DSYNC
1398         if ((ssf == s->nsubsubframes[sf] - 1 || s->sync_ssf) && get_bits(&s->gb, 16) != 0xffff) {
1399             av_log(s->avctx, AV_LOG_ERROR, "X96-DSYNC check failed\n");
1400             return AVERROR_INVALIDDATA;
1401         }
1402
1403         ofs += DCA_SUBBAND_SAMPLES;
1404     }
1405
1406     // Inverse ADPCM
1407     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1408         inverse_adpcm(s->x96_subband_samples[ch], s->prediction_vq_index[ch],
1409                       s->prediction_mode[ch], s->x96_subband_start, s->nsubbands[ch],
1410                       *sub_pos, nsamples);
1411     }
1412
1413     // Joint subband coding
1414     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1415         int src_ch = s->joint_intensity_index[ch] - 1;
1416         if (src_ch >= 0) {
1417             s->dcadsp->decode_joint(s->x96_subband_samples[ch], s->x96_subband_samples[src_ch],
1418                                     s->joint_scale_factors[ch], s->nsubbands[ch],
1419                                     s->nsubbands[src_ch], *sub_pos, nsamples);
1420         }
1421     }
1422
1423     // Advance subband sample pointer for the next subframe
1424     *sub_pos = ofs;
1425     return 0;
1426 }
1427
1428 static void erase_x96_adpcm_history(DCACoreDecoder *s)
1429 {
1430     int ch, band;
1431
1432     // Erase ADPCM history from previous frame if
1433     // predictor history switch was disabled
1434     for (ch = 0; ch < DCA_CHANNELS; ch++)
1435         for (band = 0; band < DCA_SUBBANDS_X96; band++)
1436             AV_ZERO128(s->x96_subband_samples[ch][band] - DCA_ADPCM_COEFFS);
1437 }
1438
1439 static int alloc_x96_sample_buffer(DCACoreDecoder *s)
1440 {
1441     int nchsamples = DCA_ADPCM_COEFFS + s->npcmblocks;
1442     int nframesamples = nchsamples * DCA_CHANNELS * DCA_SUBBANDS_X96;
1443     unsigned int size = s->x96_subband_size;
1444     int ch, band;
1445
1446     // Reallocate subband sample buffer
1447     av_fast_mallocz(&s->x96_subband_buffer, &s->x96_subband_size,
1448                     nframesamples * sizeof(int32_t));
1449     if (!s->x96_subband_buffer)
1450         return AVERROR(ENOMEM);
1451
1452     if (size != s->x96_subband_size) {
1453         for (ch = 0; ch < DCA_CHANNELS; ch++)
1454             for (band = 0; band < DCA_SUBBANDS_X96; band++)
1455                 s->x96_subband_samples[ch][band] = s->x96_subband_buffer +
1456                     (ch * DCA_SUBBANDS_X96 + band) * nchsamples + DCA_ADPCM_COEFFS;
1457     }
1458
1459     if (!s->predictor_history)
1460         erase_x96_adpcm_history(s);
1461
1462     return 0;
1463 }
1464
1465 static int parse_x96_subframe_header(DCACoreDecoder *s, int xch_base)
1466 {
1467     int ch, band, ret;
1468
1469     if (get_bits_left(&s->gb) < 0)
1470         return AVERROR_INVALIDDATA;
1471
1472     // Prediction mode
1473     for (ch = xch_base; ch < s->x96_nchannels; ch++)
1474         for (band = s->x96_subband_start; band < s->nsubbands[ch]; band++)
1475             s->prediction_mode[ch][band] = get_bits1(&s->gb);
1476
1477     // Prediction coefficients VQ address
1478     for (ch = xch_base; ch < s->x96_nchannels; ch++)
1479         for (band = s->x96_subband_start; band < s->nsubbands[ch]; band++)
1480             if (s->prediction_mode[ch][band])
1481                 s->prediction_vq_index[ch][band] = get_bits(&s->gb, 12);
1482
1483     // Bit allocation index
1484     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1485         int sel = s->bit_allocation_sel[ch];
1486         int abits = 0;
1487
1488         for (band = s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1489             // If Huffman code was used, the difference of abits was encoded
1490             if (sel < 7)
1491                 abits += get_vlc(&s->gb, &vlc_quant_index[5 + 2 * s->x96_high_res], sel);
1492             else
1493                 abits = get_bits(&s->gb, 3 + s->x96_high_res);
1494
1495             if (abits < 0 || abits > 7 + 8 * s->x96_high_res) {
1496                 av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 bit allocation index\n");
1497                 return AVERROR_INVALIDDATA;
1498             }
1499
1500             s->bit_allocation[ch][band] = abits;
1501         }
1502     }
1503
1504     // Scale factors
1505     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1506         int sel = s->scale_factor_sel[ch];
1507         int scale_index = 0;
1508
1509         // Extract scales for subbands which are transmitted even for
1510         // unallocated subbands
1511         for (band = s->x96_subband_start; band < s->nsubbands[ch]; band++) {
1512             if ((ret = parse_scale(s, &scale_index, sel)) < 0)
1513                 return ret;
1514             s->scale_factors[ch][band >> 1][band & 1] = ret;
1515         }
1516     }
1517
1518     // Joint subband codebook select
1519     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1520         if (s->joint_intensity_index[ch]) {
1521             s->joint_scale_sel[ch] = get_bits(&s->gb, 3);
1522             if (s->joint_scale_sel[ch] == 7) {
1523                 av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 joint scale factor code book\n");
1524                 return AVERROR_INVALIDDATA;
1525             }
1526         }
1527     }
1528
1529     // Scale factors for joint subband coding
1530     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1531         int src_ch = s->joint_intensity_index[ch] - 1;
1532         if (src_ch >= 0) {
1533             int sel = s->joint_scale_sel[ch];
1534             for (band = s->nsubbands[ch]; band < s->nsubbands[src_ch]; band++) {
1535                 if ((ret = parse_joint_scale(s, sel)) < 0)
1536                     return ret;
1537                 s->joint_scale_factors[ch][band] = ret;
1538             }
1539         }
1540     }
1541
1542     // Side information CRC check word
1543     if (s->crc_present)
1544         skip_bits(&s->gb, 16);
1545
1546     return 0;
1547 }
1548
1549 static int parse_x96_coding_header(DCACoreDecoder *s, int exss, int xch_base)
1550 {
1551     int n, ch, header_size = 0, header_pos = get_bits_count(&s->gb);
1552
1553     if (get_bits_left(&s->gb) < 0)
1554         return AVERROR_INVALIDDATA;
1555
1556     if (exss) {
1557         // Channel set header length
1558         header_size = get_bits(&s->gb, 7) + 1;
1559
1560         // Check CRC
1561         if (s->x96_crc_present
1562             && (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
1563             && ff_dca_check_crc(&s->gb, header_pos, header_pos + header_size * 8)) {
1564             av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 channel set header checksum\n");
1565             return AVERROR_INVALIDDATA;
1566         }
1567     }
1568
1569     // High resolution flag
1570     s->x96_high_res = get_bits1(&s->gb);
1571
1572     // First encoded subband
1573     if (s->x96_rev_no < 8) {
1574         s->x96_subband_start = get_bits(&s->gb, 5);
1575         if (s->x96_subband_start > 27) {
1576             av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 subband start index (%d)\n", s->x96_subband_start);
1577             return AVERROR_INVALIDDATA;
1578         }
1579     } else {
1580         s->x96_subband_start = DCA_SUBBANDS;
1581     }
1582
1583     // Subband activity count
1584     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1585         s->nsubbands[ch] = get_bits(&s->gb, 6) + 1;
1586         if (s->nsubbands[ch] < DCA_SUBBANDS) {
1587             av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 subband activity count (%d)\n", s->nsubbands[ch]);
1588             return AVERROR_INVALIDDATA;
1589         }
1590     }
1591
1592     // Joint intensity coding index
1593     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1594         if ((n = get_bits(&s->gb, 3)) && xch_base)
1595             n += xch_base - 1;
1596         if (n > s->x96_nchannels) {
1597             av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 joint intensity coding index\n");
1598             return AVERROR_INVALIDDATA;
1599         }
1600         s->joint_intensity_index[ch] = n;
1601     }
1602
1603     // Scale factor code book
1604     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1605         s->scale_factor_sel[ch] = get_bits(&s->gb, 3);
1606         if (s->scale_factor_sel[ch] >= 6) {
1607             av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 scale factor code book\n");
1608             return AVERROR_INVALIDDATA;
1609         }
1610     }
1611
1612     // Bit allocation quantizer select
1613     for (ch = xch_base; ch < s->x96_nchannels; ch++)
1614         s->bit_allocation_sel[ch] = get_bits(&s->gb, 3);
1615
1616     // Quantization index codebook select
1617     for (n = 0; n < 6 + 4 * s->x96_high_res; n++)
1618         for (ch = xch_base; ch < s->x96_nchannels; ch++)
1619             s->quant_index_sel[ch][n] = get_bits(&s->gb, quant_index_sel_nbits[n]);
1620
1621     if (exss) {
1622         // Reserved
1623         // Byte align
1624         // CRC16 of channel set header
1625         if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {
1626             av_log(s->avctx, AV_LOG_ERROR, "Read past end of X96 channel set header\n");
1627             return AVERROR_INVALIDDATA;
1628         }
1629     } else {
1630         if (s->crc_present)
1631             skip_bits(&s->gb, 16);
1632     }
1633
1634     return 0;
1635 }
1636
1637 static int parse_x96_frame_data(DCACoreDecoder *s, int exss, int xch_base)
1638 {
1639     int sf, ch, ret, band, sub_pos;
1640
1641     if ((ret = parse_x96_coding_header(s, exss, xch_base)) < 0)
1642         return ret;
1643
1644     for (sf = 0, sub_pos = 0; sf < s->nsubframes; sf++) {
1645         if ((ret = parse_x96_subframe_header(s, xch_base)) < 0)
1646             return ret;
1647         if ((ret = parse_x96_subframe_audio(s, sf, xch_base, &sub_pos)) < 0)
1648             return ret;
1649     }
1650
1651     for (ch = xch_base; ch < s->x96_nchannels; ch++) {
1652         // Determine number of active subbands for this channel
1653         int nsubbands = s->nsubbands[ch];
1654         if (s->joint_intensity_index[ch])
1655             nsubbands = FFMAX(nsubbands, s->nsubbands[s->joint_intensity_index[ch] - 1]);
1656
1657         // Update history for ADPCM and clear inactive subbands
1658         for (band = 0; band < DCA_SUBBANDS_X96; band++) {
1659             int32_t *samples = s->x96_subband_samples[ch][band] - DCA_ADPCM_COEFFS;
1660             if (band >= s->x96_subband_start && band < nsubbands)
1661                 AV_COPY128(samples, samples + s->npcmblocks);
1662             else
1663                 memset(samples, 0, (DCA_ADPCM_COEFFS + s->npcmblocks) * sizeof(int32_t));
1664         }
1665     }
1666
1667     return 0;
1668 }
1669
1670 static int parse_x96_frame(DCACoreDecoder *s)
1671 {
1672     int ret;
1673
1674     // Revision number
1675     s->x96_rev_no = get_bits(&s->gb, 4);
1676     if (s->x96_rev_no < 1 || s->x96_rev_no > 8) {
1677         av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 revision (%d)\n", s->x96_rev_no);
1678         return AVERROR_INVALIDDATA;
1679     }
1680
1681     s->x96_crc_present = 0;
1682     s->x96_nchannels = s->nchannels;
1683
1684     if ((ret = alloc_x96_sample_buffer(s)) < 0)
1685         return ret;
1686
1687     if ((ret = parse_x96_frame_data(s, 0, 0)) < 0)
1688         return ret;
1689
1690     // Seek to the end of core frame
1691     if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) {
1692         av_log(s->avctx, AV_LOG_ERROR, "Read past end of X96 frame\n");
1693         return AVERROR_INVALIDDATA;
1694     }
1695
1696     return 0;
1697 }
1698
1699 static int parse_x96_frame_exss(DCACoreDecoder *s)
1700 {
1701     int     x96_frame_size[DCA_EXSS_CHSETS_MAX];
1702     int     x96_nchannels[DCA_EXSS_CHSETS_MAX];
1703     int     x96_nchsets, x96_base_ch;
1704     int     i, ret, header_size, header_pos = get_bits_count(&s->gb);
1705
1706     // X96 sync word
1707     if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_X96) {
1708         av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 sync word\n");
1709         return AVERROR_INVALIDDATA;
1710     }
1711
1712     // X96 frame header length
1713     header_size = get_bits(&s->gb, 6) + 1;
1714
1715     // Check X96 frame header CRC
1716     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
1717         && ff_dca_check_crc(&s->gb, header_pos + 32, header_pos + header_size * 8)) {
1718         av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 frame header checksum\n");
1719         return AVERROR_INVALIDDATA;
1720     }
1721
1722     // Revision number
1723     s->x96_rev_no = get_bits(&s->gb, 4);
1724     if (s->x96_rev_no < 1 || s->x96_rev_no > 8) {
1725         av_log(s->avctx, AV_LOG_ERROR, "Invalid X96 revision (%d)\n", s->x96_rev_no);
1726         return AVERROR_INVALIDDATA;
1727     }
1728
1729     // CRC presence flag for channel set header
1730     s->x96_crc_present = get_bits1(&s->gb);
1731
1732     // Number of channel sets
1733     x96_nchsets = get_bits(&s->gb, 2) + 1;
1734
1735     // Channel set data byte size
1736     for (i = 0; i < x96_nchsets; i++)
1737         x96_frame_size[i] = get_bits(&s->gb, 12) + 1;
1738
1739     // Number of channels in channel set
1740     for (i = 0; i < x96_nchsets; i++)
1741         x96_nchannels[i] = get_bits(&s->gb, 3) + 1;
1742
1743     // Reserved
1744     // Byte align
1745     // CRC16 of X96 frame header
1746     if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) {
1747         av_log(s->avctx, AV_LOG_ERROR, "Read past end of X96 frame header\n");
1748         return AVERROR_INVALIDDATA;
1749     }
1750
1751     if ((ret = alloc_x96_sample_buffer(s)) < 0)
1752         return ret;
1753
1754     // Channel set data
1755     for (i = 0, x96_base_ch = 0; i < x96_nchsets; i++) {
1756         header_pos = get_bits_count(&s->gb);
1757
1758         if (x96_base_ch + x96_nchannels[i] <= s->nchannels) {
1759             s->x96_nchannels = x96_base_ch + x96_nchannels[i];
1760             if ((ret = parse_x96_frame_data(s, 1, x96_base_ch)) < 0)
1761                 return ret;
1762         }
1763
1764         x96_base_ch += x96_nchannels[i];
1765
1766         if (ff_dca_seek_bits(&s->gb, header_pos + x96_frame_size[i] * 8)) {
1767             av_log(s->avctx, AV_LOG_ERROR, "Read past end of X96 channel set\n");
1768             return AVERROR_INVALIDDATA;
1769         }
1770     }
1771
1772     return 0;
1773 }
1774
1775 static int parse_aux_data(DCACoreDecoder *s)
1776 {
1777     int aux_pos;
1778
1779     if (get_bits_left(&s->gb) < 0)
1780         return AVERROR_INVALIDDATA;
1781
1782     // Auxiliary data byte count (can't be trusted)
1783     skip_bits(&s->gb, 6);
1784
1785     // 4-byte align
1786     skip_bits_long(&s->gb, -get_bits_count(&s->gb) & 31);
1787
1788     // Auxiliary data sync word
1789     if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_REV1AUX) {
1790         av_log(s->avctx, AV_LOG_ERROR, "Invalid auxiliary data sync word\n");
1791         return AVERROR_INVALIDDATA;
1792     }
1793
1794     aux_pos = get_bits_count(&s->gb);
1795
1796     // Auxiliary decode time stamp flag
1797     if (get_bits1(&s->gb))
1798         skip_bits_long(&s->gb, 47);
1799
1800     // Auxiliary dynamic downmix flag
1801     if (s->prim_dmix_embedded = get_bits1(&s->gb)) {
1802         int i, m, n;
1803
1804         // Auxiliary primary channel downmix type
1805         s->prim_dmix_type = get_bits(&s->gb, 3);
1806         if (s->prim_dmix_type >= DCA_DMIX_TYPE_COUNT) {
1807             av_log(s->avctx, AV_LOG_ERROR, "Invalid primary channel set downmix type\n");
1808             return AVERROR_INVALIDDATA;
1809         }
1810
1811         // Size of downmix coefficients matrix
1812         m = ff_dca_dmix_primary_nch[s->prim_dmix_type];
1813         n = ff_dca_channels[s->audio_mode] + !!s->lfe_present;
1814
1815         // Dynamic downmix code coefficients
1816         for (i = 0; i < m * n; i++) {
1817             int code = get_bits(&s->gb, 9);
1818             int sign = (code >> 8) - 1;
1819             unsigned int index = code & 0xff;
1820             if (index >= FF_DCA_DMIXTABLE_SIZE) {
1821                 av_log(s->avctx, AV_LOG_ERROR, "Invalid downmix coefficient index\n");
1822                 return AVERROR_INVALIDDATA;
1823             }
1824             s->prim_dmix_coeff[i] = (ff_dca_dmixtable[index] ^ sign) - sign;
1825         }
1826     }
1827
1828     // Byte align
1829     skip_bits(&s->gb, -get_bits_count(&s->gb) & 7);
1830
1831     // CRC16 of auxiliary data
1832     skip_bits(&s->gb, 16);
1833
1834     // Check CRC
1835     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL))
1836         && ff_dca_check_crc(&s->gb, aux_pos, get_bits_count(&s->gb))) {
1837         av_log(s->avctx, AV_LOG_ERROR, "Invalid auxiliary data checksum\n");
1838         return AVERROR_INVALIDDATA;
1839     }
1840
1841     return 0;
1842 }
1843
1844 static int parse_optional_info(DCACoreDecoder *s)
1845 {
1846     DCAContext *dca = s->avctx->priv_data;
1847     int ret = -1;
1848
1849     // Time code stamp
1850     if (s->ts_present)
1851         skip_bits_long(&s->gb, 32);
1852
1853     // Auxiliary data
1854     if (s->aux_present && (ret = parse_aux_data(s)) < 0
1855         && (s->avctx->err_recognition & AV_EF_EXPLODE))
1856         return ret;
1857
1858     if (ret < 0)
1859         s->prim_dmix_embedded = 0;
1860
1861     // Core extensions
1862     if (s->ext_audio_present && !dca->core_only) {
1863         int sync_pos = FFMIN(s->frame_size / 4, s->gb.size_in_bits / 32) - 1;
1864         int last_pos = get_bits_count(&s->gb) / 32;
1865         int size, dist;
1866
1867         // Search for extension sync words aligned on 4-byte boundary. Search
1868         // must be done backwards from the end of core frame to work around
1869         // sync word aliasing issues.
1870         switch (s->ext_audio_type) {
1871         case EXT_AUDIO_XCH:
1872             if (dca->request_channel_layout)
1873                 break;
1874
1875             // The distance between XCH sync word and end of the core frame
1876             // must be equal to XCH frame size. Off by one error is allowed for
1877             // compatibility with legacy bitstreams. Minimum XCH frame size is
1878             // 96 bytes. AMODE and PCHS are further checked to reduce
1879             // probability of alias sync detection.
1880             for (; sync_pos >= last_pos; sync_pos--) {
1881                 if (AV_RB32(s->gb.buffer + sync_pos * 4) == DCA_SYNCWORD_XCH) {
1882                     s->gb.index = (sync_pos + 1) * 32;
1883                     size = get_bits(&s->gb, 10) + 1;
1884                     dist = s->frame_size - sync_pos * 4;
1885                     if (size >= 96
1886                         && (size == dist || size - 1 == dist)
1887                         && get_bits(&s->gb, 7) == 0x08) {
1888                         s->xch_pos = get_bits_count(&s->gb);
1889                         break;
1890                     }
1891                 }
1892             }
1893
1894             if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1895                 av_log(s->avctx, AV_LOG_ERROR, "XCH sync word not found\n");
1896                 return AVERROR_INVALIDDATA;
1897             }
1898             break;
1899
1900         case EXT_AUDIO_X96:
1901             // The distance between X96 sync word and end of the core frame
1902             // must be equal to X96 frame size. Minimum X96 frame size is 96
1903             // bytes.
1904             for (; sync_pos >= last_pos; sync_pos--) {
1905                 if (AV_RB32(s->gb.buffer + sync_pos * 4) == DCA_SYNCWORD_X96) {
1906                     s->gb.index = (sync_pos + 1) * 32;
1907                     size = get_bits(&s->gb, 12) + 1;
1908                     dist = s->frame_size - sync_pos * 4;
1909                     if (size >= 96 && size == dist) {
1910                         s->x96_pos = get_bits_count(&s->gb);
1911                         break;
1912                     }
1913                 }
1914             }
1915
1916             if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1917                 av_log(s->avctx, AV_LOG_ERROR, "X96 sync word not found\n");
1918                 return AVERROR_INVALIDDATA;
1919             }
1920             break;
1921
1922         case EXT_AUDIO_XXCH:
1923             if (dca->request_channel_layout)
1924                 break;
1925
1926             // XXCH frame header CRC must be valid. Minimum XXCH frame header
1927             // size is 11 bytes.
1928             for (; sync_pos >= last_pos; sync_pos--) {
1929                 if (AV_RB32(s->gb.buffer + sync_pos * 4) == DCA_SYNCWORD_XXCH) {
1930                     s->gb.index = (sync_pos + 1) * 32;
1931                     size = get_bits(&s->gb, 6) + 1;
1932                     if (size >= 11 &&
1933                         !ff_dca_check_crc(&s->gb, (sync_pos + 1) * 32,
1934                                           sync_pos * 32 + size * 8)) {
1935                         s->xxch_pos = sync_pos * 32;
1936                         break;
1937                     }
1938                 }
1939             }
1940
1941             if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1942                 av_log(s->avctx, AV_LOG_ERROR, "XXCH sync word not found\n");
1943                 return AVERROR_INVALIDDATA;
1944             }
1945             break;
1946         }
1947     }
1948
1949     return 0;
1950 }
1951
1952 int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size)
1953 {
1954     int ret;
1955
1956     s->ext_audio_mask = 0;
1957     s->xch_pos = s->xxch_pos = s->x96_pos = 0;
1958
1959     if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
1960         return ret;
1961
1962     skip_bits_long(&s->gb, 32);
1963     if ((ret = parse_frame_header(s)) < 0)
1964         return ret;
1965     if ((ret = alloc_sample_buffer(s)) < 0)
1966         return ret;
1967     if ((ret = parse_frame_data(s, HEADER_CORE, 0)) < 0)
1968         return ret;
1969     if ((ret = parse_optional_info(s)) < 0)
1970         return ret;
1971
1972     // Workaround for DTS in WAV
1973     if (s->frame_size > size && s->frame_size < size + 4) {
1974         av_log(s->avctx, AV_LOG_DEBUG, "Working around excessive core frame size (%d > %d)\n", s->frame_size, size);
1975         s->frame_size = size;
1976     }
1977
1978     if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) {
1979         av_log(s->avctx, AV_LOG_ERROR, "Read past end of core frame\n");
1980         if (s->avctx->err_recognition & AV_EF_EXPLODE)
1981             return AVERROR_INVALIDDATA;
1982     }
1983
1984     return 0;
1985 }
1986
1987 int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset)
1988 {
1989     AVCodecContext *avctx = s->avctx;
1990     DCAContext *dca = avctx->priv_data;
1991     GetBitContext gb = s->gb;
1992     int exss_mask = asset ? asset->extension_mask : 0;
1993     int ret = 0, ext = 0;
1994
1995     // Parse (X)XCH unless downmixing
1996     if (!dca->request_channel_layout) {
1997         if (exss_mask & DCA_EXSS_XXCH) {
1998             if ((ret = init_get_bits8(&s->gb, data + asset->xxch_offset, asset->xxch_size)) < 0)
1999                 return ret;
2000             ret = parse_xxch_frame(s);
2001             ext = DCA_EXSS_XXCH;
2002         } else if (s->xxch_pos) {
2003             s->gb.index = s->xxch_pos;
2004             ret = parse_xxch_frame(s);
2005             ext = DCA_CSS_XXCH;
2006         } else if (s->xch_pos) {
2007             s->gb.index = s->xch_pos;
2008             ret = parse_xch_frame(s);
2009             ext = DCA_CSS_XCH;
2010         }
2011
2012         // Revert to primary channel set in case (X)XCH parsing fails
2013         if (ret < 0) {
2014             if (avctx->err_recognition & AV_EF_EXPLODE)
2015                 return ret;
2016             s->nchannels = ff_dca_channels[s->audio_mode];
2017             s->ch_mask = audio_mode_ch_mask[s->audio_mode];
2018             if (s->lfe_present)
2019                 s->ch_mask |= DCA_SPEAKER_MASK_LFE1;
2020         } else {
2021             s->ext_audio_mask |= ext;
2022         }
2023     }
2024
2025     // Parse XBR
2026     if (exss_mask & DCA_EXSS_XBR) {
2027         if ((ret = init_get_bits8(&s->gb, data + asset->xbr_offset, asset->xbr_size)) < 0)
2028             return ret;
2029         if ((ret = parse_xbr_frame(s)) < 0) {
2030             if (avctx->err_recognition & AV_EF_EXPLODE)
2031                 return ret;
2032         } else {
2033             s->ext_audio_mask |= DCA_EXSS_XBR;
2034         }
2035     }
2036
2037     // Parse X96 unless decoding XLL
2038     if (!(dca->packet & DCA_PACKET_XLL)) {
2039         if (exss_mask & DCA_EXSS_X96) {
2040             if ((ret = init_get_bits8(&s->gb, data + asset->x96_offset, asset->x96_size)) < 0)
2041                 return ret;
2042             if ((ret = parse_x96_frame_exss(s)) < 0) {
2043                 if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
2044                     return ret;
2045             } else {
2046                 s->ext_audio_mask |= DCA_EXSS_X96;
2047             }
2048         } else if (s->x96_pos) {
2049             s->gb = gb;
2050             s->gb.index = s->x96_pos;
2051             if ((ret = parse_x96_frame(s)) < 0) {
2052                 if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
2053                     return ret;
2054             } else {
2055                 s->ext_audio_mask |= DCA_CSS_X96;
2056             }
2057         }
2058     }
2059
2060     return 0;
2061 }
2062
2063 static int map_prm_ch_to_spkr(DCACoreDecoder *s, int ch)
2064 {
2065     int pos, spkr;
2066
2067     // Try to map this channel to core first
2068     pos = ff_dca_channels[s->audio_mode];
2069     if (ch < pos) {
2070         spkr = prm_ch_to_spkr_map[s->audio_mode][ch];
2071         if (s->ext_audio_mask & (DCA_CSS_XXCH | DCA_EXSS_XXCH)) {
2072             if (s->xxch_core_mask & (1U << spkr))
2073                 return spkr;
2074             if (spkr == DCA_SPEAKER_Ls && (s->xxch_core_mask & DCA_SPEAKER_MASK_Lss))
2075                 return DCA_SPEAKER_Lss;
2076             if (spkr == DCA_SPEAKER_Rs && (s->xxch_core_mask & DCA_SPEAKER_MASK_Rss))
2077                 return DCA_SPEAKER_Rss;
2078             return -1;
2079         }
2080         return spkr;
2081     }
2082
2083     // Then XCH
2084     if ((s->ext_audio_mask & DCA_CSS_XCH) && ch == pos)
2085         return DCA_SPEAKER_Cs;
2086
2087     // Then XXCH
2088     if (s->ext_audio_mask & (DCA_CSS_XXCH | DCA_EXSS_XXCH)) {
2089         for (spkr = DCA_SPEAKER_Cs; spkr < s->xxch_mask_nbits; spkr++)
2090             if (s->xxch_spkr_mask & (1U << spkr))
2091                 if (pos++ == ch)
2092                     return spkr;
2093     }
2094
2095     // No mapping
2096     return -1;
2097 }
2098
2099 static void erase_dsp_history(DCACoreDecoder *s)
2100 {
2101     memset(s->dcadsp_data, 0, sizeof(s->dcadsp_data));
2102     s->output_history_lfe_fixed = 0;
2103     s->output_history_lfe_float = 0;
2104 }
2105
2106 static void set_filter_mode(DCACoreDecoder *s, int mode)
2107 {
2108     if (s->filter_mode != mode) {
2109         erase_dsp_history(s);
2110         s->filter_mode = mode;
2111     }
2112 }
2113
2114 int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth)
2115 {
2116     int n, ch, spkr, nsamples, x96_nchannels = 0;
2117     const int32_t *filter_coeff;
2118     int32_t *ptr;
2119
2120     // Externally set x96_synth flag implies that X96 synthesis should be
2121     // enabled, yet actual X96 subband data should be discarded. This is a
2122     // special case for lossless residual decoder that ignores X96 data if
2123     // present.
2124     if (!x96_synth && (s->ext_audio_mask & (DCA_CSS_X96 | DCA_EXSS_X96))) {
2125         x96_nchannels = s->x96_nchannels;
2126         x96_synth = 1;
2127     }
2128     if (x96_synth < 0)
2129         x96_synth = 0;
2130
2131     s->output_rate = s->sample_rate << x96_synth;
2132     s->npcmsamples = nsamples = (s->npcmblocks * DCA_PCMBLOCK_SAMPLES) << x96_synth;
2133
2134     // Reallocate PCM output buffer
2135     av_fast_malloc(&s->output_buffer, &s->output_size,
2136                    nsamples * av_popcount(s->ch_mask) * sizeof(int32_t));
2137     if (!s->output_buffer)
2138         return AVERROR(ENOMEM);
2139
2140     ptr = (int32_t *)s->output_buffer;
2141     for (spkr = 0; spkr < DCA_SPEAKER_COUNT; spkr++) {
2142         if (s->ch_mask & (1U << spkr)) {
2143             s->output_samples[spkr] = ptr;
2144             ptr += nsamples;
2145         } else {
2146             s->output_samples[spkr] = NULL;
2147         }
2148     }
2149
2150     // Handle change of filtering mode
2151     set_filter_mode(s, x96_synth | DCA_FILTER_MODE_FIXED);
2152
2153     // Select filter
2154     if (x96_synth)
2155         filter_coeff = ff_dca_fir_64bands_fixed;
2156     else if (s->filter_perfect)
2157         filter_coeff = ff_dca_fir_32bands_perfect_fixed;
2158     else
2159         filter_coeff = ff_dca_fir_32bands_nonperfect_fixed;
2160
2161     // Filter primary channels
2162     for (ch = 0; ch < s->nchannels; ch++) {
2163         // Map this primary channel to speaker
2164         spkr = map_prm_ch_to_spkr(s, ch);
2165         if (spkr < 0)
2166             return AVERROR(EINVAL);
2167
2168         // Filter bank reconstruction
2169         s->dcadsp->sub_qmf_fixed[x96_synth](
2170             &s->synth,
2171             &s->dcadct,
2172             s->output_samples[spkr],
2173             s->subband_samples[ch],
2174             ch < x96_nchannels ? s->x96_subband_samples[ch] : NULL,
2175             s->dcadsp_data[ch].u.fix.hist1,
2176             &s->dcadsp_data[ch].offset,
2177             s->dcadsp_data[ch].u.fix.hist2,
2178             filter_coeff,
2179             s->npcmblocks);
2180     }
2181
2182     // Filter LFE channel
2183     if (s->lfe_present) {
2184         int32_t *samples = s->output_samples[DCA_SPEAKER_LFE1];
2185         int nlfesamples = s->npcmblocks >> 1;
2186
2187         // Check LFF
2188         if (s->lfe_present == LFE_FLAG_128) {
2189             av_log(s->avctx, AV_LOG_ERROR, "Fixed point mode doesn't support LFF=1\n");
2190             return AVERROR(EINVAL);
2191         }
2192
2193         // Offset intermediate buffer for X96
2194         if (x96_synth)
2195             samples += nsamples / 2;
2196
2197         // Interpolate LFE channel
2198         s->dcadsp->lfe_fir_fixed(samples, s->lfe_samples + DCA_LFE_HISTORY,
2199                                  ff_dca_lfe_fir_64_fixed, s->npcmblocks);
2200
2201         if (x96_synth) {
2202             // Filter 96 kHz oversampled LFE PCM to attenuate high frequency
2203             // (47.6 - 48.0 kHz) components of interpolation image
2204             s->dcadsp->lfe_x96_fixed(s->output_samples[DCA_SPEAKER_LFE1],
2205                                      samples, &s->output_history_lfe_fixed,
2206                                      nsamples / 2);
2207
2208         }
2209
2210         // Update LFE history
2211         for (n = DCA_LFE_HISTORY - 1; n >= 0; n--)
2212             s->lfe_samples[n] = s->lfe_samples[nlfesamples + n];
2213     }
2214
2215     return 0;
2216 }
2217
2218 static int filter_frame_fixed(DCACoreDecoder *s, AVFrame *frame)
2219 {
2220     AVCodecContext *avctx = s->avctx;
2221     DCAContext *dca = avctx->priv_data;
2222     int i, n, ch, ret, spkr, nsamples;
2223
2224     // Don't filter twice when falling back from XLL
2225     if (!(dca->packet & DCA_PACKET_XLL) && (ret = ff_dca_core_filter_fixed(s, 0)) < 0)
2226         return ret;
2227
2228     avctx->sample_rate = s->output_rate;
2229     avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
2230     avctx->bits_per_raw_sample = 24;
2231
2232     frame->nb_samples = nsamples = s->npcmsamples;
2233     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
2234         return ret;
2235
2236     // Undo embedded XCH downmix
2237     if (s->es_format && (s->ext_audio_mask & DCA_CSS_XCH)
2238         && s->audio_mode >= AMODE_2F2R) {
2239         s->dcadsp->dmix_sub_xch(s->output_samples[DCA_SPEAKER_Ls],
2240                                 s->output_samples[DCA_SPEAKER_Rs],
2241                                 s->output_samples[DCA_SPEAKER_Cs],
2242                                 nsamples);
2243
2244     }
2245
2246     // Undo embedded XXCH downmix
2247     if ((s->ext_audio_mask & (DCA_CSS_XXCH | DCA_EXSS_XXCH))
2248         && s->xxch_dmix_embedded) {
2249         int scale_inv   = s->xxch_dmix_scale_inv;
2250         int *coeff_ptr  = s->xxch_dmix_coeff;
2251         int xch_base    = ff_dca_channels[s->audio_mode];
2252         av_assert1(s->nchannels - xch_base <= DCA_XXCH_CHANNELS_MAX);
2253
2254         // Undo embedded core downmix pre-scaling
2255         for (spkr = 0; spkr < s->xxch_mask_nbits; spkr++) {
2256             if (s->xxch_core_mask & (1U << spkr)) {
2257                 s->dcadsp->dmix_scale_inv(s->output_samples[spkr],
2258                                           scale_inv, nsamples);
2259             }
2260         }
2261
2262         // Undo downmix
2263         for (ch = xch_base; ch < s->nchannels; ch++) {
2264             int src_spkr = map_prm_ch_to_spkr(s, ch);
2265             if (src_spkr < 0)
2266                 return AVERROR(EINVAL);
2267             for (spkr = 0; spkr < s->xxch_mask_nbits; spkr++) {
2268                 if (s->xxch_dmix_mask[ch - xch_base] & (1U << spkr)) {
2269                     int coeff = mul16(*coeff_ptr++, scale_inv);
2270                     if (coeff) {
2271                         s->dcadsp->dmix_sub(s->output_samples[spkr    ],
2272                                             s->output_samples[src_spkr],
2273                                             coeff, nsamples);
2274                     }
2275                 }
2276             }
2277         }
2278     }
2279
2280     if (!(s->ext_audio_mask & (DCA_CSS_XXCH | DCA_CSS_XCH | DCA_EXSS_XXCH))) {
2281         // Front sum/difference decoding
2282         if ((s->sumdiff_front && s->audio_mode > AMODE_MONO)
2283             || s->audio_mode == AMODE_STEREO_SUMDIFF) {
2284             s->fixed_dsp->butterflies_fixed(s->output_samples[DCA_SPEAKER_L],
2285                                             s->output_samples[DCA_SPEAKER_R],
2286                                             nsamples);
2287         }
2288
2289         // Surround sum/difference decoding
2290         if (s->sumdiff_surround && s->audio_mode >= AMODE_2F2R) {
2291             s->fixed_dsp->butterflies_fixed(s->output_samples[DCA_SPEAKER_Ls],
2292                                             s->output_samples[DCA_SPEAKER_Rs],
2293                                             nsamples);
2294         }
2295     }
2296
2297     // Downmix primary channel set to stereo
2298     if (s->request_mask != s->ch_mask) {
2299         ff_dca_downmix_to_stereo_fixed(s->dcadsp,
2300                                        s->output_samples,
2301                                        s->prim_dmix_coeff,
2302                                        nsamples, s->ch_mask);
2303     }
2304
2305     for (i = 0; i < avctx->channels; i++) {
2306         int32_t *samples = s->output_samples[s->ch_remap[i]];
2307         int32_t *plane = (int32_t *)frame->extended_data[i];
2308         for (n = 0; n < nsamples; n++)
2309             plane[n] = clip23(samples[n]) * (1 << 8);
2310     }
2311
2312     return 0;
2313 }
2314
2315 static int filter_frame_float(DCACoreDecoder *s, AVFrame *frame)
2316 {
2317     AVCodecContext *avctx = s->avctx;
2318     int x96_nchannels = 0, x96_synth = 0;
2319     int i, n, ch, ret, spkr, nsamples, nchannels;
2320     float *output_samples[DCA_SPEAKER_COUNT] = { NULL }, *ptr;
2321     const float *filter_coeff;
2322
2323     if (s->ext_audio_mask & (DCA_CSS_X96 | DCA_EXSS_X96)) {
2324         x96_nchannels = s->x96_nchannels;
2325         x96_synth = 1;
2326     }
2327
2328     avctx->sample_rate = s->sample_rate << x96_synth;
2329     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
2330     avctx->bits_per_raw_sample = 0;
2331
2332     frame->nb_samples = nsamples = (s->npcmblocks * DCA_PCMBLOCK_SAMPLES) << x96_synth;
2333     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
2334         return ret;
2335
2336     // Build reverse speaker to channel mapping
2337     for (i = 0; i < avctx->channels; i++)
2338         output_samples[s->ch_remap[i]] = (float *)frame->extended_data[i];
2339
2340     // Allocate space for extra channels
2341     nchannels = av_popcount(s->ch_mask) - avctx->channels;
2342     if (nchannels > 0) {
2343         av_fast_malloc(&s->output_buffer, &s->output_size,
2344                        nsamples * nchannels * sizeof(float));
2345         if (!s->output_buffer)
2346             return AVERROR(ENOMEM);
2347
2348         ptr = (float *)s->output_buffer;
2349         for (spkr = 0; spkr < DCA_SPEAKER_COUNT; spkr++) {
2350             if (!(s->ch_mask & (1U << spkr)))
2351                 continue;
2352             if (output_samples[spkr])
2353                 continue;
2354             output_samples[spkr] = ptr;
2355             ptr += nsamples;
2356         }
2357     }
2358
2359     // Handle change of filtering mode
2360     set_filter_mode(s, x96_synth);
2361
2362     // Select filter
2363     if (x96_synth)
2364         filter_coeff = ff_dca_fir_64bands;
2365     else if (s->filter_perfect)
2366         filter_coeff = ff_dca_fir_32bands_perfect;
2367     else
2368         filter_coeff = ff_dca_fir_32bands_nonperfect;
2369
2370     // Filter primary channels
2371     for (ch = 0; ch < s->nchannels; ch++) {
2372         // Map this primary channel to speaker
2373         spkr = map_prm_ch_to_spkr(s, ch);
2374         if (spkr < 0)
2375             return AVERROR(EINVAL);
2376
2377         // Filter bank reconstruction
2378         s->dcadsp->sub_qmf_float[x96_synth](
2379             &s->synth,
2380             &s->imdct[x96_synth],
2381             output_samples[spkr],
2382             s->subband_samples[ch],
2383             ch < x96_nchannels ? s->x96_subband_samples[ch] : NULL,
2384             s->dcadsp_data[ch].u.flt.hist1,
2385             &s->dcadsp_data[ch].offset,
2386             s->dcadsp_data[ch].u.flt.hist2,
2387             filter_coeff,
2388             s->npcmblocks,
2389             1.0f / (1 << (17 - x96_synth)));
2390     }
2391
2392     // Filter LFE channel
2393     if (s->lfe_present) {
2394         int dec_select = (s->lfe_present == LFE_FLAG_128);
2395         float *samples = output_samples[DCA_SPEAKER_LFE1];
2396         int nlfesamples = s->npcmblocks >> (dec_select + 1);
2397
2398         // Offset intermediate buffer for X96
2399         if (x96_synth)
2400             samples += nsamples / 2;
2401
2402         // Select filter
2403         if (dec_select)
2404             filter_coeff = ff_dca_lfe_fir_128;
2405         else
2406             filter_coeff = ff_dca_lfe_fir_64;
2407
2408         // Interpolate LFE channel
2409         s->dcadsp->lfe_fir_float[dec_select](
2410             samples, s->lfe_samples + DCA_LFE_HISTORY,
2411             filter_coeff, s->npcmblocks);
2412
2413         if (x96_synth) {
2414             // Filter 96 kHz oversampled LFE PCM to attenuate high frequency
2415             // (47.6 - 48.0 kHz) components of interpolation image
2416             s->dcadsp->lfe_x96_float(output_samples[DCA_SPEAKER_LFE1],
2417                                      samples, &s->output_history_lfe_float,
2418                                      nsamples / 2);
2419         }
2420
2421         // Update LFE history
2422         for (n = DCA_LFE_HISTORY - 1; n >= 0; n--)
2423             s->lfe_samples[n] = s->lfe_samples[nlfesamples + n];
2424     }
2425
2426     // Undo embedded XCH downmix
2427     if (s->es_format && (s->ext_audio_mask & DCA_CSS_XCH)
2428         && s->audio_mode >= AMODE_2F2R) {
2429         s->float_dsp->vector_fmac_scalar(output_samples[DCA_SPEAKER_Ls],
2430                                          output_samples[DCA_SPEAKER_Cs],
2431                                          -M_SQRT1_2, nsamples);
2432         s->float_dsp->vector_fmac_scalar(output_samples[DCA_SPEAKER_Rs],
2433                                          output_samples[DCA_SPEAKER_Cs],
2434                                          -M_SQRT1_2, nsamples);
2435     }
2436
2437     // Undo embedded XXCH downmix
2438     if ((s->ext_audio_mask & (DCA_CSS_XXCH | DCA_EXSS_XXCH))
2439         && s->xxch_dmix_embedded) {
2440         float scale_inv = s->xxch_dmix_scale_inv * (1.0f / (1 << 16));
2441         int *coeff_ptr  = s->xxch_dmix_coeff;
2442         int xch_base    = ff_dca_channels[s->audio_mode];
2443         av_assert1(s->nchannels - xch_base <= DCA_XXCH_CHANNELS_MAX);
2444
2445         // Undo downmix
2446         for (ch = xch_base; ch < s->nchannels; ch++) {
2447             int src_spkr = map_prm_ch_to_spkr(s, ch);
2448             if (src_spkr < 0)
2449                 return AVERROR(EINVAL);
2450             for (spkr = 0; spkr < s->xxch_mask_nbits; spkr++) {
2451                 if (s->xxch_dmix_mask[ch - xch_base] & (1U << spkr)) {
2452                     int coeff = *coeff_ptr++;
2453                     if (coeff) {
2454                         s->float_dsp->vector_fmac_scalar(output_samples[    spkr],
2455                                                          output_samples[src_spkr],
2456                                                          coeff * (-1.0f / (1 << 15)),
2457                                                          nsamples);
2458                     }
2459                 }
2460             }
2461         }
2462
2463         // Undo embedded core downmix pre-scaling
2464         for (spkr = 0; spkr < s->xxch_mask_nbits; spkr++) {
2465             if (s->xxch_core_mask & (1U << spkr)) {
2466                 s->float_dsp->vector_fmul_scalar(output_samples[spkr],
2467                                                  output_samples[spkr],
2468                                                  scale_inv, nsamples);
2469             }
2470         }
2471     }
2472
2473     if (!(s->ext_audio_mask & (DCA_CSS_XXCH | DCA_CSS_XCH | DCA_EXSS_XXCH))) {
2474         // Front sum/difference decoding
2475         if ((s->sumdiff_front && s->audio_mode > AMODE_MONO)
2476             || s->audio_mode == AMODE_STEREO_SUMDIFF) {
2477             s->float_dsp->butterflies_float(output_samples[DCA_SPEAKER_L],
2478                                             output_samples[DCA_SPEAKER_R],
2479                                             nsamples);
2480         }
2481
2482         // Surround sum/difference decoding
2483         if (s->sumdiff_surround && s->audio_mode >= AMODE_2F2R) {
2484             s->float_dsp->butterflies_float(output_samples[DCA_SPEAKER_Ls],
2485                                             output_samples[DCA_SPEAKER_Rs],
2486                                             nsamples);
2487         }
2488     }
2489
2490     // Downmix primary channel set to stereo
2491     if (s->request_mask != s->ch_mask) {
2492         ff_dca_downmix_to_stereo_float(s->float_dsp, output_samples,
2493                                        s->prim_dmix_coeff,
2494                                        nsamples, s->ch_mask);
2495     }
2496
2497     return 0;
2498 }
2499
2500 int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame)
2501 {
2502     AVCodecContext *avctx = s->avctx;
2503     DCAContext *dca = avctx->priv_data;
2504     DCAExssAsset *asset = &dca->exss.assets[0];
2505     enum AVMatrixEncoding matrix_encoding;
2506     int ret;
2507
2508     // Handle downmixing to stereo request
2509     if (dca->request_channel_layout == DCA_SPEAKER_LAYOUT_STEREO
2510         && s->audio_mode > AMODE_MONO && s->prim_dmix_embedded
2511         && (s->prim_dmix_type == DCA_DMIX_TYPE_LoRo ||
2512             s->prim_dmix_type == DCA_DMIX_TYPE_LtRt))
2513         s->request_mask = DCA_SPEAKER_LAYOUT_STEREO;
2514     else
2515         s->request_mask = s->ch_mask;
2516     if (!ff_dca_set_channel_layout(avctx, s->ch_remap, s->request_mask))
2517         return AVERROR(EINVAL);
2518
2519     // Force fixed point mode when falling back from XLL
2520     if ((avctx->flags & AV_CODEC_FLAG_BITEXACT) || ((dca->packet & DCA_PACKET_EXSS)
2521                                                     && (asset->extension_mask & DCA_EXSS_XLL)))
2522         ret = filter_frame_fixed(s, frame);
2523     else
2524         ret = filter_frame_float(s, frame);
2525     if (ret < 0)
2526         return ret;
2527
2528     // Set profile, bit rate, etc
2529     if (s->ext_audio_mask & DCA_EXSS_MASK)
2530         avctx->profile = FF_PROFILE_DTS_HD_HRA;
2531     else if (s->ext_audio_mask & (DCA_CSS_XXCH | DCA_CSS_XCH))
2532         avctx->profile = FF_PROFILE_DTS_ES;
2533     else if (s->ext_audio_mask & DCA_CSS_X96)
2534         avctx->profile = FF_PROFILE_DTS_96_24;
2535     else
2536         avctx->profile = FF_PROFILE_DTS;
2537
2538     if (s->bit_rate > 3 && !(s->ext_audio_mask & DCA_EXSS_MASK))
2539         avctx->bit_rate = s->bit_rate;
2540     else
2541         avctx->bit_rate = 0;
2542
2543     if (s->audio_mode == AMODE_STEREO_TOTAL || (s->request_mask != s->ch_mask &&
2544                                                 s->prim_dmix_type == DCA_DMIX_TYPE_LtRt))
2545         matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
2546     else
2547         matrix_encoding = AV_MATRIX_ENCODING_NONE;
2548     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
2549         return ret;
2550
2551     return 0;
2552 }
2553
2554 av_cold void ff_dca_core_flush(DCACoreDecoder *s)
2555 {
2556     if (s->subband_buffer) {
2557         erase_adpcm_history(s);
2558         memset(s->lfe_samples, 0, DCA_LFE_HISTORY * sizeof(int32_t));
2559     }
2560
2561     if (s->x96_subband_buffer)
2562         erase_x96_adpcm_history(s);
2563
2564     erase_dsp_history(s);
2565 }
2566
2567 av_cold int ff_dca_core_init(DCACoreDecoder *s)
2568 {
2569     dca_init_vlcs();
2570
2571     if (!(s->float_dsp = avpriv_float_dsp_alloc(0)))
2572         return -1;
2573     if (!(s->fixed_dsp = avpriv_alloc_fixed_dsp(0)))
2574         return -1;
2575
2576     ff_dcadct_init(&s->dcadct);
2577     if (ff_mdct_init(&s->imdct[0], 6, 1, 1.0) < 0)
2578         return -1;
2579     if (ff_mdct_init(&s->imdct[1], 7, 1, 1.0) < 0)
2580         return -1;
2581     ff_synth_filter_init(&s->synth);
2582
2583     s->x96_rand = 1;
2584     return 0;
2585 }
2586
2587 av_cold void ff_dca_core_close(DCACoreDecoder *s)
2588 {
2589     av_freep(&s->float_dsp);
2590     av_freep(&s->fixed_dsp);
2591
2592     ff_mdct_end(&s->imdct[0]);
2593     ff_mdct_end(&s->imdct[1]);
2594
2595     av_freep(&s->subband_buffer);
2596     s->subband_size = 0;
2597
2598     av_freep(&s->x96_subband_buffer);
2599     s->x96_subband_size = 0;
2600
2601     av_freep(&s->output_buffer);
2602     s->output_size = 0;
2603 }