FFmpeg
dca_core.c
Go to the documentation of this file.
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 = ff_dca_parse_core_frame_header(&h, &s->gb);
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)
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 }
dcamath.h
DCA_SPEAKER_Lss
@ DCA_SPEAKER_Lss
Definition: dca.h:81
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
DCA_SPEAKER_C
@ DCA_SPEAKER_C
Definition: dca.h:79
DCA_SYNCWORD_XBR
#define DCA_SYNCWORD_XBR
Definition: dca_syncwords.h:29
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_dca_high_freq_vq
const int8_t ff_dca_high_freq_vq[1024][32]
Definition: dcadata.c:4240
parse_xch_frame
static int parse_xch_frame(DCACoreDecoder *s)
Definition: dca_core.c:837
DCA_EXT_AUDIO_X96
@ DCA_EXT_AUDIO_X96
Definition: dca_core.h:76
DCAContext::crctab
const AVCRC * crctab
Definition: dcadec.h:57
alloc_x96_sample_buffer
static int alloc_x96_sample_buffer(DCACoreDecoder *s)
Definition: dca_core.c:1280
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
ff_dca_core_parse_exss
int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset)
Definition: dca_core.c:1831
DCA_SPEAKER_LAYOUT_5POINT0
#define DCA_SPEAKER_LAYOUT_5POINT0
Definition: dca.h:129
dca_get_vlc
static int dca_get_vlc(GetBitContext *s, DCAVLC *v, int i)
Definition: dca_core.c:68
parse_aux_data
static int parse_aux_data(DCACoreDecoder *s)
Definition: dca_core.c:1617
ff_dca_core_close
av_cold void ff_dca_core_close(DCACoreDecoder *s)
Definition: dca_core.c:2430
ff_dca_bit_rates
const uint32_t ff_dca_bit_rates[32]
Definition: dcadata.c:32
DCA_LFE_FLAG_128
@ DCA_LFE_FLAG_128
Definition: dca_core.h:82
DCAVLC::offset
int offset
Code values offset.
Definition: dcahuff.h:36
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
DCA_CSS_XCH
@ DCA_CSS_XCH
Definition: dca.h:173
DCA_SPEAKER_MASK_Rs
@ DCA_SPEAKER_MASK_Rs
Definition: dca.h:96
parse_xxch_frame
static int parse_xxch_frame(DCACoreDecoder *s)
Definition: dca_core.c:858
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
parse_x96_subframe_audio
static int parse_x96_subframe_audio(DCACoreDecoder *s, int sf, int xch_base, int *sub_pos)
Definition: dca_core.c:1159
parse_x96_frame_exss
static int parse_x96_frame_exss(DCACoreDecoder *s)
Definition: dca_core.c:1541
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
DCAExssAsset::x96_size
int x96_size
Size of X96 extension in extension substream.
Definition: dca_exss.h:57
DCA_SPEAKER_MASK_Lss
@ DCA_SPEAKER_MASK_Lss
Definition: dca.h:101
DCA_EXSS_XXCH
@ DCA_EXSS_XXCH
Definition: dca.h:177
ff_dca_lossy_quant
const uint32_t ff_dca_lossy_quant[32]
Definition: dcadata.c:4223
map_prm_ch_to_spkr
static int map_prm_ch_to_spkr(DCACoreDecoder *s, int ch)
Definition: dca_core.c:1908
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
data
const char data[16]
Definition: mxf.c:142
DCA_SPEAKER_LAYOUT_STEREO
#define DCA_SPEAKER_LAYOUT_STEREO
Definition: dca.h:123
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
DCAContext::request_channel_layout
int request_channel_layout
Converted from avctx.request_channel_layout.
Definition: dcadec.h:64
ff_dca_fir_64bands
const float ff_dca_fir_64bands[1024]
Definition: dcadata.c:7550
ff_dca_seek_bits
static int ff_dca_seek_bits(GetBitContext *s, int p)
Definition: dcadec.h:89
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
DCA_AMODE_STEREO_SUMDIFF
@ DCA_AMODE_STEREO_SUMDIFF
Definition: dca_core.h:63
DCA_SUBBAND_SAMPLES
#define DCA_SUBBAND_SAMPLES
Definition: dca_core.h:45
av_popcount
#define av_popcount
Definition: common.h:176
ff_dca_check_crc
static int ff_dca_check_crc(AVCodecContext *avctx, GetBitContext *s, int p1, int p2)
Definition: dcadec.h:75
mul23
static int32_t mul23(int32_t a, int32_t b)
Definition: dcamath.h:50
DCA_PACKET_XLL
#define DCA_PACKET_XLL
Definition: dcadec.h:39
DCA_FILTER_MODE_FIXED
#define DCA_FILTER_MODE_FIXED
Definition: dca_core.h:57
parse_x96_frame_data
static int parse_x96_frame_data(DCACoreDecoder *s, int exss, int xch_base)
Definition: dca_core.c:1477
parse_coding_header
static int parse_coding_header(DCACoreDecoder *s, enum HeaderType header, int xch_base)
Definition: dca_core.c:151
FF_DCA_DMIXTABLE_OFFSET
#define FF_DCA_DMIXTABLE_OFFSET
Definition: dcadata.h:71
parse_block_codes
static int parse_block_codes(DCACoreDecoder *s, int32_t *audio, int abits)
Definition: dca_core.c:546
erase_adpcm_history
static void erase_adpcm_history(DCACoreDecoder *s)
Definition: dca_core.c:758
DCAExssAsset
Definition: dca_exss.h:29
DCAExssAsset::xbr_size
int xbr_size
Size of XBR extension in extension substream.
Definition: dca_exss.h:51
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
DCA_SYNCWORD_X96
#define DCA_SYNCWORD_X96
Definition: dca_syncwords.h:28
ff_dca_core_filter_frame
int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame)
Definition: dca_core.c:2345
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
ff_synth_filter_init
av_cold void ff_synth_filter_init(SynthFilterContext *c)
Definition: synth_filter.c:171
ff_dca_lfe_fir_128
const float ff_dca_lfe_fir_128[256]
Definition: dcadata.c:7482
ff_dca_vlc_transition_mode
DCAVLC ff_dca_vlc_transition_mode
Definition: dcahuff.c:1246
DCA_LFE_HISTORY
#define DCA_LFE_HISTORY
Definition: dca_core.h:47
DCA_EXSS_XLL
@ DCA_EXSS_XLL
Definition: dca.h:180
DCAContext::core_only
int core_only
Core only decoding flag.
Definition: dcadec.h:65
ff_dca_fir_32bands_nonperfect
const float ff_dca_fir_32bands_nonperfect[512]
Definition: dcadata.c:6808
parse_x96_subframe_header
static int parse_x96_subframe_header(DCACoreDecoder *s, int xch_base)
Definition: dca_core.c:1306
U
#define U(x)
Definition: vp56_arith.h:37
ff_dca_quant_index_group_size
const uint8_t ff_dca_quant_index_group_size[DCA_CODE_BOOKS]
Definition: dcadata.c:53
mul31
static int32_t mul31(int32_t a, int32_t b)
Definition: dcamath.h:51
DCA_PARSE_ERROR_FRAME_SIZE
@ DCA_PARSE_ERROR_FRAME_SIZE
Definition: dca.h:43
FF_PROFILE_DTS_HD_HRA
#define FF_PROFILE_DTS_HD_HRA
Definition: avcodec.h:1883
GetBitContext
Definition: get_bits.h:61
DCA_EXT_AUDIO_XXCH
@ DCA_EXT_AUDIO_XXCH
Definition: dca_core.h:77
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
ff_dca_downmix_to_stereo_float
void ff_dca_downmix_to_stereo_float(AVFloatDSPContext *fdsp, float **samples, int *coeff_l, int nsamples, int ch_mask)
Definition: dcadec.c:110
inverse_adpcm
static void inverse_adpcm(int32_t **subband_samples, const int16_t *vq_index, const int8_t *prediction_mode, int sb_start, int sb_end, int ofs, int len)
Definition: dca_core.c:600
HEADER_XCH
@ HEADER_XCH
Definition: dca_core.c:34
ff_dca_quant_levels
const uint32_t ff_dca_quant_levels[32]
Definition: dcadata.c:4215
dcadata.h
clip23
static int32_t clip23(int32_t a)
Definition: dcamath.h:54
avpriv_alloc_fixed_dsp
AVFixedDSPContext * avpriv_alloc_fixed_dsp(int bit_exact)
Allocate and initialize a fixed DSP context.
Definition: fixed_dsp.c:149
parse_optional_info
static int parse_optional_info(DCACoreDecoder *s)
Definition: dca_core.c:1685
DCACoreDecoder
Definition: dca_core.h:101
parse_xbr_subframe
static int parse_xbr_subframe(DCACoreDecoder *s, int xbr_base_ch, int xbr_nchannels, int *xbr_nsubbands, int xbr_transition_mode, int sf, int *sub_pos)
Definition: dca_core.c:935
DCA_SPEAKER_LFE1
@ DCA_SPEAKER_LFE1
Definition: dca.h:80
DCAContext::exss
DCAExssParser exss
EXSS parser context.
Definition: dcadec.h:51
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
DCA_AMODE_STEREO_TOTAL
@ DCA_AMODE_STEREO_TOTAL
Definition: dca_core.h:64
AV_MATRIX_ENCODING_DOLBY
@ AV_MATRIX_ENCODING_DOLBY
Definition: channel_layout.h:122
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
DCA_SPEAKER_MASK_Cs
@ DCA_SPEAKER_MASK_Cs
Definition: dca.h:98
DCA_DMIX_TYPE_LoRo
@ DCA_DMIX_TYPE_LoRo
Definition: dca.h:188
ff_dcaadpcm_predict
static int64_t ff_dcaadpcm_predict(int pred_vq_index, const int32_t *input)
Definition: dcaadpcm.h:33
mask
static const uint16_t mask[17]
Definition: lzw.c:38
ff_dca_downmix_to_stereo_fixed
void ff_dca_downmix_to_stereo_fixed(DCADSPContext *dcadsp, int32_t **samples, int *coeff_l, int nsamples, int ch_mask)
Definition: dcadec.c:79
ff_dca_lfe_fir_64_fixed
const int32_t ff_dca_lfe_fir_64_fixed[256]
Definition: dcadata.c:8336
DCA_SPEAKER_Cs
@ DCA_SPEAKER_Cs
Definition: dca.h:80
DCA_SPEAKER_Rss
@ DCA_SPEAKER_Rss
Definition: dca.h:81
DCAVLC::max_depth
int max_depth
Parameter for get_vlc2()
Definition: dcahuff.h:37
DCAContext::packet
int packet
Packet flags.
Definition: dcadec.h:62
s
#define s(width, name)
Definition: cbs_vp9.c:257
DCA_ADPCM_COEFFS
#define DCA_ADPCM_COEFFS
Definition: dcadata.h:28
DCA_ABITS_MAX
#define DCA_ABITS_MAX
Definition: dca_core.h:48
parse_xbr_frame
static int parse_xbr_frame(DCACoreDecoder *s)
Definition: dca_core.c:1070
set_filter_mode
static void set_filter_mode(DCACoreDecoder *s, int mode)
Definition: dca_core.c:1951
DCA_SPEAKER_Ls
@ DCA_SPEAKER_Ls
Definition: dca.h:79
HEADER_CORE
@ HEADER_CORE
Definition: dca_core.c:33
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
DCA_PARSE_ERROR_PCM_RES
@ DCA_PARSE_ERROR_PCM_RES
Definition: dca.h:48
mul16
static int32_t mul16(int32_t a, int32_t b)
Definition: dcamath.h:47
DCA_AMODE_MONO
@ DCA_AMODE_MONO
Definition: dca_core.h:60
dcadec.h
HEADER_XXCH
@ HEADER_XXCH
Definition: dca_core.c:35
f
#define f(width, name)
Definition: cbs_vp9.c:255
dca_syncwords.h
int32_t
int32_t
Definition: audio_convert.c:194
DCA_SPEAKER_LAYOUT_3_0
#define DCA_SPEAKER_LAYOUT_3_0
Definition: dca.h:125
DCA_EXSS_XBR
@ DCA_EXSS_XBR
Definition: dca.h:176
ff_dca_set_channel_layout
int ff_dca_set_channel_layout(AVCodecContext *avctx, int *ch_remap, int dca_mask)
Definition: dcadec.c:32
AVMatrixEncoding
AVMatrixEncoding
Definition: channel_layout.h:120
NULL
#define NULL
Definition: coverity.c:32
alloc_sample_buffer
static int alloc_sample_buffer(DCACoreDecoder *s)
Definition: dca_core.c:771
AV_COPY128
#define AV_COPY128(d, s)
Definition: intreadwrite.h:609
DCA_CSS_X96
@ DCA_CSS_X96
Definition: dca.h:172
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
ff_dcadct_init
av_cold void ff_dcadct_init(DCADCTContext *c)
Definition: dcadct.c:358
parse_x96_frame
static int parse_x96_frame(DCACoreDecoder *s)
Definition: dca_core.c:1512
ff_dca_lossless_quant
const uint32_t ff_dca_lossless_quant[32]
Definition: dcadata.c:4231
ff_dca_dmix_primary_nch
const uint8_t ff_dca_dmix_primary_nch[8]
Definition: dcadata.c:45
DCA_SPEAKER_Rs
@ DCA_SPEAKER_Rs
Definition: dca.h:80
ff_dca_lfe_fir_64
const float ff_dca_lfe_fir_64[256]
Definition: dcadata.c:7339
parse_subframe_audio
static int parse_subframe_audio(DCACoreDecoder *s, int sf, enum HeaderType header, int xch_base, int *sub_pos, int *lfe_pos)
Definition: dca_core.c:621
FF_PROFILE_DTS_ES
#define FF_PROFILE_DTS_ES
Definition: avcodec.h:1881
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
DCA_SYNCWORD_XCH
#define DCA_SYNCWORD_XCH
Definition: dca_syncwords.h:26
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:507
DCA_EXSS_X96
@ DCA_EXSS_X96
Definition: dca.h:178
DCA_SPEAKER_LAYOUT_2_2
#define DCA_SPEAKER_LAYOUT_2_2
Definition: dca.h:128
DCAVLC::vlc
VLC vlc[7]
Actual codes.
Definition: dcahuff.h:38
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:202
ff_dca_fir_64bands_fixed
const int32_t ff_dca_fir_64bands_fixed[1024]
Definition: dcadata.c:8371
extract_audio
static int extract_audio(DCACoreDecoder *s, int32_t *audio, int abits, int ch)
Definition: dca_core.c:573
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
AV_ZERO128
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
DCA_SPEAKER_LAYOUT_MONO
#define DCA_SPEAKER_LAYOUT_MONO
Definition: dca.h:122
DCA_CHANNELS
#define DCA_CHANNELS
Definition: dca_core.h:41
index
int index
Definition: gxfenc.c:89
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
rand_x96
static int rand_x96(DCACoreDecoder *s)
Definition: dca_core.c:1153
ff_dca_inv_dmixtable
const uint32_t ff_dca_inv_dmixtable[FF_DCA_INV_DMIXTABLE_SIZE]
Definition: dcadata.c:8676
DCACoreFrameHeader
Definition: dca.h:51
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
dcahuff.h
ff_dca_dmixtable
const uint16_t ff_dca_dmixtable[FF_DCA_DMIXTABLE_SIZE]
Definition: dcadata.c:8642
ff_dca_scale_factor_quant7
const uint32_t ff_dca_scale_factor_quant7[128]
Definition: dcadata.c:4172
ff_dca_channels
const uint8_t ff_dca_channels[16]
Definition: dcadata.c:41
AV_MATRIX_ENCODING_NONE
@ AV_MATRIX_ENCODING_NONE
Definition: channel_layout.h:121
scale_table
static const uint8_t scale_table[]
Definition: hca_data.h:53
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
ff_dca_core_parse
int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size)
Definition: dca_core.c:1798
size
int size
Definition: twinvq_data.h:10344
DCA_SYNCWORD_XXCH
#define DCA_SYNCWORD_XXCH
Definition: dca_syncwords.h:27
DCA_CODE_BOOKS
#define DCA_CODE_BOOKS
Definition: dcahuff.h:32
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:162
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
DCA_SUBBANDS_X96
#define DCA_SUBBANDS_X96
Definition: dca_core.h:43
block_code_nbits
static const uint8_t block_code_nbits[7]
Definition: dca_core.c:64
dcaadpcm.h
FF_PROFILE_DTS
#define FF_PROFILE_DTS
Definition: avcodec.h:1880
erase_dsp_history
static void erase_dsp_history(DCACoreDecoder *s)
Definition: dca_core.c:1944
header
static const uint8_t header[24]
Definition: sdr2.c:67
parse_scale
static int parse_scale(DCACoreDecoder *s, int *scale_index, int sel)
Definition: dca_core.c:347
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
DCA_AMODE_2F2R
@ DCA_AMODE_2F2R
Definition: dca_core.h:68
DCA_SPEAKER_MASK_Rss
@ DCA_SPEAKER_MASK_Rss
Definition: dca.h:102
DCA_SPEAKER_R
@ DCA_SPEAKER_R
Definition: dca.h:79
ff_dca_vlc_scale_factor
DCAVLC ff_dca_vlc_scale_factor
Definition: dcahuff.c:1247
DCA_EXSS_MASK
@ DCA_EXSS_MASK
Definition: dca.h:183
DCA_PARSE_ERROR_DEFICIT_SAMPLES
@ DCA_PARSE_ERROR_DEFICIT_SAMPLES
Definition: dca.h:41
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
ff_dca_parse_core_frame_header
int ff_dca_parse_core_frame_header(DCACoreFrameHeader *h, GetBitContext *gb)
Parse and validate core frame header.
Definition: dca.c:91
ff_dca_core_init
av_cold int ff_dca_core_init(DCACoreDecoder *s)
Definition: dca_core.c:2412
HeaderType
HeaderType
Definition: dca_core.c:32
ff_dca_quant_index_sel_nbits
const uint8_t ff_dca_quant_index_sel_nbits[DCA_CODE_BOOKS]
Definition: dcadata.c:49
i
int i
Definition: input.c:407
prm_ch_to_spkr_map
static const int8_t prm_ch_to_spkr_map[DCA_AMODE_COUNT][5]
Definition: dca_core.c:38
DCAContext
Definition: dcadec.h:46
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
ff_dca_vlc_quant_index
DCAVLC ff_dca_vlc_quant_index[DCA_CODE_BOOKS]
Definition: dcahuff.c:1248
audio_mode_ch_mask
static const uint8_t audio_mode_ch_mask[DCA_AMODE_COUNT]
Definition: dca_core.c:51
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
dca.h
filter_frame_fixed
static int filter_frame_fixed(DCACoreDecoder *s, AVFrame *frame)
Definition: dca_core.c:2063
DCA_SPEAKER_MASK_LFE1
@ DCA_SPEAKER_MASK_LFE1
Definition: dca.h:97
uint8_t
uint8_t
Definition: audio_convert.c:194
DCA_DMIX_TYPE_LtRt
@ DCA_DMIX_TYPE_LtRt
Definition: dca.h:189
DCA_SPEAKER_LAYOUT_3_1
#define DCA_SPEAKER_LAYOUT_3_1
Definition: dca.h:127
len
int len
Definition: vorbis_enc_data.h:452
DCAExssParser::assets
DCAExssAsset assets[1]
Audio asset descriptors.
Definition: dca_exss.h:87
DCA_EXSS_CHSETS_MAX
#define DCA_EXSS_CHSETS_MAX
Definition: dca_core.h:54
DCA_EXT_AUDIO_XCH
@ DCA_EXT_AUDIO_XCH
Definition: dca_core.h:75
ff_dca_scale_factor_quant6
const uint32_t ff_dca_scale_factor_quant6[64]
Definition: dcadata.c:4161
DCA_DMIX_TYPE_COUNT
@ DCA_DMIX_TYPE_COUNT
Definition: dca.h:195
ff_dca_core_filter_fixed
int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth)
Definition: dca_core.c:1959
DCA_SUBBANDS
#define DCA_SUBBANDS
Definition: dca_core.h:42
VLC::bits
int bits
Definition: vlc.h:27
DCA_PCMBLOCK_SAMPLES
#define DCA_PCMBLOCK_SAMPLES
Definition: dca_core.h:46
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
ret
ret
Definition: filter_design.txt:187
DCA_PACKET_EXSS
#define DCA_PACKET_EXSS
Definition: dcadec.h:38
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_dca_fir_32bands_nonperfect_fixed
const int32_t ff_dca_fir_32bands_nonperfect_fixed[512]
Definition: dcadata.c:8205
FF_PROFILE_DTS_96_24
#define FF_PROFILE_DTS_96_24
Definition: avcodec.h:1882
parse_frame_data
static int parse_frame_data(DCACoreDecoder *s, enum HeaderType header, int xch_base)
Definition: dca_core.c:799
pos
unsigned int pos
Definition: spdifenc.c:412
ff_dca_bits_per_sample
const uint8_t ff_dca_bits_per_sample[8]
Definition: dca.c:50
filter_frame_float
static int filter_frame_float(DCACoreDecoder *s, AVFrame *frame)
Definition: dca_core.c:2160
DCA_SPEAKER_LAYOUT_2_1
#define DCA_SPEAKER_LAYOUT_2_1
Definition: dca.h:126
parse_joint_scale
static int parse_joint_scale(DCACoreDecoder *s, int sel)
Definition: dca_core.c:376
DCA_AMODE_COUNT
@ DCA_AMODE_COUNT
Definition: dca_core.h:71
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:58
ff_dca_core_dequantize
static void ff_dca_core_dequantize(int32_t *output, const int32_t *input, int32_t step_size, int32_t scale, int residual, int len)
Definition: dca_core.h:227
DCA_PARSE_ERROR_PCM_BLOCKS
@ DCA_PARSE_ERROR_PCM_BLOCKS
Definition: dca.h:42
parse_x96_coding_header
static int parse_x96_coding_header(DCACoreDecoder *s, int exss, int xch_base)
Definition: dca_core.c:1390
AVCodecContext
main external API structure.
Definition: avcodec.h:536
FF_DCA_DMIXTABLE_SIZE
#define FF_DCA_DMIXTABLE_SIZE
Definition: dcadata.h:69
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
DCA_PARSE_ERROR_LFE_FLAG
@ DCA_PARSE_ERROR_LFE_FLAG
Definition: dca.h:47
mode
mode
Definition: ebur128.h:83
FF_DCA_INV_DMIXTABLE_SIZE
#define FF_DCA_INV_DMIXTABLE_SIZE
Definition: dcadata.h:70
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1858
parse_huffman_codes
static int parse_huffman_codes(DCACoreDecoder *s, int32_t *audio, int abits, int sel)
Definition: dca_core.c:562
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
DCA_EXSS_CHANNELS_MAX
#define DCA_EXSS_CHANNELS_MAX
Definition: dca_core.h:53
DCA_XXCH_CHANNELS_MAX
#define DCA_XXCH_CHANNELS_MAX
Definition: dca_core.h:52
DCAVLC
Definition: dcahuff.h:35
DCA_PARSE_ERROR_SAMPLE_RATE
@ DCA_PARSE_ERROR_SAMPLE_RATE
Definition: dca.h:45
ff_side_data_update_matrix_encoding
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:114
DCAExssAsset::x96_offset
int x96_offset
Offset to X96 extension from start of substream.
Definition: dca_exss.h:56
DCA_PARSE_ERROR_RESERVED_BIT
@ DCA_PARSE_ERROR_RESERVED_BIT
Definition: dca.h:46
parse_subframe_header
static int parse_subframe_header(DCACoreDecoder *s, int sf, enum HeaderType header, int xch_base)
Definition: dca_core.c:399
DCA_SPEAKER_MASK_Ls
@ DCA_SPEAKER_MASK_Ls
Definition: dca.h:95
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
parse_frame_header
static int parse_frame_header(DCACoreDecoder *s)
Definition: dca_core.c:82
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
ff_dca_vlc_bit_allocation
DCAVLC ff_dca_vlc_bit_allocation
Definition: dcahuff.c:1245
DCAExssAsset::xbr_offset
int xbr_offset
Offset to XBR extension from start of substream.
Definition: dca_exss.h:50
ff_dca_fir_32bands_perfect_fixed
const int32_t ff_dca_fir_32bands_perfect_fixed[512]
Definition: dcadata.c:8074
DCAExssAsset::extension_mask
int extension_mask
Coding components used in asset.
Definition: dca_exss.h:45
get_array
static void get_array(GetBitContext *s, int32_t *array, int size, int n)
Definition: dca_core.c:73
DCAExssAsset::xxch_size
int xxch_size
Size of XXCH extension in extension substream.
Definition: dca_exss.h:54
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
ff_dca_joint_scale_factors
const uint32_t ff_dca_joint_scale_factors[129]
Definition: dcadata.c:4191
ff_dca_fir_32bands_perfect
const float ff_dca_fir_32bands_perfect[512]
Definition: dcadata.c:6293
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
ff_dca_scale_factor_adj
const uint32_t ff_dca_scale_factor_adj[4]
Definition: dcadata.c:4211
erase_x96_adpcm_history
static void erase_x96_adpcm_history(DCACoreDecoder *s)
Definition: dca_core.c:1267
DCA_SPEAKER_COUNT
@ DCA_SPEAKER_COUNT
Definition: dca.h:88
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
DCA_SPEAKER_L
@ DCA_SPEAKER_L
Definition: dca.h:79
DCA_CSS_XXCH
@ DCA_CSS_XXCH
Definition: dca.h:171
h
h
Definition: vp9dsp_template.c:2038
DCAExssAsset::xxch_offset
int xxch_offset
Offset to XXCH extension from start of substream.
Definition: dca_exss.h:53
avpriv_dca_sample_rates
const uint32_t avpriv_dca_sample_rates[16]
Definition: dca.c:36
decode_blockcodes
static int decode_blockcodes(int code1, int code2, int levels, int32_t *audio)
Definition: dca_core.c:526
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
DCA_SYNCWORD_REV1AUX
#define DCA_SYNCWORD_REV1AUX
Definition: dca_syncwords.h:34
DCA_PARSE_ERROR_AMODE
@ DCA_PARSE_ERROR_AMODE
Definition: dca.h:44
ff_dca_core_flush
av_cold void ff_dca_core_flush(DCACoreDecoder *s)
Definition: dca_core.c:2399
Generated on Wed Aug 24 2022 21:33:51 for FFmpeg by   doxygen 1.8.17