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