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