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