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  for (j = base_channel; j < s->prim_channels; j++) {
809  s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
810  s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
811  }
812  }
813  }
814 
815  /* Dynamic range coefficient */
816  if (!base_channel && s->dynrange)
817  s->dynrange_coef = get_bits(&s->gb, 8);
818 
819  /* Side information CRC check word */
820  if (s->crc_present) {
821  get_bits(&s->gb, 16);
822  }
823 
824  /*
825  * Primary audio data arrays
826  */
827 
828  /* VQ encoded high frequency subbands */
829  for (j = base_channel; j < s->prim_channels; j++)
830  for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
831  /* 1 vector -> 32 samples */
832  s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
833 
834  /* Low frequency effect data */
835  if (!base_channel && s->lfe) {
836  /* LFE samples */
837  int lfe_samples = 2 * s->lfe * (4 + block_index);
838  int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
839  float lfe_scale;
840 
841  for (j = lfe_samples; j < lfe_end_sample; j++) {
842  /* Signed 8 bits int */
843  s->lfe_data[j] = get_sbits(&s->gb, 8);
844  }
845 
846  /* Scale factor index */
847  skip_bits(&s->gb, 1);
849 
850  /* Quantization step size * scale factor */
851  lfe_scale = 0.035 * s->lfe_scale_factor;
852 
853  for (j = lfe_samples; j < lfe_end_sample; j++)
854  s->lfe_data[j] *= lfe_scale;
855  }
856 
857 #ifdef TRACE
858  av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
860  av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
862 
863  for (j = base_channel; j < s->prim_channels; j++) {
864  av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
865  for (k = 0; k < s->subband_activity[j]; k++)
866  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
867  av_log(s->avctx, AV_LOG_DEBUG, "\n");
868  }
869  for (j = base_channel; j < s->prim_channels; j++) {
870  for (k = 0; k < s->subband_activity[j]; k++)
872  "prediction coefs: %f, %f, %f, %f\n",
873  (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
874  (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
875  (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
876  (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
877  }
878  for (j = base_channel; j < s->prim_channels; j++) {
879  av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
880  for (k = 0; k < s->vq_start_subband[j]; k++)
881  av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
882  av_log(s->avctx, AV_LOG_DEBUG, "\n");
883  }
884  for (j = base_channel; j < s->prim_channels; j++) {
885  av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
886  for (k = 0; k < s->subband_activity[j]; k++)
887  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
888  av_log(s->avctx, AV_LOG_DEBUG, "\n");
889  }
890  for (j = base_channel; j < s->prim_channels; j++) {
891  av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
892  for (k = 0; k < s->subband_activity[j]; k++) {
893  if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
894  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
895  if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
896  av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
897  }
898  av_log(s->avctx, AV_LOG_DEBUG, "\n");
899  }
900  for (j = base_channel; j < s->prim_channels; j++) {
901  if (s->joint_intensity[j] > 0) {
902  int source_channel = s->joint_intensity[j] - 1;
903  av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
904  for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
905  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
906  av_log(s->avctx, AV_LOG_DEBUG, "\n");
907  }
908  }
909  if (!base_channel && s->prim_channels > 2 && s->downmix) {
910  av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
911  for (j = 0; j < s->prim_channels; j++) {
912  av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
913  dca_downmix_coeffs[s->downmix_coef[j][0]]);
914  av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
915  dca_downmix_coeffs[s->downmix_coef[j][1]]);
916  }
917  av_log(s->avctx, AV_LOG_DEBUG, "\n");
918  }
919  for (j = base_channel; j < s->prim_channels; j++)
920  for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
921  av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
922  if (!base_channel && s->lfe) {
923  int lfe_samples = 2 * s->lfe * (4 + block_index);
924  int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
925 
926  av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
927  for (j = lfe_samples; j < lfe_end_sample; j++)
928  av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
929  av_log(s->avctx, AV_LOG_DEBUG, "\n");
930  }
931 #endif
932 
933  return 0;
934 }
935 
936 static void qmf_32_subbands(DCAContext *s, int chans,
937  float samples_in[32][8], float *samples_out,
938  float scale)
939 {
940  const float *prCoeff;
941  int i;
942 
943  int sb_act = s->subband_activity[chans];
944  int subindex;
945 
946  scale *= sqrt(1 / 8.0);
947 
948  /* Select filter */
949  if (!s->multirate_inter) /* Non-perfect reconstruction */
950  prCoeff = fir_32bands_nonperfect;
951  else /* Perfect reconstruction */
952  prCoeff = fir_32bands_perfect;
953 
954  for (i = sb_act; i < 32; i++)
955  s->raXin[i] = 0.0;
956 
957  /* Reconstructed channel sample index */
958  for (subindex = 0; subindex < 8; subindex++) {
959  /* Load in one sample from each subband and clear inactive subbands */
960  for (i = 0; i < sb_act; i++) {
961  unsigned sign = (i - 1) & 2;
962  uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
963  AV_WN32A(&s->raXin[i], v);
964  }
965 
967  s->subband_fir_hist[chans],
968  &s->hist_index[chans],
969  s->subband_fir_noidea[chans], prCoeff,
970  samples_out, s->raXin, scale);
971  samples_out += 32;
972  }
973 }
974 
975 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
976  int num_deci_sample, float *samples_in,
977  float *samples_out, float scale)
978 {
979  /* samples_in: An array holding decimated samples.
980  * Samples in current subframe starts from samples_in[0],
981  * while samples_in[-1], samples_in[-2], ..., stores samples
982  * from last subframe as history.
983  *
984  * samples_out: An array holding interpolated samples
985  */
986 
987  int decifactor;
988  const float *prCoeff;
989  int deciindex;
990 
991  /* Select decimation filter */
992  if (decimation_select == 1) {
993  decifactor = 64;
994  prCoeff = lfe_fir_128;
995  } else {
996  decifactor = 32;
997  prCoeff = lfe_fir_64;
998  }
999  /* Interpolation */
1000  for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1001  s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1002  samples_in++;
1003  samples_out += 2 * decifactor;
1004  }
1005 }
1006 
1007 /* downmixing routines */
1008 #define MIX_REAR1(samples, si1, rs, coef) \
1009  samples[i] += samples[si1] * coef[rs][0]; \
1010  samples[i+256] += samples[si1] * coef[rs][1];
1011 
1012 #define MIX_REAR2(samples, si1, si2, rs, coef) \
1013  samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
1014  samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1015 
1016 #define MIX_FRONT3(samples, coef) \
1017  t = samples[i + c]; \
1018  u = samples[i + l]; \
1019  v = samples[i + r]; \
1020  samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1021  samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1022 
1023 #define DOWNMIX_TO_STEREO(op1, op2) \
1024  for (i = 0; i < 256; i++) { \
1025  op1 \
1026  op2 \
1027  }
1028 
1029 static void dca_downmix(float *samples, int srcfmt,
1030  int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1031  const int8_t *channel_mapping)
1032 {
1033  int c, l, r, sl, sr, s;
1034  int i;
1035  float t, u, v;
1036  float coef[DCA_PRIM_CHANNELS_MAX][2];
1037 
1038  for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1039  coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1040  coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1041  }
1042 
1043  switch (srcfmt) {
1044  case DCA_MONO:
1045  case DCA_CHANNEL:
1046  case DCA_STEREO_TOTAL:
1047  case DCA_STEREO_SUMDIFF:
1048  case DCA_4F2R:
1049  av_log(NULL, 0, "Not implemented!\n");
1050  break;
1051  case DCA_STEREO:
1052  break;
1053  case DCA_3F:
1054  c = channel_mapping[0] * 256;
1055  l = channel_mapping[1] * 256;
1056  r = channel_mapping[2] * 256;
1057  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1058  break;
1059  case DCA_2F1R:
1060  s = channel_mapping[2] * 256;
1061  DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1062  break;
1063  case DCA_3F1R:
1064  c = channel_mapping[0] * 256;
1065  l = channel_mapping[1] * 256;
1066  r = channel_mapping[2] * 256;
1067  s = channel_mapping[3] * 256;
1068  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1069  MIX_REAR1(samples, i + s, 3, coef));
1070  break;
1071  case DCA_2F2R:
1072  sl = channel_mapping[2] * 256;
1073  sr = channel_mapping[3] * 256;
1074  DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1075  break;
1076  case DCA_3F2R:
1077  c = channel_mapping[0] * 256;
1078  l = channel_mapping[1] * 256;
1079  r = channel_mapping[2] * 256;
1080  sl = channel_mapping[3] * 256;
1081  sr = channel_mapping[4] * 256;
1082  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1083  MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1084  break;
1085  }
1086 }
1087 
1088 
1089 #ifndef decode_blockcodes
1090 /* Very compact version of the block code decoder that does not use table
1091  * look-up but is slightly slower */
1092 static int decode_blockcode(int code, int levels, int *values)
1093 {
1094  int i;
1095  int offset = (levels - 1) >> 1;
1096 
1097  for (i = 0; i < 4; i++) {
1098  int div = FASTDIV(code, levels);
1099  values[i] = code - offset - div * levels;
1100  code = div;
1101  }
1102 
1103  return code;
1104 }
1105 
1106 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1107 {
1108  return decode_blockcode(code1, levels, values) |
1109  decode_blockcode(code2, levels, values + 4);
1110 }
1111 #endif
1112 
1113 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1114 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1115 
1116 #ifndef int8x8_fmul_int32
1117 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1118 {
1119  float fscale = scale / 16.0;
1120  int i;
1121  for (i = 0; i < 8; i++)
1122  dst[i] = src[i] * fscale;
1123 }
1124 #endif
1125 
1126 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1127 {
1128  int k, l;
1129  int subsubframe = s->current_subsubframe;
1130 
1131  const float *quant_step_table;
1132 
1133  /* FIXME */
1134  float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1135  LOCAL_ALIGNED_16(int, block, [8]);
1136 
1137  /*
1138  * Audio data
1139  */
1140 
1141  /* Select quantization step size table */
1142  if (s->bit_rate_index == 0x1f)
1143  quant_step_table = lossless_quant_d;
1144  else
1145  quant_step_table = lossy_quant_d;
1146 
1147  for (k = base_channel; k < s->prim_channels; k++) {
1148  if (get_bits_left(&s->gb) < 0)
1149  return AVERROR_INVALIDDATA;
1150 
1151  for (l = 0; l < s->vq_start_subband[k]; l++) {
1152  int m;
1153 
1154  /* Select the mid-tread linear quantizer */
1155  int abits = s->bitalloc[k][l];
1156 
1157  float quant_step_size = quant_step_table[abits];
1158 
1159  /*
1160  * Determine quantization index code book and its type
1161  */
1162 
1163  /* Select quantization index code book */
1164  int sel = s->quant_index_huffman[k][abits];
1165 
1166  /*
1167  * Extract bits from the bit stream
1168  */
1169  if (!abits) {
1170  memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1171  } else {
1172  /* Deal with transients */
1173  int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1174  float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1175  s->scalefactor_adj[k][sel];
1176 
1177  if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1178  if (abits <= 7) {
1179  /* Block code */
1180  int block_code1, block_code2, size, levels, err;
1181 
1182  size = abits_sizes[abits - 1];
1183  levels = abits_levels[abits - 1];
1184 
1185  block_code1 = get_bits(&s->gb, size);
1186  block_code2 = get_bits(&s->gb, size);
1187  err = decode_blockcodes(block_code1, block_code2,
1188  levels, block);
1189  if (err) {
1191  "ERROR: block code look-up failed\n");
1192  return AVERROR_INVALIDDATA;
1193  }
1194  } else {
1195  /* no coding */
1196  for (m = 0; m < 8; m++)
1197  block[m] = get_sbits(&s->gb, abits - 3);
1198  }
1199  } else {
1200  /* Huffman coded */
1201  for (m = 0; m < 8; m++)
1202  block[m] = get_bitalloc(&s->gb,
1203  &dca_smpl_bitalloc[abits], sel);
1204  }
1205 
1206  s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1207  block, rscale, 8);
1208  }
1209 
1210  /*
1211  * Inverse ADPCM if in prediction mode
1212  */
1213  if (s->prediction_mode[k][l]) {
1214  int n;
1215  for (m = 0; m < 8; m++) {
1216  for (n = 1; n <= 4; n++)
1217  if (m >= n)
1218  subband_samples[k][l][m] +=
1219  (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1220  subband_samples[k][l][m - n] / 8192);
1221  else if (s->predictor_history)
1222  subband_samples[k][l][m] +=
1223  (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1224  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1225  }
1226  }
1227  }
1228 
1229  /*
1230  * Decode VQ encoded high frequencies
1231  */
1232  for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1233  /* 1 vector -> 32 samples but we only need the 8 samples
1234  * for this subsubframe. */
1235  int hfvq = s->high_freq_vq[k][l];
1236 
1237  if (!s->debug_flag & 0x01) {
1239  "Stream with high frequencies VQ coding\n");
1240  s->debug_flag |= 0x01;
1241  }
1242 
1243  int8x8_fmul_int32(subband_samples[k][l],
1244  &high_freq_vq[hfvq][subsubframe * 8],
1245  s->scale_factor[k][l][0]);
1246  }
1247  }
1248 
1249  /* Check for DSYNC after subsubframe */
1250  if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1251  if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1252 #ifdef TRACE
1253  av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1254 #endif
1255  } else {
1256  av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1257  }
1258  }
1259 
1260  /* Backup predictor history for adpcm */
1261  for (k = base_channel; k < s->prim_channels; k++)
1262  for (l = 0; l < s->vq_start_subband[k]; l++)
1263  memcpy(s->subband_samples_hist[k][l],
1264  &subband_samples[k][l][4],
1265  4 * sizeof(subband_samples[0][0][0]));
1266 
1267  return 0;
1268 }
1269 
1270 static int dca_filter_channels(DCAContext *s, int block_index)
1271 {
1272  float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1273  int k;
1274 
1275  /* 32 subbands QMF */
1276  for (k = 0; k < s->prim_channels; k++) {
1277 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1278  0, 8388608.0, 8388608.0 };*/
1279  qmf_32_subbands(s, k, subband_samples[k],
1280  &s->samples[256 * s->channel_order_tab[k]],
1281  M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1282  }
1283 
1284  /* Down mixing */
1285  if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1287  }
1288 
1289  /* Generate LFE samples for this subsubframe FIXME!!! */
1290  if (s->output & DCA_LFE) {
1291  lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1292  s->lfe_data + 2 * s->lfe * (block_index + 4),
1293  &s->samples[256 * dca_lfe_index[s->amode]],
1294  (1.0 / 256.0) * s->scale_bias);
1295  /* Outputs 20bits pcm samples */
1296  }
1297 
1298  return 0;
1299 }
1300 
1301 
1302 static int dca_subframe_footer(DCAContext *s, int base_channel)
1303 {
1304  int aux_data_count = 0, i;
1305 
1306  /*
1307  * Unpack optional information
1308  */
1309 
1310  /* presumably optional information only appears in the core? */
1311  if (!base_channel) {
1312  if (s->timestamp)
1313  skip_bits_long(&s->gb, 32);
1314 
1315  if (s->aux_data)
1316  aux_data_count = get_bits(&s->gb, 6);
1317 
1318  for (i = 0; i < aux_data_count; i++)
1319  get_bits(&s->gb, 8);
1320 
1321  if (s->crc_present && (s->downmix || s->dynrange))
1322  get_bits(&s->gb, 16);
1323  }
1324 
1325  return 0;
1326 }
1327 
1334 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1335 {
1336  int ret;
1337 
1338  /* Sanity check */
1339  if (s->current_subframe >= s->subframes) {
1340  av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1341  s->current_subframe, s->subframes);
1342  return AVERROR_INVALIDDATA;
1343  }
1344 
1345  if (!s->current_subsubframe) {
1346 #ifdef TRACE
1347  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1348 #endif
1349  /* Read subframe header */
1350  if ((ret = dca_subframe_header(s, base_channel, block_index)))
1351  return ret;
1352  }
1353 
1354  /* Read subsubframe */
1355 #ifdef TRACE
1356  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1357 #endif
1358  if ((ret = dca_subsubframe(s, base_channel, block_index)))
1359  return ret;
1360 
1361  /* Update state */
1362  s->current_subsubframe++;
1364  s->current_subsubframe = 0;
1365  s->current_subframe++;
1366  }
1367  if (s->current_subframe >= s->subframes) {
1368 #ifdef TRACE
1369  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1370 #endif
1371  /* Read subframe footer */
1372  if ((ret = dca_subframe_footer(s, base_channel)))
1373  return ret;
1374  }
1375 
1376  return 0;
1377 }
1378 
1382 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
1383  int max_size)
1384 {
1385  uint32_t mrk;
1386  int i, tmp;
1387  const uint16_t *ssrc = (const uint16_t *) src;
1388  uint16_t *sdst = (uint16_t *) dst;
1389  PutBitContext pb;
1390 
1391  if ((unsigned) src_size > (unsigned) max_size) {
1392 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
1393 // return -1;
1394  src_size = max_size;
1395  }
1396 
1397  mrk = AV_RB32(src);
1398  switch (mrk) {
1399  case DCA_MARKER_RAW_BE:
1400  memcpy(dst, src, src_size);
1401  return src_size;
1402  case DCA_MARKER_RAW_LE:
1403  for (i = 0; i < (src_size + 1) >> 1; i++)
1404  *sdst++ = av_bswap16(*ssrc++);
1405  return src_size;
1406  case DCA_MARKER_14B_BE:
1407  case DCA_MARKER_14B_LE:
1408  init_put_bits(&pb, dst, max_size);
1409  for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1410  tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1411  put_bits(&pb, 14, tmp);
1412  }
1413  flush_put_bits(&pb);
1414  return (put_bits_count(&pb) + 7) >> 3;
1415  default:
1416  return AVERROR_INVALIDDATA;
1417  }
1418 }
1419 
1423 static int dca_exss_mask2count(int mask)
1424 {
1425  /* count bits that mean speaker pairs twice */
1426  return av_popcount(mask) +
1427  av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1436 }
1437 
1441 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1442 {
1443  int i;
1444 
1445  for (i = 0; i < channels; i++) {
1446  int mix_map_mask = get_bits(gb, out_ch);
1447  int num_coeffs = av_popcount(mix_map_mask);
1448  skip_bits_long(gb, num_coeffs * 6);
1449  }
1450 }
1451 
1456 {
1457  int header_pos = get_bits_count(&s->gb);
1458  int header_size;
1459  int channels;
1460  int embedded_stereo = 0;
1461  int embedded_6ch = 0;
1462  int drc_code_present;
1463  int extensions_mask;
1464  int i, j;
1465 
1466  if (get_bits_left(&s->gb) < 16)
1467  return -1;
1468 
1469  /* We will parse just enough to get to the extensions bitmask with which
1470  * we can set the profile value. */
1471 
1472  header_size = get_bits(&s->gb, 9) + 1;
1473  skip_bits(&s->gb, 3); // asset index
1474 
1475  if (s->static_fields) {
1476  if (get_bits1(&s->gb))
1477  skip_bits(&s->gb, 4); // asset type descriptor
1478  if (get_bits1(&s->gb))
1479  skip_bits_long(&s->gb, 24); // language descriptor
1480 
1481  if (get_bits1(&s->gb)) {
1482  /* How can one fit 1024 bytes of text here if the maximum value
1483  * for the asset header size field above was 512 bytes? */
1484  int text_length = get_bits(&s->gb, 10) + 1;
1485  if (get_bits_left(&s->gb) < text_length * 8)
1486  return -1;
1487  skip_bits_long(&s->gb, text_length * 8); // info text
1488  }
1489 
1490  skip_bits(&s->gb, 5); // bit resolution - 1
1491  skip_bits(&s->gb, 4); // max sample rate code
1492  channels = get_bits(&s->gb, 8) + 1;
1493 
1494  if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1495  int spkr_remap_sets;
1496  int spkr_mask_size = 16;
1497  int num_spkrs[7];
1498 
1499  if (channels > 2)
1500  embedded_stereo = get_bits1(&s->gb);
1501  if (channels > 6)
1502  embedded_6ch = get_bits1(&s->gb);
1503 
1504  if (get_bits1(&s->gb)) {
1505  spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1506  skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1507  }
1508 
1509  spkr_remap_sets = get_bits(&s->gb, 3);
1510 
1511  for (i = 0; i < spkr_remap_sets; i++) {
1512  /* std layout mask for each remap set */
1513  num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1514  }
1515 
1516  for (i = 0; i < spkr_remap_sets; i++) {
1517  int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1518  if (get_bits_left(&s->gb) < 0)
1519  return -1;
1520 
1521  for (j = 0; j < num_spkrs[i]; j++) {
1522  int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1523  int num_dec_ch = av_popcount(remap_dec_ch_mask);
1524  skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1525  }
1526  }
1527 
1528  } else {
1529  skip_bits(&s->gb, 3); // representation type
1530  }
1531  }
1532 
1533  drc_code_present = get_bits1(&s->gb);
1534  if (drc_code_present)
1535  get_bits(&s->gb, 8); // drc code
1536 
1537  if (get_bits1(&s->gb))
1538  skip_bits(&s->gb, 5); // dialog normalization code
1539 
1540  if (drc_code_present && embedded_stereo)
1541  get_bits(&s->gb, 8); // drc stereo code
1542 
1543  if (s->mix_metadata && get_bits1(&s->gb)) {
1544  skip_bits(&s->gb, 1); // external mix
1545  skip_bits(&s->gb, 6); // post mix gain code
1546 
1547  if (get_bits(&s->gb, 2) != 3) // mixer drc code
1548  skip_bits(&s->gb, 3); // drc limit
1549  else
1550  skip_bits(&s->gb, 8); // custom drc code
1551 
1552  if (get_bits1(&s->gb)) // channel specific scaling
1553  for (i = 0; i < s->num_mix_configs; i++)
1554  skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1555  else
1556  skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1557 
1558  for (i = 0; i < s->num_mix_configs; i++) {
1559  if (get_bits_left(&s->gb) < 0)
1560  return -1;
1561  dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1562  if (embedded_6ch)
1564  if (embedded_stereo)
1566  }
1567  }
1568 
1569  switch (get_bits(&s->gb, 2)) {
1570  case 0: extensions_mask = get_bits(&s->gb, 12); break;
1571  case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1572  case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1573  case 3: extensions_mask = 0; /* aux coding */ break;
1574  }
1575 
1576  /* not parsed further, we were only interested in the extensions mask */
1577 
1578  if (get_bits_left(&s->gb) < 0)
1579  return -1;
1580 
1581  if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1582  av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1583  return -1;
1584  }
1585  skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1586 
1587  if (extensions_mask & DCA_EXT_EXSS_XLL)
1589  else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1592 
1593  if (!(extensions_mask & DCA_EXT_CORE))
1594  av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1595  if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1597  "DTS extensions detection mismatch (%d, %d)\n",
1598  extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1599 
1600  return 0;
1601 }
1602 
1607 {
1608  int ss_index;
1609  int blownup;
1610  int num_audiop = 1;
1611  int num_assets = 1;
1612  int active_ss_mask[8];
1613  int i, j;
1614 
1615  if (get_bits_left(&s->gb) < 52)
1616  return;
1617 
1618  skip_bits(&s->gb, 8); // user data
1619  ss_index = get_bits(&s->gb, 2);
1620 
1621  blownup = get_bits1(&s->gb);
1622  skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1623  skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1624 
1625  s->static_fields = get_bits1(&s->gb);
1626  if (s->static_fields) {
1627  skip_bits(&s->gb, 2); // reference clock code
1628  skip_bits(&s->gb, 3); // frame duration code
1629 
1630  if (get_bits1(&s->gb))
1631  skip_bits_long(&s->gb, 36); // timestamp
1632 
1633  /* a single stream can contain multiple audio assets that can be
1634  * combined to form multiple audio presentations */
1635 
1636  num_audiop = get_bits(&s->gb, 3) + 1;
1637  if (num_audiop > 1) {
1638  av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1639  /* ignore such streams for now */
1640  return;
1641  }
1642 
1643  num_assets = get_bits(&s->gb, 3) + 1;
1644  if (num_assets > 1) {
1645  av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1646  /* ignore such streams for now */
1647  return;
1648  }
1649 
1650  for (i = 0; i < num_audiop; i++)
1651  active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1652 
1653  for (i = 0; i < num_audiop; i++)
1654  for (j = 0; j <= ss_index; j++)
1655  if (active_ss_mask[i] & (1 << j))
1656  skip_bits(&s->gb, 8); // active asset mask
1657 
1658  s->mix_metadata = get_bits1(&s->gb);
1659  if (s->mix_metadata) {
1660  int mix_out_mask_size;
1661 
1662  skip_bits(&s->gb, 2); // adjustment level
1663  mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1664  s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1665 
1666  for (i = 0; i < s->num_mix_configs; i++) {
1667  int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1668  s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1669  }
1670  }
1671  }
1672 
1673  for (i = 0; i < num_assets; i++)
1674  skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1675 
1676  for (i = 0; i < num_assets; i++) {
1678  return;
1679  }
1680 
1681  /* not parsed further, we were only interested in the extensions mask
1682  * from the asset header */
1683 }
1684 
1689 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1690  int *got_frame_ptr, AVPacket *avpkt)
1691 {
1692  const uint8_t *buf = avpkt->data;
1693  int buf_size = avpkt->size;
1694 
1695  int lfe_samples;
1696  int num_core_channels = 0;
1697  int i, ret;
1698  float *samples_flt;
1699  int16_t *samples_s16;
1700  DCAContext *s = avctx->priv_data;
1701  int channels;
1702  int core_ss_end;
1703 
1704 
1705  s->xch_present = 0;
1706 
1707  s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1710  av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1711  return AVERROR_INVALIDDATA;
1712  }
1713 
1714  init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1715  if ((ret = dca_parse_frame_header(s)) < 0) {
1716  //seems like the frame is corrupt, try with the next one
1717  return ret;
1718  }
1719  //set AVCodec values with parsed data
1720  avctx->sample_rate = s->sample_rate;
1721  avctx->bit_rate = s->bit_rate;
1722  avctx->frame_size = s->sample_blocks * 32;
1723 
1724  s->profile = FF_PROFILE_DTS;
1725 
1726  for (i = 0; i < (s->sample_blocks / 8); i++) {
1727  if ((ret = dca_decode_block(s, 0, i))) {
1728  av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1729  return ret;
1730  }
1731  }
1732 
1733  /* record number of core channels incase less than max channels are requested */
1734  num_core_channels = s->prim_channels;
1735 
1736  if (s->ext_coding)
1738  else
1739  s->core_ext_mask = 0;
1740 
1741  core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1742 
1743  /* only scan for extensions if ext_descr was unknown or indicated a
1744  * supported XCh extension */
1745  if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1746 
1747  /* if ext_descr was unknown, clear s->core_ext_mask so that the
1748  * extensions scan can fill it up */
1749  s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1750 
1751  /* extensions start at 32-bit boundaries into bitstream */
1752  skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1753 
1754  while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1755  uint32_t bits = get_bits_long(&s->gb, 32);
1756 
1757  switch (bits) {
1758  case 0x5a5a5a5a: {
1759  int ext_amode, xch_fsize;
1760 
1762 
1763  /* validate sync word using XCHFSIZE field */
1764  xch_fsize = show_bits(&s->gb, 10);
1765  if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1766  (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1767  continue;
1768 
1769  /* skip length-to-end-of-frame field for the moment */
1770  skip_bits(&s->gb, 10);
1771 
1772  s->core_ext_mask |= DCA_EXT_XCH;
1773 
1774  /* extension amode(number of channels in extension) should be 1 */
1775  /* AFAIK XCh is not used for more channels */
1776  if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1777  av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1778  " supported!\n", ext_amode);
1779  continue;
1780  }
1781 
1782  /* much like core primary audio coding header */
1784 
1785  for (i = 0; i < (s->sample_blocks / 8); i++)
1786  if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1787  av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1788  continue;
1789  }
1790 
1791  s->xch_present = 1;
1792  break;
1793  }
1794  case 0x47004a03:
1795  /* XXCh: extended channels */
1796  /* usually found either in core or HD part in DTS-HD HRA streams,
1797  * but not in DTS-ES which contains XCh extensions instead */
1799  break;
1800 
1801  case 0x1d95f262: {
1802  int fsize96 = show_bits(&s->gb, 12) + 1;
1803  if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1804  continue;
1805 
1806  av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1807  get_bits_count(&s->gb));
1808  skip_bits(&s->gb, 12);
1809  av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1810  av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1811 
1812  s->core_ext_mask |= DCA_EXT_X96;
1813  break;
1814  }
1815  }
1816 
1817  skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1818  }
1819  } else {
1820  /* no supported extensions, skip the rest of the core substream */
1821  skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1822  }
1823 
1824  if (s->core_ext_mask & DCA_EXT_X96)
1826  else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1828 
1829  /* check for ExSS (HD part) */
1830  if (s->dca_buffer_size - s->frame_size > 32 &&
1831  get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1833 
1834  avctx->profile = s->profile;
1835 
1836  channels = s->prim_channels + !!s->lfe;
1837 
1838  if (s->amode < 16) {
1840 
1841  if (s->xch_present && (!avctx->request_channels ||
1842  avctx->request_channels > num_core_channels + !!s->lfe)) {
1844  if (s->lfe) {
1847  } else {
1849  }
1850  } else {
1851  channels = num_core_channels + !!s->lfe;
1852  s->xch_present = 0; /* disable further xch processing */
1853  if (s->lfe) {
1856  } else
1858  }
1859 
1860  if (channels > !!s->lfe &&
1861  s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1862  return AVERROR_INVALIDDATA;
1863 
1864  if (avctx->request_channels == 2 && s->prim_channels > 2) {
1865  channels = 2;
1866  s->output = DCA_STEREO;
1868  }
1869  } else {
1870  av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1871  return AVERROR_INVALIDDATA;
1872  }
1873 
1874 
1875  /* There is nothing that prevents a dts frame to change channel configuration
1876  but Libav doesn't support that so only set the channels if it is previously
1877  unset. Ideally during the first probe for channels the crc should be checked
1878  and only set avctx->channels when the crc is ok. Right now the decoder could
1879  set the channels based on a broken first frame.*/
1880  if (s->is_channels_set == 0) {
1881  s->is_channels_set = 1;
1882  avctx->channels = channels;
1883  }
1884  if (avctx->channels != channels) {
1885  av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1886  "channels changing in stream. Skipping frame.\n");
1887  return AVERROR_PATCHWELCOME;
1888  }
1889 
1890  /* get output buffer */
1891  s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1892  if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1893  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1894  return ret;
1895  }
1896  samples_flt = (float *) s->frame.data[0];
1897  samples_s16 = (int16_t *) s->frame.data[0];
1898 
1899  /* filter to get final output */
1900  for (i = 0; i < (s->sample_blocks / 8); i++) {
1901  dca_filter_channels(s, i);
1902 
1903  /* If this was marked as a DTS-ES stream we need to subtract back- */
1904  /* channel from SL & SR to remove matrixed back-channel signal */
1905  if ((s->source_pcm_res & 1) && s->xch_present) {
1906  float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1907  float *lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1908  float *rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1909  s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1910  s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1911  }
1912 
1913  if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1914  s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
1915  channels);
1916  samples_flt += 256 * channels;
1917  } else {
1918  s->fmt_conv.float_to_int16_interleave(samples_s16,
1919  s->samples_chanptr, 256,
1920  channels);
1921  samples_s16 += 256 * channels;
1922  }
1923  }
1924 
1925  /* update lfe history */
1926  lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1927  for (i = 0; i < 2 * s->lfe * 4; i++)
1928  s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1929 
1930  *got_frame_ptr = 1;
1931  *(AVFrame *) data = s->frame;
1932 
1933  return buf_size;
1934 }
1935 
1936 
1937 
1945 {
1946  DCAContext *s = avctx->priv_data;
1947  int i;
1948 
1949  s->avctx = avctx;
1950  dca_init_vlcs();
1951 
1952  dsputil_init(&s->dsp, avctx);
1953  ff_mdct_init(&s->imdct, 6, 1, 1.0);
1955  ff_dcadsp_init(&s->dcadsp);
1956  ff_fmt_convert_init(&s->fmt_conv, avctx);
1957 
1958  for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
1959  s->samples_chanptr[i] = s->samples + i * 256;
1960 
1961  if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
1962  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1963  s->scale_bias = 1.0 / 32768.0;
1964  } else {
1965  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1966  s->scale_bias = 1.0;
1967  }
1968 
1969  /* allow downmixing to stereo */
1970  if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1971  avctx->request_channels == 2) {
1972  avctx->channels = avctx->request_channels;
1973  }
1974 
1976  avctx->coded_frame = &s->frame;
1977 
1978  return 0;
1979 }
1980 
1982 {
1983  DCAContext *s = avctx->priv_data;
1984  ff_mdct_end(&s->imdct);
1985  return 0;
1986 }
1987 
1988 static const AVProfile profiles[] = {
1989  { FF_PROFILE_DTS, "DTS" },
1990  { FF_PROFILE_DTS_ES, "DTS-ES" },
1991  { FF_PROFILE_DTS_96_24, "DTS 96/24" },
1992  { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1993  { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
1994  { FF_PROFILE_UNKNOWN },
1995 };
1996 
1998  .name = "dca",
1999  .type = AVMEDIA_TYPE_AUDIO,
2000  .id = CODEC_ID_DTS,
2001  .priv_data_size = sizeof(DCAContext),
2002  .init = dca_decode_init,
2004  .close = dca_decode_end,
2005  .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2006  .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2007  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
2010  .profiles = NULL_IF_CONFIG_SMALL(profiles),
2011 };