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