dca.c
Go to the documentation of this file.
1 /*
2  * DCA compatible decoder
3  * Copyright (C) 2004 Gildas Bazin
4  * Copyright (C) 2004 Benjamin Zores
5  * Copyright (C) 2006 Benjamin Larsson
6  * Copyright (C) 2007 Konstantin Shishkov
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include <math.h>
26 #include <stddef.h>
27 #include <stdio.h>
28 
29 #include "libavutil/common.h"
30 #include "libavutil/intmath.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/audioconvert.h"
34 #include "avcodec.h"
35 #include "internal.h"
36 #include "dsputil.h"
37 #include "fft.h"
38 #include "get_bits.h"
39 #include "put_bits.h"
40 #include "dcadata.h"
41 #include "dcahuff.h"
42 #include "dca.h"
43 #include "synth_filter.h"
44 #include "dcadsp.h"
45 #include "fmtconvert.h"
46 
47 #if ARCH_ARM
48 # include "arm/dca.h"
49 #endif
50 
51 //#define TRACE
52 
53 #define DCA_PRIM_CHANNELS_MAX (7)
54 #define DCA_SUBBANDS (32)
55 #define DCA_ABITS_MAX (32) /* Should be 28 */
56 #define DCA_SUBSUBFRAMES_MAX (4)
57 #define DCA_SUBFRAMES_MAX (16)
58 #define DCA_BLOCKS_MAX (16)
59 #define DCA_LFE_MAX (3)
60 
61 enum DCAMode {
62  DCA_MONO = 0,
73 };
74 
75 /* these are unconfirmed but should be mostly correct */
80  DCA_EXSS_LFE = 0x0008,
89  DCA_EXSS_LFE2 = 0x1000,
93 };
94 
96  DCA_EXT_CORE = 0x001,
97  DCA_EXT_XXCH = 0x002,
98  DCA_EXT_X96 = 0x004,
99  DCA_EXT_XCH = 0x008,
106 };
107 
108 /* -1 are reserved or unknown */
109 static const int dca_ext_audio_descr_mask[] = {
110  DCA_EXT_XCH,
111  -1,
112  DCA_EXT_X96,
114  -1,
115  -1,
116  DCA_EXT_XXCH,
117  -1,
118 };
119 
120 /* extensions that reside in core substream */
121 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
122 
123 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
124  * Some compromises have been made for special configurations. Most configurations
125  * are never used so complete accuracy is not needed.
126  *
127  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
128  * S -> side, when both rear and back are configured move one of them to the side channel
129  * OV -> center back
130  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
131  */
132 static const uint64_t dca_core_channel_layout[] = {
138  AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,
139  AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,
140  AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,
141  AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
142 
143  AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
145 
146  AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
148 
149  AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
151 
155 
157  AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
159 
161  AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
163 
165  AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
167 };
168 
169 static const int8_t dca_lfe_index[] = {
170  1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
171 };
172 
173 static const int8_t dca_channel_reorder_lfe[][9] = {
174  { 0, -1, -1, -1, -1, -1, -1, -1, -1},
175  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
176  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
177  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
178  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
179  { 2, 0, 1, -1, -1, -1, -1, -1, -1},
180  { 0, 1, 3, -1, -1, -1, -1, -1, -1},
181  { 2, 0, 1, 4, -1, -1, -1, -1, -1},
182  { 0, 1, 3, 4, -1, -1, -1, -1, -1},
183  { 2, 0, 1, 4, 5, -1, -1, -1, -1},
184  { 3, 4, 0, 1, 5, 6, -1, -1, -1},
185  { 2, 0, 1, 4, 5, 6, -1, -1, -1},
186  { 0, 6, 4, 5, 2, 3, -1, -1, -1},
187  { 4, 2, 5, 0, 1, 6, 7, -1, -1},
188  { 5, 6, 0, 1, 7, 3, 8, 4, -1},
189  { 4, 2, 5, 0, 1, 6, 8, 7, -1},
190 };
191 
192 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
193  { 0, 2, -1, -1, -1, -1, -1, -1, -1},
194  { 0, 1, 3, -1, -1, -1, -1, -1, -1},
195  { 0, 1, 3, -1, -1, -1, -1, -1, -1},
196  { 0, 1, 3, -1, -1, -1, -1, -1, -1},
197  { 0, 1, 3, -1, -1, -1, -1, -1, -1},
198  { 2, 0, 1, 4, -1, -1, -1, -1, -1},
199  { 0, 1, 3, 4, -1, -1, -1, -1, -1},
200  { 2, 0, 1, 4, 5, -1, -1, -1, -1},
201  { 0, 1, 4, 5, 3, -1, -1, -1, -1},
202  { 2, 0, 1, 5, 6, 4, -1, -1, -1},
203  { 3, 4, 0, 1, 6, 7, 5, -1, -1},
204  { 2, 0, 1, 4, 5, 6, 7, -1, -1},
205  { 0, 6, 4, 5, 2, 3, 7, -1, -1},
206  { 4, 2, 5, 0, 1, 7, 8, 6, -1},
207  { 5, 6, 0, 1, 8, 3, 9, 4, 7},
208  { 4, 2, 5, 0, 1, 6, 9, 8, 7},
209 };
210 
211 static const int8_t dca_channel_reorder_nolfe[][9] = {
212  { 0, -1, -1, -1, -1, -1, -1, -1, -1},
213  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
214  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
215  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
216  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
217  { 2, 0, 1, -1, -1, -1, -1, -1, -1},
218  { 0, 1, 2, -1, -1, -1, -1, -1, -1},
219  { 2, 0, 1, 3, -1, -1, -1, -1, -1},
220  { 0, 1, 2, 3, -1, -1, -1, -1, -1},
221  { 2, 0, 1, 3, 4, -1, -1, -1, -1},
222  { 2, 3, 0, 1, 4, 5, -1, -1, -1},
223  { 2, 0, 1, 3, 4, 5, -1, -1, -1},
224  { 0, 5, 3, 4, 1, 2, -1, -1, -1},
225  { 3, 2, 4, 0, 1, 5, 6, -1, -1},
226  { 4, 5, 0, 1, 6, 2, 7, 3, -1},
227  { 3, 2, 4, 0, 1, 5, 7, 6, -1},
228 };
229 
230 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
231  { 0, 1, -1, -1, -1, -1, -1, -1, -1},
232  { 0, 1, 2, -1, -1, -1, -1, -1, -1},
233  { 0, 1, 2, -1, -1, -1, -1, -1, -1},
234  { 0, 1, 2, -1, -1, -1, -1, -1, -1},
235  { 0, 1, 2, -1, -1, -1, -1, -1, -1},
236  { 2, 0, 1, 3, -1, -1, -1, -1, -1},
237  { 0, 1, 2, 3, -1, -1, -1, -1, -1},
238  { 2, 0, 1, 3, 4, -1, -1, -1, -1},
239  { 0, 1, 3, 4, 2, -1, -1, -1, -1},
240  { 2, 0, 1, 4, 5, 3, -1, -1, -1},
241  { 2, 3, 0, 1, 5, 6, 4, -1, -1},
242  { 2, 0, 1, 3, 4, 5, 6, -1, -1},
243  { 0, 5, 3, 4, 1, 2, 6, -1, -1},
244  { 3, 2, 4, 0, 1, 6, 7, 5, -1},
245  { 4, 5, 0, 1, 7, 2, 8, 3, 6},
246  { 3, 2, 4, 0, 1, 5, 8, 7, 6},
247 };
248 
249 #define DCA_DOLBY 101 /* FIXME */
250 
251 #define DCA_CHANNEL_BITS 6
252 #define DCA_CHANNEL_MASK 0x3F
253 
254 #define DCA_LFE 0x80
255 
256 #define HEADER_SIZE 14
257 
258 #define DCA_MAX_FRAME_SIZE 16384
259 #define DCA_MAX_EXSS_HEADER_SIZE 4096
260 
261 #define DCA_BUFFER_PADDING_SIZE 1024
262 
264 typedef struct {
265  int offset;
266  int maxbits[8];
267  int wrap;
268  VLC vlc[8];
269 } BitAlloc;
270 
275 
277  int idx)
278 {
279  return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
280  ba->offset;
281 }
282 
283 typedef struct {
286  /* Frame header */
292  int amode;
294  int bit_rate;
296 
297  int downmix;
298  int dynrange;
299  int timestamp;
300  int aux_data;
301  int hdcd;
302  int ext_descr;
304  int aspf;
305  int lfe;
309  int version;
312  int front_sum;
315 
316  /* Primary audio coding header */
317  int subframes;
321  int subband_activity[DCA_PRIM_CHANNELS_MAX];
322  int vq_start_subband[DCA_PRIM_CHANNELS_MAX];
323  int joint_intensity[DCA_PRIM_CHANNELS_MAX];
324  int transient_huffman[DCA_PRIM_CHANNELS_MAX];
325  int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX];
326  int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];
327  int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];
328  float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];
329 
330  /* Primary audio coding side information */
331  int subsubframes[DCA_SUBFRAMES_MAX];
332  int partial_samples[DCA_SUBFRAMES_MAX];
333  int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
334  int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
336  int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
337  int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];
338  int joint_huff[DCA_PRIM_CHANNELS_MAX];
339  int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
340  int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];
342 
344 
345  float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];
347 
348  /* Subband samples history (for ADPCM) */
349  DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
350  DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
351  DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
352  int hist_index[DCA_PRIM_CHANNELS_MAX];
353  DECLARE_ALIGNED(32, float, raXin)[32];
354 
355  int output;
356  float scale_bias;
357 
360  const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
361 
364 
365  const int8_t *channel_order_tab;
367  /* Current position in DCA frame */
370 
372 
373  /* XCh extension information */
376 
377  /* ExSS header parser */
381  int mix_config_num_ch[4];
382 
383  int profile;
384 
391 } DCAContext;
392 
393 static const uint16_t dca_vlc_offs[] = {
394  0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
395  5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
396  5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
397  7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
398  12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
399  18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
400 };
401 
402 static av_cold void dca_init_vlcs(void)
403 {
404  static int vlcs_initialized = 0;
405  int i, j, c = 14;
406  static VLC_TYPE dca_table[23622][2];
407 
408  if (vlcs_initialized)
409  return;
410 
411  dca_bitalloc_index.offset = 1;
412  dca_bitalloc_index.wrap = 2;
413  for (i = 0; i < 5; i++) {
414  dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
415  dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
416  init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
417  bitalloc_12_bits[i], 1, 1,
419  }
420  dca_scalefactor.offset = -64;
421  dca_scalefactor.wrap = 2;
422  for (i = 0; i < 5; i++) {
423  dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
424  dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
425  init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
426  scales_bits[i], 1, 1,
428  }
429  dca_tmode.offset = 0;
430  dca_tmode.wrap = 1;
431  for (i = 0; i < 4; i++) {
432  dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
433  dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
434  init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
435  tmode_bits[i], 1, 1,
437  }
438 
439  for (i = 0; i < 10; i++)
440  for (j = 0; j < 7; j++) {
441  if (!bitalloc_codes[i][j])
442  break;
443  dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
444  dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
445  dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
446  dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
447 
448  init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
449  bitalloc_sizes[i],
450  bitalloc_bits[i][j], 1, 1,
452  c++;
453  }
454  vlcs_initialized = 1;
455 }
456 
457 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
458 {
459  while (len--)
460  *dst++ = get_bits(gb, bits);
461 }
462 
463 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
464 {
465  int i, j;
466  static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
467  static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
468  static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
469 
470  s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
472 
475 
476 
477  for (i = base_channel; i < s->prim_channels; i++) {
478  s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
479  if (s->subband_activity[i] > DCA_SUBBANDS)
481  }
482  for (i = base_channel; i < s->prim_channels; i++) {
483  s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
484  if (s->vq_start_subband[i] > DCA_SUBBANDS)
486  }
487  get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
488  get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
489  get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
490  get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
491 
492  /* Get codebooks quantization indexes */
493  if (!base_channel)
494  memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
495  for (j = 1; j < 11; j++)
496  for (i = base_channel; i < s->prim_channels; i++)
497  s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
498 
499  /* Get scale factor adjustment */
500  for (j = 0; j < 11; j++)
501  for (i = base_channel; i < s->prim_channels; i++)
502  s->scalefactor_adj[i][j] = 1;
503 
504  for (j = 1; j < 11; j++)
505  for (i = base_channel; i < s->prim_channels; i++)
506  if (s->quant_index_huffman[i][j] < thr[j])
507  s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
508 
509  if (s->crc_present) {
510  /* Audio header CRC check */
511  get_bits(&s->gb, 16);
512  }
513 
514  s->current_subframe = 0;
515  s->current_subsubframe = 0;
516 
517 #ifdef TRACE
518  av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
519  av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
520  for (i = base_channel; i < s->prim_channels; i++) {
521  av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
522  s->subband_activity[i]);
523  av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
524  s->vq_start_subband[i]);
525  av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
526  s->joint_intensity[i]);
527  av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
528  s->transient_huffman[i]);
529  av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
530  s->scalefactor_huffman[i]);
531  av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
532  s->bitalloc_huffman[i]);
533  av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
534  for (j = 0; j < 11; j++)
535  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
536  av_log(s->avctx, AV_LOG_DEBUG, "\n");
537  av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
538  for (j = 0; j < 11; j++)
539  av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
540  av_log(s->avctx, AV_LOG_DEBUG, "\n");
541  }
542 #endif
543 
544  return 0;
545 }
546 
548 {
549  init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
550 
551  /* Sync code */
552  skip_bits_long(&s->gb, 32);
553 
554  /* Frame header */
555  s->frame_type = get_bits(&s->gb, 1);
556  s->samples_deficit = get_bits(&s->gb, 5) + 1;
557  s->crc_present = get_bits(&s->gb, 1);
558  s->sample_blocks = get_bits(&s->gb, 7) + 1;
559  s->frame_size = get_bits(&s->gb, 14) + 1;
560  if (s->frame_size < 95)
561  return AVERROR_INVALIDDATA;
562  s->amode = get_bits(&s->gb, 6);
563  s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
564  if (!s->sample_rate)
565  return AVERROR_INVALIDDATA;
566  s->bit_rate_index = get_bits(&s->gb, 5);
568  if (!s->bit_rate)
569  return AVERROR_INVALIDDATA;
570 
571  s->downmix = get_bits(&s->gb, 1);
572  s->dynrange = get_bits(&s->gb, 1);
573  s->timestamp = get_bits(&s->gb, 1);
574  s->aux_data = get_bits(&s->gb, 1);
575  s->hdcd = get_bits(&s->gb, 1);
576  s->ext_descr = get_bits(&s->gb, 3);
577  s->ext_coding = get_bits(&s->gb, 1);
578  s->aspf = get_bits(&s->gb, 1);
579  s->lfe = get_bits(&s->gb, 2);
580  s->predictor_history = get_bits(&s->gb, 1);
581 
582  if (s->lfe > 2) {
583  av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
584  return AVERROR_INVALIDDATA;
585  }
586 
587  /* TODO: check CRC */
588  if (s->crc_present)
589  s->header_crc = get_bits(&s->gb, 16);
590 
591  s->multirate_inter = get_bits(&s->gb, 1);
592  s->version = get_bits(&s->gb, 4);
593  s->copy_history = get_bits(&s->gb, 2);
594  s->source_pcm_res = get_bits(&s->gb, 3);
595  s->front_sum = get_bits(&s->gb, 1);
596  s->surround_sum = get_bits(&s->gb, 1);
597  s->dialog_norm = get_bits(&s->gb, 4);
598 
599  /* FIXME: channels mixing levels */
600  s->output = s->amode;
601  if (s->lfe)
602  s->output |= DCA_LFE;
603 
604 #ifdef TRACE
605  av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
606  av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
607  av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
608  av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
609  s->sample_blocks, s->sample_blocks * 32);
610  av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
611  av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
612  s->amode, dca_channels[s->amode]);
613  av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
614  s->sample_rate);
615  av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
616  s->bit_rate);
617  av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
618  av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
619  av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
620  av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
621  av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
622  av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
623  av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
624  av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
625  av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
626  av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
627  s->predictor_history);
628  av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
629  av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
630  s->multirate_inter);
631  av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
632  av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
634  "source pcm resolution: %i (%i bits/sample)\n",
636  av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
637  av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
638  av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
639  av_log(s->avctx, AV_LOG_DEBUG, "\n");
640 #endif
641 
642  /* Primary audio coding header */
643  s->subframes = get_bits(&s->gb, 4) + 1;
644 
645  return dca_parse_audio_coding_header(s, 0);
646 }
647 
648 
649 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
650 {
651  if (level < 5) {
652  /* huffman encoded */
653  value += get_bitalloc(gb, &dca_scalefactor, level);
654  value = av_clip(value, 0, (1 << log2range) - 1);
655  } else if (level < 8) {
656  if (level + 1 > log2range) {
657  skip_bits(gb, level + 1 - log2range);
658  value = get_bits(gb, log2range);
659  } else {
660  value = get_bits(gb, level + 1);
661  }
662  }
663  return value;
664 }
665 
666 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
667 {
668  /* Primary audio coding side information */
669  int j, k;
670 
671  if (get_bits_left(&s->gb) < 0)
672  return AVERROR_INVALIDDATA;
673 
674  if (!base_channel) {
675  s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
676  s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
677  }
678 
679  for (j = base_channel; j < s->prim_channels; j++) {
680  for (k = 0; k < s->subband_activity[j]; k++)
681  s->prediction_mode[j][k] = get_bits(&s->gb, 1);
682  }
683 
684  /* Get prediction codebook */
685  for (j = base_channel; j < s->prim_channels; j++) {
686  for (k = 0; k < s->subband_activity[j]; k++) {
687  if (s->prediction_mode[j][k] > 0) {
688  /* (Prediction coefficient VQ address) */
689  s->prediction_vq[j][k] = get_bits(&s->gb, 12);
690  }
691  }
692  }
693 
694  /* Bit allocation index */
695  for (j = base_channel; j < s->prim_channels; j++) {
696  for (k = 0; k < s->vq_start_subband[j]; k++) {
697  if (s->bitalloc_huffman[j] == 6)
698  s->bitalloc[j][k] = get_bits(&s->gb, 5);
699  else if (s->bitalloc_huffman[j] == 5)
700  s->bitalloc[j][k] = get_bits(&s->gb, 4);
701  else if (s->bitalloc_huffman[j] == 7) {
703  "Invalid bit allocation index\n");
704  return AVERROR_INVALIDDATA;
705  } else {
706  s->bitalloc[j][k] =
707  get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
708  }
709 
710  if (s->bitalloc[j][k] > 26) {
711  // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
712  // j, k, s->bitalloc[j][k]);
713  return AVERROR_INVALIDDATA;
714  }
715  }
716  }
717 
718  /* Transition mode */
719  for (j = base_channel; j < s->prim_channels; j++) {
720  for (k = 0; k < s->subband_activity[j]; k++) {
721  s->transition_mode[j][k] = 0;
722  if (s->subsubframes[s->current_subframe] > 1 &&
723  k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
724  s->transition_mode[j][k] =
725  get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
726  }
727  }
728  }
729 
730  if (get_bits_left(&s->gb) < 0)
731  return AVERROR_INVALIDDATA;
732 
733  for (j = base_channel; j < s->prim_channels; j++) {
734  const uint32_t *scale_table;
735  int scale_sum, log_size;
736 
737  memset(s->scale_factor[j], 0,
738  s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
739 
740  if (s->scalefactor_huffman[j] == 6) {
741  scale_table = scale_factor_quant7;
742  log_size = 7;
743  } else {
744  scale_table = scale_factor_quant6;
745  log_size = 6;
746  }
747 
748  /* When huffman coded, only the difference is encoded */
749  scale_sum = 0;
750 
751  for (k = 0; k < s->subband_activity[j]; k++) {
752  if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
753  scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
754  s->scale_factor[j][k][0] = scale_table[scale_sum];
755  }
756 
757  if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
758  /* Get second scale factor */
759  scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
760  s->scale_factor[j][k][1] = scale_table[scale_sum];
761  }
762  }
763  }
764 
765  /* Joint subband scale factor codebook select */
766  for (j = base_channel; j < s->prim_channels; j++) {
767  /* Transmitted only if joint subband coding enabled */
768  if (s->joint_intensity[j] > 0)
769  s->joint_huff[j] = get_bits(&s->gb, 3);
770  }
771 
772  if (get_bits_left(&s->gb) < 0)
773  return AVERROR_INVALIDDATA;
774 
775  /* Scale factors for joint subband coding */
776  for (j = base_channel; j < s->prim_channels; j++) {
777  int source_channel;
778 
779  /* Transmitted only if joint subband coding enabled */
780  if (s->joint_intensity[j] > 0) {
781  int scale = 0;
782  source_channel = s->joint_intensity[j] - 1;
783 
784  /* When huffman coded, only the difference is encoded
785  * (is this valid as well for joint scales ???) */
786 
787  for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
788  scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
789  s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
790  }
791 
792  if (!(s->debug_flag & 0x02)) {
794  "Joint stereo coding not supported\n");
795  s->debug_flag |= 0x02;
796  }
797  }
798  }
799 
800  /* Stereo downmix coefficients */
801  if (!base_channel && s->prim_channels > 2) {
802  if (s->downmix) {
803  for (j = base_channel; j < s->prim_channels; j++) {
804  s->downmix_coef[j][0] = get_bits(&s->gb, 7);
805  s->downmix_coef[j][1] = get_bits(&s->gb, 7);
806  }
807  } else {
808  int am = s->amode & DCA_CHANNEL_MASK;
809  if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
811  "Invalid channel mode %d\n", am);
812  return AVERROR_INVALIDDATA;
813  }
814 
816  av_log_ask_for_sample(s->avctx, "Downmixing %d channels",
817  s->prim_channels);
818  return AVERROR_PATCHWELCOME;
819  }
820 
821  for (j = base_channel; j < s->prim_channels; j++) {
822  s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
823  s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
824  }
825  }
826  }
827 
828  /* Dynamic range coefficient */
829  if (!base_channel && s->dynrange)
830  s->dynrange_coef = get_bits(&s->gb, 8);
831 
832  /* Side information CRC check word */
833  if (s->crc_present) {
834  get_bits(&s->gb, 16);
835  }
836 
837  /*
838  * Primary audio data arrays
839  */
840 
841  /* VQ encoded high frequency subbands */
842  for (j = base_channel; j < s->prim_channels; j++)
843  for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
844  /* 1 vector -> 32 samples */
845  s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
846 
847  /* Low frequency effect data */
848  if (!base_channel && s->lfe) {
849  /* LFE samples */
850  int lfe_samples = 2 * s->lfe * (4 + block_index);
851  int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
852  float lfe_scale;
853 
854  for (j = lfe_samples; j < lfe_end_sample; j++) {
855  /* Signed 8 bits int */
856  s->lfe_data[j] = get_sbits(&s->gb, 8);
857  }
858 
859  /* Scale factor index */
860  skip_bits(&s->gb, 1);
862 
863  /* Quantization step size * scale factor */
864  lfe_scale = 0.035 * s->lfe_scale_factor;
865 
866  for (j = lfe_samples; j < lfe_end_sample; j++)
867  s->lfe_data[j] *= lfe_scale;
868  }
869 
870 #ifdef TRACE
871  av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
873  av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
875 
876  for (j = base_channel; j < s->prim_channels; j++) {
877  av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
878  for (k = 0; k < s->subband_activity[j]; k++)
879  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
880  av_log(s->avctx, AV_LOG_DEBUG, "\n");
881  }
882  for (j = base_channel; j < s->prim_channels; j++) {
883  for (k = 0; k < s->subband_activity[j]; k++)
885  "prediction coefs: %f, %f, %f, %f\n",
886  (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
887  (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
888  (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
889  (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
890  }
891  for (j = base_channel; j < s->prim_channels; j++) {
892  av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
893  for (k = 0; k < s->vq_start_subband[j]; k++)
894  av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
895  av_log(s->avctx, AV_LOG_DEBUG, "\n");
896  }
897  for (j = base_channel; j < s->prim_channels; j++) {
898  av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
899  for (k = 0; k < s->subband_activity[j]; k++)
900  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
901  av_log(s->avctx, AV_LOG_DEBUG, "\n");
902  }
903  for (j = base_channel; j < s->prim_channels; j++) {
904  av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
905  for (k = 0; k < s->subband_activity[j]; k++) {
906  if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
907  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
908  if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
909  av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
910  }
911  av_log(s->avctx, AV_LOG_DEBUG, "\n");
912  }
913  for (j = base_channel; j < s->prim_channels; j++) {
914  if (s->joint_intensity[j] > 0) {
915  int source_channel = s->joint_intensity[j] - 1;
916  av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
917  for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
918  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
919  av_log(s->avctx, AV_LOG_DEBUG, "\n");
920  }
921  }
922  if (!base_channel && s->prim_channels > 2 && s->downmix) {
923  av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
924  for (j = 0; j < s->prim_channels; j++) {
925  av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
926  dca_downmix_coeffs[s->downmix_coef[j][0]]);
927  av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
928  dca_downmix_coeffs[s->downmix_coef[j][1]]);
929  }
930  av_log(s->avctx, AV_LOG_DEBUG, "\n");
931  }
932  for (j = base_channel; j < s->prim_channels; j++)
933  for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
934  av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
935  if (!base_channel && s->lfe) {
936  int lfe_samples = 2 * s->lfe * (4 + block_index);
937  int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
938 
939  av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
940  for (j = lfe_samples; j < lfe_end_sample; j++)
941  av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
942  av_log(s->avctx, AV_LOG_DEBUG, "\n");
943  }
944 #endif
945 
946  return 0;
947 }
948 
949 static void qmf_32_subbands(DCAContext *s, int chans,
950  float samples_in[32][8], float *samples_out,
951  float scale)
952 {
953  const float *prCoeff;
954  int i;
955 
956  int sb_act = s->subband_activity[chans];
957  int subindex;
958 
959  scale *= sqrt(1 / 8.0);
960 
961  /* Select filter */
962  if (!s->multirate_inter) /* Non-perfect reconstruction */
963  prCoeff = fir_32bands_nonperfect;
964  else /* Perfect reconstruction */
965  prCoeff = fir_32bands_perfect;
966 
967  for (i = sb_act; i < 32; i++)
968  s->raXin[i] = 0.0;
969 
970  /* Reconstructed channel sample index */
971  for (subindex = 0; subindex < 8; subindex++) {
972  /* Load in one sample from each subband and clear inactive subbands */
973  for (i = 0; i < sb_act; i++) {
974  unsigned sign = (i - 1) & 2;
975  uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
976  AV_WN32A(&s->raXin[i], v);
977  }
978 
980  s->subband_fir_hist[chans],
981  &s->hist_index[chans],
982  s->subband_fir_noidea[chans], prCoeff,
983  samples_out, s->raXin, scale);
984  samples_out += 32;
985  }
986 }
987 
988 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
989  int num_deci_sample, float *samples_in,
990  float *samples_out, float scale)
991 {
992  /* samples_in: An array holding decimated samples.
993  * Samples in current subframe starts from samples_in[0],
994  * while samples_in[-1], samples_in[-2], ..., stores samples
995  * from last subframe as history.
996  *
997  * samples_out: An array holding interpolated samples
998  */
999 
1000  int decifactor;
1001  const float *prCoeff;
1002  int deciindex;
1003 
1004  /* Select decimation filter */
1005  if (decimation_select == 1) {
1006  decifactor = 64;
1007  prCoeff = lfe_fir_128;
1008  } else {
1009  decifactor = 32;
1010  prCoeff = lfe_fir_64;
1011  }
1012  /* Interpolation */
1013  for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1014  s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1015  samples_in++;
1016  samples_out += 2 * decifactor;
1017  }
1018 }
1019 
1020 /* downmixing routines */
1021 #define MIX_REAR1(samples, si1, rs, coef) \
1022  samples[i] += samples[si1] * coef[rs][0]; \
1023  samples[i+256] += samples[si1] * coef[rs][1];
1024 
1025 #define MIX_REAR2(samples, si1, si2, rs, coef) \
1026  samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
1027  samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1028 
1029 #define MIX_FRONT3(samples, coef) \
1030  t = samples[i + c]; \
1031  u = samples[i + l]; \
1032  v = samples[i + r]; \
1033  samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1034  samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1035 
1036 #define DOWNMIX_TO_STEREO(op1, op2) \
1037  for (i = 0; i < 256; i++) { \
1038  op1 \
1039  op2 \
1040  }
1041 
1042 static void dca_downmix(float *samples, int srcfmt,
1043  int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1044  const int8_t *channel_mapping)
1045 {
1046  int c, l, r, sl, sr, s;
1047  int i;
1048  float t, u, v;
1049  float coef[DCA_PRIM_CHANNELS_MAX][2];
1050 
1051  for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1052  coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1053  coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1054  }
1055 
1056  switch (srcfmt) {
1057  case DCA_MONO:
1058  case DCA_CHANNEL:
1059  case DCA_STEREO_TOTAL:
1060  case DCA_STEREO_SUMDIFF:
1061  case DCA_4F2R:
1062  av_log(NULL, 0, "Not implemented!\n");
1063  break;
1064  case DCA_STEREO:
1065  break;
1066  case DCA_3F:
1067  c = channel_mapping[0] * 256;
1068  l = channel_mapping[1] * 256;
1069  r = channel_mapping[2] * 256;
1070  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1071  break;
1072  case DCA_2F1R:
1073  s = channel_mapping[2] * 256;
1074  DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1075  break;
1076  case DCA_3F1R:
1077  c = channel_mapping[0] * 256;
1078  l = channel_mapping[1] * 256;
1079  r = channel_mapping[2] * 256;
1080  s = channel_mapping[3] * 256;
1081  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1082  MIX_REAR1(samples, i + s, 3, coef));
1083  break;
1084  case DCA_2F2R:
1085  sl = channel_mapping[2] * 256;
1086  sr = channel_mapping[3] * 256;
1087  DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1088  break;
1089  case DCA_3F2R:
1090  c = channel_mapping[0] * 256;
1091  l = channel_mapping[1] * 256;
1092  r = channel_mapping[2] * 256;
1093  sl = channel_mapping[3] * 256;
1094  sr = channel_mapping[4] * 256;
1095  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1096  MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1097  break;
1098  }
1099 }
1100 
1101 
1102 #ifndef decode_blockcodes
1103 /* Very compact version of the block code decoder that does not use table
1104  * look-up but is slightly slower */
1105 static int decode_blockcode(int code, int levels, int *values)
1106 {
1107  int i;
1108  int offset = (levels - 1) >> 1;
1109 
1110  for (i = 0; i < 4; i++) {
1111  int div = FASTDIV(code, levels);
1112  values[i] = code - offset - div * levels;
1113  code = div;
1114  }
1115 
1116  return code;
1117 }
1118 
1119 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1120 {
1121  return decode_blockcode(code1, levels, values) |
1122  decode_blockcode(code2, levels, values + 4);
1123 }
1124 #endif
1125 
1126 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1127 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1128 
1129 #ifndef int8x8_fmul_int32
1130 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1131 {
1132  float fscale = scale / 16.0;
1133  int i;
1134  for (i = 0; i < 8; i++)
1135  dst[i] = src[i] * fscale;
1136 }
1137 #endif
1138 
1139 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1140 {
1141  int k, l;
1142  int subsubframe = s->current_subsubframe;
1143 
1144  const float *quant_step_table;
1145 
1146  /* FIXME */
1147  float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1148  LOCAL_ALIGNED_16(int, block, [8]);
1149 
1150  /*
1151  * Audio data
1152  */
1153 
1154  /* Select quantization step size table */
1155  if (s->bit_rate_index == 0x1f)
1156  quant_step_table = lossless_quant_d;
1157  else
1158  quant_step_table = lossy_quant_d;
1159 
1160  for (k = base_channel; k < s->prim_channels; k++) {
1161  if (get_bits_left(&s->gb) < 0)
1162  return AVERROR_INVALIDDATA;
1163 
1164  for (l = 0; l < s->vq_start_subband[k]; l++) {
1165  int m;
1166 
1167  /* Select the mid-tread linear quantizer */
1168  int abits = s->bitalloc[k][l];
1169 
1170  float quant_step_size = quant_step_table[abits];
1171 
1172  /*
1173  * Determine quantization index code book and its type
1174  */
1175 
1176  /* Select quantization index code book */
1177  int sel = s->quant_index_huffman[k][abits];
1178 
1179  /*
1180  * Extract bits from the bit stream
1181  */
1182  if (!abits) {
1183  memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1184  } else {
1185  /* Deal with transients */
1186  int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1187  float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1188  s->scalefactor_adj[k][sel];
1189 
1190  if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1191  if (abits <= 7) {
1192  /* Block code */
1193  int block_code1, block_code2, size, levels, err;
1194 
1195  size = abits_sizes[abits - 1];
1196  levels = abits_levels[abits - 1];
1197 
1198  block_code1 = get_bits(&s->gb, size);
1199  block_code2 = get_bits(&s->gb, size);
1200  err = decode_blockcodes(block_code1, block_code2,
1201  levels, block);
1202  if (err) {
1204  "ERROR: block code look-up failed\n");
1205  return AVERROR_INVALIDDATA;
1206  }
1207  } else {
1208  /* no coding */
1209  for (m = 0; m < 8; m++)
1210  block[m] = get_sbits(&s->gb, abits - 3);
1211  }
1212  } else {
1213  /* Huffman coded */
1214  for (m = 0; m < 8; m++)
1215  block[m] = get_bitalloc(&s->gb,
1216  &dca_smpl_bitalloc[abits], sel);
1217  }
1218 
1219  s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1220  block, rscale, 8);
1221  }
1222 
1223  /*
1224  * Inverse ADPCM if in prediction mode
1225  */
1226  if (s->prediction_mode[k][l]) {
1227  int n;
1228  for (m = 0; m < 8; m++) {
1229  for (n = 1; n <= 4; n++)
1230  if (m >= n)
1231  subband_samples[k][l][m] +=
1232  (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1233  subband_samples[k][l][m - n] / 8192);
1234  else if (s->predictor_history)
1235  subband_samples[k][l][m] +=
1236  (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1237  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1238  }
1239  }
1240  }
1241 
1242  /*
1243  * Decode VQ encoded high frequencies
1244  */
1245  for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1246  /* 1 vector -> 32 samples but we only need the 8 samples
1247  * for this subsubframe. */
1248  int hfvq = s->high_freq_vq[k][l];
1249 
1250  if (!s->debug_flag & 0x01) {
1252  "Stream with high frequencies VQ coding\n");
1253  s->debug_flag |= 0x01;
1254  }
1255 
1256  int8x8_fmul_int32(subband_samples[k][l],
1257  &high_freq_vq[hfvq][subsubframe * 8],
1258  s->scale_factor[k][l][0]);
1259  }
1260  }
1261 
1262  /* Check for DSYNC after subsubframe */
1263  if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1264  if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1265 #ifdef TRACE
1266  av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1267 #endif
1268  } else {
1269  av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1270  return AVERROR_INVALIDDATA;
1271  }
1272  }
1273 
1274  /* Backup predictor history for adpcm */
1275  for (k = base_channel; k < s->prim_channels; k++)
1276  for (l = 0; l < s->vq_start_subband[k]; l++)
1277  memcpy(s->subband_samples_hist[k][l],
1278  &subband_samples[k][l][4],
1279  4 * sizeof(subband_samples[0][0][0]));
1280 
1281  return 0;
1282 }
1283 
1284 static int dca_filter_channels(DCAContext *s, int block_index)
1285 {
1286  float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1287  int k;
1288 
1289  /* 32 subbands QMF */
1290  for (k = 0; k < s->prim_channels; k++) {
1291 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1292  0, 8388608.0, 8388608.0 };*/
1293  qmf_32_subbands(s, k, subband_samples[k],
1294  &s->samples[256 * s->channel_order_tab[k]],
1295  M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1296  }
1297 
1298  /* Down mixing */
1299  if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1301  }
1302 
1303  /* Generate LFE samples for this subsubframe FIXME!!! */
1304  if (s->output & DCA_LFE) {
1305  lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1306  s->lfe_data + 2 * s->lfe * (block_index + 4),
1307  &s->samples[256 * dca_lfe_index[s->amode]],
1308  (1.0 / 256.0) * s->scale_bias);
1309  /* Outputs 20bits pcm samples */
1310  }
1311 
1312  return 0;
1313 }
1314 
1315 
1316 static int dca_subframe_footer(DCAContext *s, int base_channel)
1317 {
1318  int aux_data_count = 0, i;
1319 
1320  /*
1321  * Unpack optional information
1322  */
1323 
1324  /* presumably optional information only appears in the core? */
1325  if (!base_channel) {
1326  if (s->timestamp)
1327  skip_bits_long(&s->gb, 32);
1328 
1329  if (s->aux_data)
1330  aux_data_count = get_bits(&s->gb, 6);
1331 
1332  for (i = 0; i < aux_data_count; i++)
1333  get_bits(&s->gb, 8);
1334 
1335  if (s->crc_present && (s->downmix || s->dynrange))
1336  get_bits(&s->gb, 16);
1337  }
1338 
1339  return 0;
1340 }
1341 
1348 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1349 {
1350  int ret;
1351 
1352  /* Sanity check */
1353  if (s->current_subframe >= s->subframes) {
1354  av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1355  s->current_subframe, s->subframes);
1356  return AVERROR_INVALIDDATA;
1357  }
1358 
1359  if (!s->current_subsubframe) {
1360 #ifdef TRACE
1361  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1362 #endif
1363  /* Read subframe header */
1364  if ((ret = dca_subframe_header(s, base_channel, block_index)))
1365  return ret;
1366  }
1367 
1368  /* Read subsubframe */
1369 #ifdef TRACE
1370  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1371 #endif
1372  if ((ret = dca_subsubframe(s, base_channel, block_index)))
1373  return ret;
1374 
1375  /* Update state */
1376  s->current_subsubframe++;
1378  s->current_subsubframe = 0;
1379  s->current_subframe++;
1380  }
1381  if (s->current_subframe >= s->subframes) {
1382 #ifdef TRACE
1383  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1384 #endif
1385  /* Read subframe footer */
1386  if ((ret = dca_subframe_footer(s, base_channel)))
1387  return ret;
1388  }
1389 
1390  return 0;
1391 }
1392 
1396 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
1397  int max_size)
1398 {
1399  uint32_t mrk;
1400  int i, tmp;
1401  const uint16_t *ssrc = (const uint16_t *) src;
1402  uint16_t *sdst = (uint16_t *) dst;
1403  PutBitContext pb;
1404 
1405  if ((unsigned) src_size > (unsigned) max_size) {
1406 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
1407 // return -1;
1408  src_size = max_size;
1409  }
1410 
1411  mrk = AV_RB32(src);
1412  switch (mrk) {
1413  case DCA_MARKER_RAW_BE:
1414  memcpy(dst, src, src_size);
1415  return src_size;
1416  case DCA_MARKER_RAW_LE:
1417  for (i = 0; i < (src_size + 1) >> 1; i++)
1418  *sdst++ = av_bswap16(*ssrc++);
1419  return src_size;
1420  case DCA_MARKER_14B_BE:
1421  case DCA_MARKER_14B_LE:
1422  init_put_bits(&pb, dst, max_size);
1423  for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1424  tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1425  put_bits(&pb, 14, tmp);
1426  }
1427  flush_put_bits(&pb);
1428  return (put_bits_count(&pb) + 7) >> 3;
1429  default:
1430  return AVERROR_INVALIDDATA;
1431  }
1432 }
1433 
1437 static int dca_exss_mask2count(int mask)
1438 {
1439  /* count bits that mean speaker pairs twice */
1440  return av_popcount(mask) +
1441  av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1450 }
1451 
1455 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1456 {
1457  int i;
1458 
1459  for (i = 0; i < channels; i++) {
1460  int mix_map_mask = get_bits(gb, out_ch);
1461  int num_coeffs = av_popcount(mix_map_mask);
1462  skip_bits_long(gb, num_coeffs * 6);
1463  }
1464 }
1465 
1470 {
1471  int header_pos = get_bits_count(&s->gb);
1472  int header_size;
1473  int channels;
1474  int embedded_stereo = 0;
1475  int embedded_6ch = 0;
1476  int drc_code_present;
1477  int extensions_mask;
1478  int i, j;
1479 
1480  if (get_bits_left(&s->gb) < 16)
1481  return -1;
1482 
1483  /* We will parse just enough to get to the extensions bitmask with which
1484  * we can set the profile value. */
1485 
1486  header_size = get_bits(&s->gb, 9) + 1;
1487  skip_bits(&s->gb, 3); // asset index
1488 
1489  if (s->static_fields) {
1490  if (get_bits1(&s->gb))
1491  skip_bits(&s->gb, 4); // asset type descriptor
1492  if (get_bits1(&s->gb))
1493  skip_bits_long(&s->gb, 24); // language descriptor
1494 
1495  if (get_bits1(&s->gb)) {
1496  /* How can one fit 1024 bytes of text here if the maximum value
1497  * for the asset header size field above was 512 bytes? */
1498  int text_length = get_bits(&s->gb, 10) + 1;
1499  if (get_bits_left(&s->gb) < text_length * 8)
1500  return -1;
1501  skip_bits_long(&s->gb, text_length * 8); // info text
1502  }
1503 
1504  skip_bits(&s->gb, 5); // bit resolution - 1
1505  skip_bits(&s->gb, 4); // max sample rate code
1506  channels = get_bits(&s->gb, 8) + 1;
1507 
1508  if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1509  int spkr_remap_sets;
1510  int spkr_mask_size = 16;
1511  int num_spkrs[7];
1512 
1513  if (channels > 2)
1514  embedded_stereo = get_bits1(&s->gb);
1515  if (channels > 6)
1516  embedded_6ch = get_bits1(&s->gb);
1517 
1518  if (get_bits1(&s->gb)) {
1519  spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1520  skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1521  }
1522 
1523  spkr_remap_sets = get_bits(&s->gb, 3);
1524 
1525  for (i = 0; i < spkr_remap_sets; i++) {
1526  /* std layout mask for each remap set */
1527  num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1528  }
1529 
1530  for (i = 0; i < spkr_remap_sets; i++) {
1531  int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1532  if (get_bits_left(&s->gb) < 0)
1533  return -1;
1534 
1535  for (j = 0; j < num_spkrs[i]; j++) {
1536  int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1537  int num_dec_ch = av_popcount(remap_dec_ch_mask);
1538  skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1539  }
1540  }
1541 
1542  } else {
1543  skip_bits(&s->gb, 3); // representation type
1544  }
1545  }
1546 
1547  drc_code_present = get_bits1(&s->gb);
1548  if (drc_code_present)
1549  get_bits(&s->gb, 8); // drc code
1550 
1551  if (get_bits1(&s->gb))
1552  skip_bits(&s->gb, 5); // dialog normalization code
1553 
1554  if (drc_code_present && embedded_stereo)
1555  get_bits(&s->gb, 8); // drc stereo code
1556 
1557  if (s->mix_metadata && get_bits1(&s->gb)) {
1558  skip_bits(&s->gb, 1); // external mix
1559  skip_bits(&s->gb, 6); // post mix gain code
1560 
1561  if (get_bits(&s->gb, 2) != 3) // mixer drc code
1562  skip_bits(&s->gb, 3); // drc limit
1563  else
1564  skip_bits(&s->gb, 8); // custom drc code
1565 
1566  if (get_bits1(&s->gb)) // channel specific scaling
1567  for (i = 0; i < s->num_mix_configs; i++)
1568  skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1569  else
1570  skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1571 
1572  for (i = 0; i < s->num_mix_configs; i++) {
1573  if (get_bits_left(&s->gb) < 0)
1574  return -1;
1575  dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1576  if (embedded_6ch)
1578  if (embedded_stereo)
1580  }
1581  }
1582 
1583  switch (get_bits(&s->gb, 2)) {
1584  case 0: extensions_mask = get_bits(&s->gb, 12); break;
1585  case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1586  case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1587  case 3: extensions_mask = 0; /* aux coding */ break;
1588  }
1589 
1590  /* not parsed further, we were only interested in the extensions mask */
1591 
1592  if (get_bits_left(&s->gb) < 0)
1593  return -1;
1594 
1595  if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1596  av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1597  return -1;
1598  }
1599  skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1600 
1601  if (extensions_mask & DCA_EXT_EXSS_XLL)
1603  else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1606 
1607  if (!(extensions_mask & DCA_EXT_CORE))
1608  av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1609  if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1611  "DTS extensions detection mismatch (%d, %d)\n",
1612  extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1613 
1614  return 0;
1615 }
1616 
1621 {
1622  int ss_index;
1623  int blownup;
1624  int num_audiop = 1;
1625  int num_assets = 1;
1626  int active_ss_mask[8];
1627  int i, j;
1628 
1629  if (get_bits_left(&s->gb) < 52)
1630  return;
1631 
1632  skip_bits(&s->gb, 8); // user data
1633  ss_index = get_bits(&s->gb, 2);
1634 
1635  blownup = get_bits1(&s->gb);
1636  skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1637  skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1638 
1639  s->static_fields = get_bits1(&s->gb);
1640  if (s->static_fields) {
1641  skip_bits(&s->gb, 2); // reference clock code
1642  skip_bits(&s->gb, 3); // frame duration code
1643 
1644  if (get_bits1(&s->gb))
1645  skip_bits_long(&s->gb, 36); // timestamp
1646 
1647  /* a single stream can contain multiple audio assets that can be
1648  * combined to form multiple audio presentations */
1649 
1650  num_audiop = get_bits(&s->gb, 3) + 1;
1651  if (num_audiop > 1) {
1652  av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1653  /* ignore such streams for now */
1654  return;
1655  }
1656 
1657  num_assets = get_bits(&s->gb, 3) + 1;
1658  if (num_assets > 1) {
1659  av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1660  /* ignore such streams for now */
1661  return;
1662  }
1663 
1664  for (i = 0; i < num_audiop; i++)
1665  active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1666 
1667  for (i = 0; i < num_audiop; i++)
1668  for (j = 0; j <= ss_index; j++)
1669  if (active_ss_mask[i] & (1 << j))
1670  skip_bits(&s->gb, 8); // active asset mask
1671 
1672  s->mix_metadata = get_bits1(&s->gb);
1673  if (s->mix_metadata) {
1674  int mix_out_mask_size;
1675 
1676  skip_bits(&s->gb, 2); // adjustment level
1677  mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1678  s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1679 
1680  for (i = 0; i < s->num_mix_configs; i++) {
1681  int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1682  s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1683  }
1684  }
1685  }
1686 
1687  for (i = 0; i < num_assets; i++)
1688  skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1689 
1690  for (i = 0; i < num_assets; i++) {
1692  return;
1693  }
1694 
1695  /* not parsed further, we were only interested in the extensions mask
1696  * from the asset header */
1697 }
1698 
1703 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1704  int *got_frame_ptr, AVPacket *avpkt)
1705 {
1706  const uint8_t *buf = avpkt->data;
1707  int buf_size = avpkt->size;
1708 
1709  int lfe_samples;
1710  int num_core_channels = 0;
1711  int i, ret;
1712  float *samples_flt;
1713  int16_t *samples_s16;
1714  DCAContext *s = avctx->priv_data;
1715  int channels;
1716  int core_ss_end;
1717 
1718 
1719  s->xch_present = 0;
1720 
1721  s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1724  av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1725  return AVERROR_INVALIDDATA;
1726  }
1727 
1728  init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1729  if ((ret = dca_parse_frame_header(s)) < 0) {
1730  //seems like the frame is corrupt, try with the next one
1731  return ret;
1732  }
1733  //set AVCodec values with parsed data
1734  avctx->sample_rate = s->sample_rate;
1735  avctx->bit_rate = s->bit_rate;
1736  avctx->frame_size = s->sample_blocks * 32;
1737 
1738  s->profile = FF_PROFILE_DTS;
1739 
1740  for (i = 0; i < (s->sample_blocks / 8); i++) {
1741  if ((ret = dca_decode_block(s, 0, i))) {
1742  av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1743  return ret;
1744  }
1745  }
1746 
1747  /* record number of core channels incase less than max channels are requested */
1748  num_core_channels = s->prim_channels;
1749 
1750  if (s->ext_coding)
1752  else
1753  s->core_ext_mask = 0;
1754 
1755  core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1756 
1757  /* only scan for extensions if ext_descr was unknown or indicated a
1758  * supported XCh extension */
1759  if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1760 
1761  /* if ext_descr was unknown, clear s->core_ext_mask so that the
1762  * extensions scan can fill it up */
1763  s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1764 
1765  /* extensions start at 32-bit boundaries into bitstream */
1766  skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1767 
1768  while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1769  uint32_t bits = get_bits_long(&s->gb, 32);
1770 
1771  switch (bits) {
1772  case 0x5a5a5a5a: {
1773  int ext_amode, xch_fsize;
1774 
1776 
1777  /* validate sync word using XCHFSIZE field */
1778  xch_fsize = show_bits(&s->gb, 10);
1779  if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1780  (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1781  continue;
1782 
1783  /* skip length-to-end-of-frame field for the moment */
1784  skip_bits(&s->gb, 10);
1785 
1786  s->core_ext_mask |= DCA_EXT_XCH;
1787 
1788  /* extension amode(number of channels in extension) should be 1 */
1789  /* AFAIK XCh is not used for more channels */
1790  if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1791  av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1792  " supported!\n", ext_amode);
1793  continue;
1794  }
1795 
1796  /* much like core primary audio coding header */
1798 
1799  for (i = 0; i < (s->sample_blocks / 8); i++)
1800  if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1801  av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1802  continue;
1803  }
1804 
1805  s->xch_present = 1;
1806  break;
1807  }
1808  case 0x47004a03:
1809  /* XXCh: extended channels */
1810  /* usually found either in core or HD part in DTS-HD HRA streams,
1811  * but not in DTS-ES which contains XCh extensions instead */
1813  break;
1814 
1815  case 0x1d95f262: {
1816  int fsize96 = show_bits(&s->gb, 12) + 1;
1817  if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1818  continue;
1819 
1820  av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1821  get_bits_count(&s->gb));
1822  skip_bits(&s->gb, 12);
1823  av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1824  av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1825 
1826  s->core_ext_mask |= DCA_EXT_X96;
1827  break;
1828  }
1829  }
1830 
1831  skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1832  }
1833  } else {
1834  /* no supported extensions, skip the rest of the core substream */
1835  skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1836  }
1837 
1838  if (s->core_ext_mask & DCA_EXT_X96)
1840  else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1842 
1843  /* check for ExSS (HD part) */
1844  if (s->dca_buffer_size - s->frame_size > 32 &&
1845  get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1847 
1848  avctx->profile = s->profile;
1849 
1850  channels = s->prim_channels + !!s->lfe;
1851 
1852  if (s->amode < 16) {
1854 
1855  if (s->xch_present && (!avctx->request_channels ||
1856  avctx->request_channels > num_core_channels + !!s->lfe)) {
1858  if (s->lfe) {
1861  } else {
1863  }
1864  } else {
1865  channels = num_core_channels + !!s->lfe;
1866  s->xch_present = 0; /* disable further xch processing */
1867  if (s->lfe) {
1870  } else
1872  }
1873 
1874  if (channels > !!s->lfe &&
1875  s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1876  return AVERROR_INVALIDDATA;
1877 
1878  if (avctx->request_channels == 2 && s->prim_channels > 2) {
1879  channels = 2;
1880  s->output = DCA_STEREO;
1882  }
1883  } else {
1884  av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1885  return AVERROR_INVALIDDATA;
1886  }
1887 
1888 
1889  /* There is nothing that prevents a dts frame to change channel configuration
1890  but Libav doesn't support that so only set the channels if it is previously
1891  unset. Ideally during the first probe for channels the crc should be checked
1892  and only set avctx->channels when the crc is ok. Right now the decoder could
1893  set the channels based on a broken first frame.*/
1894  if (s->is_channels_set == 0) {
1895  s->is_channels_set = 1;
1896  avctx->channels = channels;
1897  }
1898  if (avctx->channels != channels) {
1899  av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1900  "channels changing in stream. Skipping frame.\n");
1901  return AVERROR_PATCHWELCOME;
1902  }
1903 
1904  /* get output buffer */
1905  s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1906  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
1907  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1908  return ret;
1909  }
1910  samples_flt = (float *) s->frame.data[0];
1911  samples_s16 = (int16_t *) s->frame.data[0];
1912 
1913  /* filter to get final output */
1914  for (i = 0; i < (s->sample_blocks / 8); i++) {
1915  dca_filter_channels(s, i);
1916 
1917  /* If this was marked as a DTS-ES stream we need to subtract back- */
1918  /* channel from SL & SR to remove matrixed back-channel signal */
1919  if ((s->source_pcm_res & 1) && s->xch_present) {
1920  float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1921  float *lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1922  float *rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1923  s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1924  s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1925  }
1926 
1927  if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1928  s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1929  channels);
1930  samples_flt += 256 * channels;
1931  } else {
1932  s->fmt_conv.float_to_int16_interleave(samples_s16,
1933  s->samples_chanptr, 256,
1934  channels);
1935  samples_s16 += 256 * channels;
1936  }
1937  }
1938 
1939  /* update lfe history */
1940  lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1941  for (i = 0; i < 2 * s->lfe * 4; i++)
1942  s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1943 
1944  *got_frame_ptr = 1;
1945  *(AVFrame *) data = s->frame;
1946 
1947  return buf_size;
1948 }
1949 
1950 
1951 
1959 {
1960  DCAContext *s = avctx->priv_data;
1961  int i;
1962 
1963  s->avctx = avctx;
1964  dca_init_vlcs();
1965 
1966  dsputil_init(&s->dsp, avctx);
1967  ff_mdct_init(&s->imdct, 6, 1, 1.0);
1969  ff_dcadsp_init(&s->dcadsp);
1970  ff_fmt_convert_init(&s->fmt_conv, avctx);
1971 
1972  for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
1973  s->samples_chanptr[i] = s->samples + i * 256;
1974 
1975  if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1976  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1977  s->scale_bias = 1.0 / 32768.0;
1978  } else {
1979  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1980  s->scale_bias = 1.0;
1981  }
1982 
1983  /* allow downmixing to stereo */
1984  if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1985  avctx->request_channels == 2) {
1986  avctx->channels = avctx->request_channels;
1987  }
1988 
1990  avctx->coded_frame = &s->frame;
1991 
1992  return 0;
1993 }
1994 
1996 {
1997  DCAContext *s = avctx->priv_data;
1998  ff_mdct_end(&s->imdct);
1999  return 0;
2000 }
2001 
2002 static const AVProfile profiles[] = {
2003  { FF_PROFILE_DTS, "DTS" },
2004  { FF_PROFILE_DTS_ES, "DTS-ES" },
2005  { FF_PROFILE_DTS_96_24, "DTS 96/24" },
2006  { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2007  { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
2008  { FF_PROFILE_UNKNOWN },
2009 };
2010 
2012  .name = "dca",
2013  .type = AVMEDIA_TYPE_AUDIO,
2014  .id = CODEC_ID_DTS,
2015  .priv_data_size = sizeof(DCAContext),
2016  .init = dca_decode_init,
2018  .close = dca_decode_end,
2019  .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2020  .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2021  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
2024  .profiles = NULL_IF_CONFIG_SMALL(profiles),
2025 };