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 
29 #include "libavutil/channel_layout.h"
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,
66  DCA_CHANNEL,
67  DCA_STEREO,
68  DCA_STEREO_SUMDIFF,
69  DCA_STEREO_TOTAL,
70  DCA_3F,
71  DCA_2F1R,
72  DCA_3F1R,
73  DCA_2F2R,
74  DCA_3F2R,
75  DCA_4F2R
76 };
77 
78 /* these are unconfirmed but should be mostly correct */
79 enum DCAExSSSpeakerMask {
80  DCA_EXSS_FRONT_CENTER = 0x0001,
81  DCA_EXSS_FRONT_LEFT_RIGHT = 0x0002,
82  DCA_EXSS_SIDE_REAR_LEFT_RIGHT = 0x0004,
83  DCA_EXSS_LFE = 0x0008,
84  DCA_EXSS_REAR_CENTER = 0x0010,
85  DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
86  DCA_EXSS_REAR_LEFT_RIGHT = 0x0040,
87  DCA_EXSS_FRONT_HIGH_CENTER = 0x0080,
88  DCA_EXSS_OVERHEAD = 0x0100,
89  DCA_EXSS_CENTER_LEFT_RIGHT = 0x0200,
90  DCA_EXSS_WIDE_LEFT_RIGHT = 0x0400,
91  DCA_EXSS_SIDE_LEFT_RIGHT = 0x0800,
92  DCA_EXSS_LFE2 = 0x1000,
93  DCA_EXSS_SIDE_HIGH_LEFT_RIGHT = 0x2000,
94  DCA_EXSS_REAR_HIGH_CENTER = 0x4000,
95  DCA_EXSS_REAR_HIGH_LEFT_RIGHT = 0x8000,
96 };
97 
98 enum DCAExtensionMask {
99  DCA_EXT_CORE = 0x001,
100  DCA_EXT_XXCH = 0x002,
101  DCA_EXT_X96 = 0x004,
102  DCA_EXT_XCH = 0x008,
103  DCA_EXT_EXSS_CORE = 0x010,
104  DCA_EXT_EXSS_XBR = 0x020,
105  DCA_EXT_EXSS_XXCH = 0x040,
106  DCA_EXT_EXSS_X96 = 0x080,
107  DCA_EXT_EXSS_LBR = 0x100,
108  DCA_EXT_EXSS_XLL = 0x200,
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,
116  DCA_EXT_XCH | 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[] = {
136  AV_CH_FRONT_CENTER,
137  AV_CH_LAYOUT_STEREO,
138  AV_CH_LAYOUT_STEREO,
139  AV_CH_LAYOUT_STEREO,
140  AV_CH_LAYOUT_STEREO,
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 |
147  AV_CH_SIDE_RIGHT,
148 
149  AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
150  AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,
151 
152  AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
153  AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,
154 
155  AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
156  AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER |
157  AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,
158 
159  AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
160  AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
161  AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
162 
163  AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
164  AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
165  AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,
166 
167  AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
168  AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
169  AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,
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 
274 static BitAlloc dca_bitalloc_index;
275 static BitAlloc dca_tmode;
276 static BitAlloc dca_scalefactor;
277 static BitAlloc dca_smpl_bitalloc[11];
278 
279 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
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 {
287  AVCodecContext *avctx;
288  AVFrame frame;
289  /* Frame header */
290  int frame_type;
291  int samples_deficit;
292  int crc_present;
293  int sample_blocks;
294  int frame_size;
295  int amode;
296  int sample_rate;
297  int bit_rate;
298  int bit_rate_index;
299 
300  int downmix;
301  int dynrange;
302  int timestamp;
303  int aux_data;
304  int hdcd;
305  int ext_descr;
306  int ext_coding;
307  int aspf;
308  int lfe;
309  int predictor_history;
310  int header_crc;
311  int multirate_inter;
312  int version;
313  int copy_history;
314  int source_pcm_res;
315  int front_sum;
316  int surround_sum;
317  int dialog_norm;
318 
319  /* Primary audio coding header */
320  int subframes;
321  int total_channels;
322  int prim_channels;
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];
337  int bitalloc[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];
343  int dynrange_coef;
344 
345  int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
346 
347  float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];
348  int lfe_scale_factor;
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 
359  DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
360  float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
361  float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
362  uint8_t *extra_channels_buffer;
363  unsigned int extra_channels_buffer_size;
364 
365  uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
366  int dca_buffer_size;
367 
368  const int8_t *channel_order_tab;
369  GetBitContext gb;
370  /* Current position in DCA frame */
371  int current_subframe;
372  int current_subsubframe;
373 
374  int core_ext_mask;
375 
376  /* XCh extension information */
377  int xch_present;
378  int xch_base_channel;
379 
380  /* ExSS header parser */
381  int static_fields;
382  int mix_metadata;
383  int num_mix_configs;
384  int mix_config_num_ch[4];
385 
386  int profile;
387 
388  int debug_flag;
389  AVFloatDSPContext fdsp;
390  FFTContext imdct;
391  SynthFilterContext synth;
392  DCADSPContext dcadsp;
393  FmtConvertContext fmt_conv;
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,
421  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
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,
430  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
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,
439  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
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,
454  bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
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;
474  s->prim_channels = s->total_channels;
475 
476  if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
477  s->prim_channels = DCA_PRIM_CHANNELS_MAX;
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)
483  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)
488  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 
550 static int dca_parse_frame_header(DCAContext *s)
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);
566  s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
567  if (!s->sample_rate)
568  return AVERROR_INVALIDDATA;
569  s->bit_rate_index = get_bits(&s->gb, 5);
570  s->bit_rate = dca_bit_rates[s->bit_rate_index];
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  /* TODO: check CRC */
586  if (s->crc_present)
587  s->header_crc = get_bits(&s->gb, 16);
588 
589  s->multirate_inter = get_bits(&s->gb, 1);
590  s->version = get_bits(&s->gb, 4);
591  s->copy_history = get_bits(&s->gb, 2);
592  s->source_pcm_res = get_bits(&s->gb, 3);
593  s->front_sum = get_bits(&s->gb, 1);
594  s->surround_sum = get_bits(&s->gb, 1);
595  s->dialog_norm = get_bits(&s->gb, 4);
596 
597  /* FIXME: channels mixing levels */
598  s->output = s->amode;
599  if (s->lfe)
600  s->output |= DCA_LFE;
601 
602 #ifdef TRACE
603  av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
604  av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
605  av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
606  av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
607  s->sample_blocks, s->sample_blocks * 32);
608  av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
609  av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
610  s->amode, dca_channels[s->amode]);
611  av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
612  s->sample_rate);
613  av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
614  s->bit_rate);
615  av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
616  av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
617  av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
618  av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
619  av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
620  av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
621  av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
622  av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
623  av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
624  av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
625  s->predictor_history);
626  av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
627  av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
628  s->multirate_inter);
629  av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
630  av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
631  av_log(s->avctx, AV_LOG_DEBUG,
632  "source pcm resolution: %i (%i bits/sample)\n",
633  s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
634  av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
635  av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
636  av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
637  av_log(s->avctx, AV_LOG_DEBUG, "\n");
638 #endif
639 
640  /* Primary audio coding header */
641  s->subframes = get_bits(&s->gb, 4) + 1;
642 
643  return dca_parse_audio_coding_header(s, 0);
644 }
645 
646 
647 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
648 {
649  if (level < 5) {
650  /* huffman encoded */
651  value += get_bitalloc(gb, &dca_scalefactor, level);
652  value = av_clip(value, 0, (1 << log2range) - 1);
653  } else if (level < 8) {
654  if (level + 1 > log2range) {
655  skip_bits(gb, level + 1 - log2range);
656  value = get_bits(gb, log2range);
657  } else {
658  value = get_bits(gb, level + 1);
659  }
660  }
661  return value;
662 }
663 
664 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
665 {
666  /* Primary audio coding side information */
667  int j, k;
668 
669  if (get_bits_left(&s->gb) < 0)
670  return AVERROR_INVALIDDATA;
671 
672  if (!base_channel) {
673  s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
674  s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
675  }
676 
677  for (j = base_channel; j < s->prim_channels; j++) {
678  for (k = 0; k < s->subband_activity[j]; k++)
679  s->prediction_mode[j][k] = get_bits(&s->gb, 1);
680  }
681 
682  /* Get prediction codebook */
683  for (j = base_channel; j < s->prim_channels; j++) {
684  for (k = 0; k < s->subband_activity[j]; k++) {
685  if (s->prediction_mode[j][k] > 0) {
686  /* (Prediction coefficient VQ address) */
687  s->prediction_vq[j][k] = get_bits(&s->gb, 12);
688  }
689  }
690  }
691 
692  /* Bit allocation index */
693  for (j = base_channel; j < s->prim_channels; j++) {
694  for (k = 0; k < s->vq_start_subband[j]; k++) {
695  if (s->bitalloc_huffman[j] == 6)
696  s->bitalloc[j][k] = get_bits(&s->gb, 5);
697  else if (s->bitalloc_huffman[j] == 5)
698  s->bitalloc[j][k] = get_bits(&s->gb, 4);
699  else if (s->bitalloc_huffman[j] == 7) {
700  av_log(s->avctx, AV_LOG_ERROR,
701  "Invalid bit allocation index\n");
702  return AVERROR_INVALIDDATA;
703  } else {
704  s->bitalloc[j][k] =
705  get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
706  }
707 
708  if (s->bitalloc[j][k] > 26) {
709  av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
710  j, k, s->bitalloc[j][k]);
711  return AVERROR_INVALIDDATA;
712  }
713  }
714  }
715 
716  /* Transition mode */
717  for (j = base_channel; j < s->prim_channels; j++) {
718  for (k = 0; k < s->subband_activity[j]; k++) {
719  s->transition_mode[j][k] = 0;
720  if (s->subsubframes[s->current_subframe] > 1 &&
721  k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
722  s->transition_mode[j][k] =
723  get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
724  }
725  }
726  }
727 
728  if (get_bits_left(&s->gb) < 0)
729  return AVERROR_INVALIDDATA;
730 
731  for (j = base_channel; j < s->prim_channels; j++) {
732  const uint32_t *scale_table;
733  int scale_sum, log_size;
734 
735  memset(s->scale_factor[j], 0,
736  s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
737 
738  if (s->scalefactor_huffman[j] == 6) {
739  scale_table = scale_factor_quant7;
740  log_size = 7;
741  } else {
742  scale_table = scale_factor_quant6;
743  log_size = 6;
744  }
745 
746  /* When huffman coded, only the difference is encoded */
747  scale_sum = 0;
748 
749  for (k = 0; k < s->subband_activity[j]; k++) {
750  if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
751  scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
752  s->scale_factor[j][k][0] = scale_table[scale_sum];
753  }
754 
755  if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
756  /* Get second scale factor */
757  scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
758  s->scale_factor[j][k][1] = scale_table[scale_sum];
759  }
760  }
761  }
762 
763  /* Joint subband scale factor codebook select */
764  for (j = base_channel; j < s->prim_channels; j++) {
765  /* Transmitted only if joint subband coding enabled */
766  if (s->joint_intensity[j] > 0)
767  s->joint_huff[j] = get_bits(&s->gb, 3);
768  }
769 
770  if (get_bits_left(&s->gb) < 0)
771  return AVERROR_INVALIDDATA;
772 
773  /* Scale factors for joint subband coding */
774  for (j = base_channel; j < s->prim_channels; j++) {
775  int source_channel;
776 
777  /* Transmitted only if joint subband coding enabled */
778  if (s->joint_intensity[j] > 0) {
779  int scale = 0;
780  source_channel = s->joint_intensity[j] - 1;
781 
782  /* When huffman coded, only the difference is encoded
783  * (is this valid as well for joint scales ???) */
784 
785  for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
786  scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
787  s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
788  }
789 
790  if (!(s->debug_flag & 0x02)) {
791  av_log(s->avctx, AV_LOG_DEBUG,
792  "Joint stereo coding not supported\n");
793  s->debug_flag |= 0x02;
794  }
795  }
796  }
797 
798  /* Stereo downmix coefficients */
799  if (!base_channel && s->prim_channels > 2) {
800  if (s->downmix) {
801  for (j = base_channel; j < s->prim_channels; j++) {
802  s->downmix_coef[j][0] = get_bits(&s->gb, 7);
803  s->downmix_coef[j][1] = get_bits(&s->gb, 7);
804  }
805  } else {
806  int am = s->amode & DCA_CHANNEL_MASK;
807  if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
808  av_log(s->avctx, AV_LOG_ERROR,
809  "Invalid channel mode %d\n", am);
810  return AVERROR_INVALIDDATA;
811  }
812  for (j = base_channel; j < s->prim_channels; j++) {
813  s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
814  s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
815  }
816  }
817  }
818 
819  /* Dynamic range coefficient */
820  if (!base_channel && s->dynrange)
821  s->dynrange_coef = get_bits(&s->gb, 8);
822 
823  /* Side information CRC check word */
824  if (s->crc_present) {
825  get_bits(&s->gb, 16);
826  }
827 
828  /*
829  * Primary audio data arrays
830  */
831 
832  /* VQ encoded high frequency subbands */
833  for (j = base_channel; j < s->prim_channels; j++)
834  for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
835  /* 1 vector -> 32 samples */
836  s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
837 
838  /* Low frequency effect data */
839  if (!base_channel && s->lfe) {
840  /* LFE samples */
841  int lfe_samples = 2 * s->lfe * (4 + block_index);
842  int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
843  float lfe_scale;
844 
845  for (j = lfe_samples; j < lfe_end_sample; j++) {
846  /* Signed 8 bits int */
847  s->lfe_data[j] = get_sbits(&s->gb, 8);
848  }
849 
850  /* Scale factor index */
851  skip_bits(&s->gb, 1);
852  s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
853 
854  /* Quantization step size * scale factor */
855  lfe_scale = 0.035 * s->lfe_scale_factor;
856 
857  for (j = lfe_samples; j < lfe_end_sample; j++)
858  s->lfe_data[j] *= lfe_scale;
859  }
860 
861 #ifdef TRACE
862  av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
863  s->subsubframes[s->current_subframe]);
864  av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
865  s->partial_samples[s->current_subframe]);
866 
867  for (j = base_channel; j < s->prim_channels; j++) {
868  av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
869  for (k = 0; k < s->subband_activity[j]; k++)
870  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
871  av_log(s->avctx, AV_LOG_DEBUG, "\n");
872  }
873  for (j = base_channel; j < s->prim_channels; j++) {
874  for (k = 0; k < s->subband_activity[j]; k++)
875  av_log(s->avctx, AV_LOG_DEBUG,
876  "prediction coefs: %f, %f, %f, %f\n",
877  (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
878  (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
879  (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
880  (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
881  }
882  for (j = base_channel; j < s->prim_channels; j++) {
883  av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
884  for (k = 0; k < s->vq_start_subband[j]; k++)
885  av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
886  av_log(s->avctx, AV_LOG_DEBUG, "\n");
887  }
888  for (j = base_channel; j < s->prim_channels; j++) {
889  av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
890  for (k = 0; k < s->subband_activity[j]; k++)
891  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
892  av_log(s->avctx, AV_LOG_DEBUG, "\n");
893  }
894  for (j = base_channel; j < s->prim_channels; j++) {
895  av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
896  for (k = 0; k < s->subband_activity[j]; k++) {
897  if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
898  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
899  if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
900  av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
901  }
902  av_log(s->avctx, AV_LOG_DEBUG, "\n");
903  }
904  for (j = base_channel; j < s->prim_channels; j++) {
905  if (s->joint_intensity[j] > 0) {
906  int source_channel = s->joint_intensity[j] - 1;
907  av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
908  for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
909  av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
910  av_log(s->avctx, AV_LOG_DEBUG, "\n");
911  }
912  }
913  if (!base_channel && s->prim_channels > 2 && s->downmix) {
914  av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
915  for (j = 0; j < s->prim_channels; j++) {
916  av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
917  dca_downmix_coeffs[s->downmix_coef[j][0]]);
918  av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
919  dca_downmix_coeffs[s->downmix_coef[j][1]]);
920  }
921  av_log(s->avctx, AV_LOG_DEBUG, "\n");
922  }
923  for (j = base_channel; j < s->prim_channels; j++)
924  for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
925  av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
926  if (!base_channel && s->lfe) {
927  int lfe_samples = 2 * s->lfe * (4 + block_index);
928  int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
929 
930  av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
931  for (j = lfe_samples; j < lfe_end_sample; j++)
932  av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
933  av_log(s->avctx, AV_LOG_DEBUG, "\n");
934  }
935 #endif
936 
937  return 0;
938 }
939 
940 static void qmf_32_subbands(DCAContext *s, int chans,
941  float samples_in[32][8], float *samples_out,
942  float scale)
943 {
944  const float *prCoeff;
945  int i;
946 
947  int sb_act = s->subband_activity[chans];
948  int subindex;
949 
950  scale *= sqrt(1 / 8.0);
951 
952  /* Select filter */
953  if (!s->multirate_inter) /* Non-perfect reconstruction */
954  prCoeff = fir_32bands_nonperfect;
955  else /* Perfect reconstruction */
956  prCoeff = fir_32bands_perfect;
957 
958  for (i = sb_act; i < 32; i++)
959  s->raXin[i] = 0.0;
960 
961  /* Reconstructed channel sample index */
962  for (subindex = 0; subindex < 8; subindex++) {
963  /* Load in one sample from each subband and clear inactive subbands */
964  for (i = 0; i < sb_act; i++) {
965  unsigned sign = (i - 1) & 2;
966  uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
967  AV_WN32A(&s->raXin[i], v);
968  }
969 
970  s->synth.synth_filter_float(&s->imdct,
971  s->subband_fir_hist[chans],
972  &s->hist_index[chans],
973  s->subband_fir_noidea[chans], prCoeff,
974  samples_out, s->raXin, scale);
975  samples_out += 32;
976  }
977 }
978 
979 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
980  int num_deci_sample, float *samples_in,
981  float *samples_out, float scale)
982 {
983  /* samples_in: An array holding decimated samples.
984  * Samples in current subframe starts from samples_in[0],
985  * while samples_in[-1], samples_in[-2], ..., stores samples
986  * from last subframe as history.
987  *
988  * samples_out: An array holding interpolated samples
989  */
990 
991  int decifactor;
992  const float *prCoeff;
993  int deciindex;
994 
995  /* Select decimation filter */
996  if (decimation_select == 1) {
997  decifactor = 64;
998  prCoeff = lfe_fir_128;
999  } else {
1000  decifactor = 32;
1001  prCoeff = lfe_fir_64;
1002  }
1003  /* Interpolation */
1004  for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1005  s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1006  samples_in++;
1007  samples_out += 2 * decifactor;
1008  }
1009 }
1010 
1011 /* downmixing routines */
1012 #define MIX_REAR1(samples, s1, rs, coef) \
1013  samples[0][i] += samples[s1][i] * coef[rs][0]; \
1014  samples[1][i] += samples[s1][i] * coef[rs][1];
1015 
1016 #define MIX_REAR2(samples, s1, s2, rs, coef) \
1017  samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
1018  samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
1019 
1020 #define MIX_FRONT3(samples, coef) \
1021  t = samples[c][i]; \
1022  u = samples[l][i]; \
1023  v = samples[r][i]; \
1024  samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1025  samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1026 
1027 #define DOWNMIX_TO_STEREO(op1, op2) \
1028  for (i = 0; i < 256; i++) { \
1029  op1 \
1030  op2 \
1031  }
1032 
1033 static void dca_downmix(float **samples, int srcfmt,
1034  int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1035  const int8_t *channel_mapping)
1036 {
1037  int c, l, r, sl, sr, s;
1038  int i;
1039  float t, u, v;
1040  float coef[DCA_PRIM_CHANNELS_MAX][2];
1041 
1042  for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1043  coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1044  coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1045  }
1046 
1047  switch (srcfmt) {
1048  case DCA_MONO:
1049  case DCA_CHANNEL:
1050  case DCA_STEREO_TOTAL:
1051  case DCA_STEREO_SUMDIFF:
1052  case DCA_4F2R:
1053  av_log(NULL, 0, "Not implemented!\n");
1054  break;
1055  case DCA_STEREO:
1056  break;
1057  case DCA_3F:
1058  c = channel_mapping[0];
1059  l = channel_mapping[1];
1060  r = channel_mapping[2];
1061  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1062  break;
1063  case DCA_2F1R:
1064  s = channel_mapping[2];
1065  DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1066  break;
1067  case DCA_3F1R:
1068  c = channel_mapping[0];
1069  l = channel_mapping[1];
1070  r = channel_mapping[2];
1071  s = channel_mapping[3];
1072  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1073  MIX_REAR1(samples, s, 3, coef));
1074  break;
1075  case DCA_2F2R:
1076  sl = channel_mapping[2];
1077  sr = channel_mapping[3];
1078  DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1079  break;
1080  case DCA_3F2R:
1081  c = channel_mapping[0];
1082  l = channel_mapping[1];
1083  r = channel_mapping[2];
1084  sl = channel_mapping[3];
1085  sr = channel_mapping[4];
1086  DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1087  MIX_REAR2(samples, sl, sr, 3, coef));
1088  break;
1089  }
1090 }
1091 
1092 
1093 #ifndef decode_blockcodes
1094 /* Very compact version of the block code decoder that does not use table
1095  * look-up but is slightly slower */
1096 static int decode_blockcode(int code, int levels, int *values)
1097 {
1098  int i;
1099  int offset = (levels - 1) >> 1;
1100 
1101  for (i = 0; i < 4; i++) {
1102  int div = FASTDIV(code, levels);
1103  values[i] = code - offset - div * levels;
1104  code = div;
1105  }
1106 
1107  return code;
1108 }
1109 
1110 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1111 {
1112  return decode_blockcode(code1, levels, values) |
1113  decode_blockcode(code2, levels, values + 4);
1114 }
1115 #endif
1116 
1117 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1118 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1119 
1120 #ifndef int8x8_fmul_int32
1121 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1122 {
1123  float fscale = scale / 16.0;
1124  int i;
1125  for (i = 0; i < 8; i++)
1126  dst[i] = src[i] * fscale;
1127 }
1128 #endif
1129 
1130 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1131 {
1132  int k, l;
1133  int subsubframe = s->current_subsubframe;
1134 
1135  const float *quant_step_table;
1136 
1137  /* FIXME */
1138  float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1139  LOCAL_ALIGNED_16(int, block, [8]);
1140 
1141  /*
1142  * Audio data
1143  */
1144 
1145  /* Select quantization step size table */
1146  if (s->bit_rate_index == 0x1f)
1147  quant_step_table = lossless_quant_d;
1148  else
1149  quant_step_table = lossy_quant_d;
1150 
1151  for (k = base_channel; k < s->prim_channels; k++) {
1152  if (get_bits_left(&s->gb) < 0)
1153  return AVERROR_INVALIDDATA;
1154 
1155  for (l = 0; l < s->vq_start_subband[k]; l++) {
1156  int m;
1157 
1158  /* Select the mid-tread linear quantizer */
1159  int abits = s->bitalloc[k][l];
1160 
1161  float quant_step_size = quant_step_table[abits];
1162 
1163  /*
1164  * Determine quantization index code book and its type
1165  */
1166 
1167  /* Select quantization index code book */
1168  int sel = s->quant_index_huffman[k][abits];
1169 
1170  /*
1171  * Extract bits from the bit stream
1172  */
1173  if (!abits) {
1174  memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1175  } else {
1176  /* Deal with transients */
1177  int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1178  float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1179  s->scalefactor_adj[k][sel];
1180 
1181  if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1182  if (abits <= 7) {
1183  /* Block code */
1184  int block_code1, block_code2, size, levels, err;
1185 
1186  size = abits_sizes[abits - 1];
1187  levels = abits_levels[abits - 1];
1188 
1189  block_code1 = get_bits(&s->gb, size);
1190  block_code2 = get_bits(&s->gb, size);
1191  err = decode_blockcodes(block_code1, block_code2,
1192  levels, block);
1193  if (err) {
1194  av_log(s->avctx, AV_LOG_ERROR,
1195  "ERROR: block code look-up failed\n");
1196  return AVERROR_INVALIDDATA;
1197  }
1198  } else {
1199  /* no coding */
1200  for (m = 0; m < 8; m++)
1201  block[m] = get_sbits(&s->gb, abits - 3);
1202  }
1203  } else {
1204  /* Huffman coded */
1205  for (m = 0; m < 8; m++)
1206  block[m] = get_bitalloc(&s->gb,
1207  &dca_smpl_bitalloc[abits], sel);
1208  }
1209 
1210  s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1211  block, rscale, 8);
1212  }
1213 
1214  /*
1215  * Inverse ADPCM if in prediction mode
1216  */
1217  if (s->prediction_mode[k][l]) {
1218  int n;
1219  for (m = 0; m < 8; m++) {
1220  for (n = 1; n <= 4; n++)
1221  if (m >= n)
1222  subband_samples[k][l][m] +=
1223  (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1224  subband_samples[k][l][m - n] / 8192);
1225  else if (s->predictor_history)
1226  subband_samples[k][l][m] +=
1227  (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1228  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1229  }
1230  }
1231  }
1232 
1233  /*
1234  * Decode VQ encoded high frequencies
1235  */
1236  for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1237  /* 1 vector -> 32 samples but we only need the 8 samples
1238  * for this subsubframe. */
1239  int hfvq = s->high_freq_vq[k][l];
1240 
1241  if (!s->debug_flag & 0x01) {
1242  av_log(s->avctx, AV_LOG_DEBUG,
1243  "Stream with high frequencies VQ coding\n");
1244  s->debug_flag |= 0x01;
1245  }
1246 
1247  int8x8_fmul_int32(subband_samples[k][l],
1248  &high_freq_vq[hfvq][subsubframe * 8],
1249  s->scale_factor[k][l][0]);
1250  }
1251  }
1252 
1253  /* Check for DSYNC after subsubframe */
1254  if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1255  if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1256 #ifdef TRACE
1257  av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1258 #endif
1259  } else {
1260  av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1261  }
1262  }
1263 
1264  /* Backup predictor history for adpcm */
1265  for (k = base_channel; k < s->prim_channels; k++)
1266  for (l = 0; l < s->vq_start_subband[k]; l++)
1267  memcpy(s->subband_samples_hist[k][l],
1268  &subband_samples[k][l][4],
1269  4 * sizeof(subband_samples[0][0][0]));
1270 
1271  return 0;
1272 }
1273 
1274 static int dca_filter_channels(DCAContext *s, int block_index)
1275 {
1276  float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1277  int k;
1278 
1279  /* 32 subbands QMF */
1280  for (k = 0; k < s->prim_channels; k++) {
1281 /* static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1282  0, 8388608.0, 8388608.0 };*/
1283  if (s->channel_order_tab[k] >= 0)
1284  qmf_32_subbands(s, k, subband_samples[k],
1285  s->samples_chanptr[s->channel_order_tab[k]],
1286  M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1287  }
1288 
1289  /* Down mixing */
1290  if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1291  dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);
1292  }
1293 
1294  /* Generate LFE samples for this subsubframe FIXME!!! */
1295  if (s->output & DCA_LFE) {
1296  lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1297  s->lfe_data + 2 * s->lfe * (block_index + 4),
1298  s->samples_chanptr[dca_lfe_index[s->amode]],
1299  1.0 / (256.0 * 32768.0));
1300  /* Outputs 20bits pcm samples */
1301  }
1302 
1303  return 0;
1304 }
1305 
1306 
1307 static int dca_subframe_footer(DCAContext *s, int base_channel)
1308 {
1309  int aux_data_count = 0, i;
1310 
1311  /*
1312  * Unpack optional information
1313  */
1314 
1315  /* presumably optional information only appears in the core? */
1316  if (!base_channel) {
1317  if (s->timestamp)
1318  skip_bits_long(&s->gb, 32);
1319 
1320  if (s->aux_data)
1321  aux_data_count = get_bits(&s->gb, 6);
1322 
1323  for (i = 0; i < aux_data_count; i++)
1324  get_bits(&s->gb, 8);
1325 
1326  if (s->crc_present && (s->downmix || s->dynrange))
1327  get_bits(&s->gb, 16);
1328  }
1329 
1330  return 0;
1331 }
1332 
1339 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1340 {
1341  int ret;
1342 
1343  /* Sanity check */
1344  if (s->current_subframe >= s->subframes) {
1345  av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1346  s->current_subframe, s->subframes);
1347  return AVERROR_INVALIDDATA;
1348  }
1349 
1350  if (!s->current_subsubframe) {
1351 #ifdef TRACE
1352  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1353 #endif
1354  /* Read subframe header */
1355  if ((ret = dca_subframe_header(s, base_channel, block_index)))
1356  return ret;
1357  }
1358 
1359  /* Read subsubframe */
1360 #ifdef TRACE
1361  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1362 #endif
1363  if ((ret = dca_subsubframe(s, base_channel, block_index)))
1364  return ret;
1365 
1366  /* Update state */
1367  s->current_subsubframe++;
1368  if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1369  s->current_subsubframe = 0;
1370  s->current_subframe++;
1371  }
1372  if (s->current_subframe >= s->subframes) {
1373 #ifdef TRACE
1374  av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1375 #endif
1376  /* Read subframe footer */
1377  if ((ret = dca_subframe_footer(s, base_channel)))
1378  return ret;
1379  }
1380 
1381  return 0;
1382 }
1383 
1387 static int dca_exss_mask2count(int mask)
1388 {
1389  /* count bits that mean speaker pairs twice */
1390  return av_popcount(mask) +
1391  av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
1392  DCA_EXSS_FRONT_LEFT_RIGHT |
1393  DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
1394  DCA_EXSS_WIDE_LEFT_RIGHT |
1395  DCA_EXSS_SIDE_LEFT_RIGHT |
1396  DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
1397  DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
1398  DCA_EXSS_REAR_LEFT_RIGHT |
1399  DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1400 }
1401 
1405 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1406 {
1407  int i;
1408 
1409  for (i = 0; i < channels; i++) {
1410  int mix_map_mask = get_bits(gb, out_ch);
1411  int num_coeffs = av_popcount(mix_map_mask);
1412  skip_bits_long(gb, num_coeffs * 6);
1413  }
1414 }
1415 
1419 static int dca_exss_parse_asset_header(DCAContext *s)
1420 {
1421  int header_pos = get_bits_count(&s->gb);
1422  int header_size;
1423  int channels;
1424  int embedded_stereo = 0;
1425  int embedded_6ch = 0;
1426  int drc_code_present;
1427  int extensions_mask;
1428  int i, j;
1429 
1430  if (get_bits_left(&s->gb) < 16)
1431  return -1;
1432 
1433  /* We will parse just enough to get to the extensions bitmask with which
1434  * we can set the profile value. */
1435 
1436  header_size = get_bits(&s->gb, 9) + 1;
1437  skip_bits(&s->gb, 3); // asset index
1438 
1439  if (s->static_fields) {
1440  if (get_bits1(&s->gb))
1441  skip_bits(&s->gb, 4); // asset type descriptor
1442  if (get_bits1(&s->gb))
1443  skip_bits_long(&s->gb, 24); // language descriptor
1444 
1445  if (get_bits1(&s->gb)) {
1446  /* How can one fit 1024 bytes of text here if the maximum value
1447  * for the asset header size field above was 512 bytes? */
1448  int text_length = get_bits(&s->gb, 10) + 1;
1449  if (get_bits_left(&s->gb) < text_length * 8)
1450  return -1;
1451  skip_bits_long(&s->gb, text_length * 8); // info text
1452  }
1453 
1454  skip_bits(&s->gb, 5); // bit resolution - 1
1455  skip_bits(&s->gb, 4); // max sample rate code
1456  channels = get_bits(&s->gb, 8) + 1;
1457 
1458  if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1459  int spkr_remap_sets;
1460  int spkr_mask_size = 16;
1461  int num_spkrs[7];
1462 
1463  if (channels > 2)
1464  embedded_stereo = get_bits1(&s->gb);
1465  if (channels > 6)
1466  embedded_6ch = get_bits1(&s->gb);
1467 
1468  if (get_bits1(&s->gb)) {
1469  spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1470  skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1471  }
1472 
1473  spkr_remap_sets = get_bits(&s->gb, 3);
1474 
1475  for (i = 0; i < spkr_remap_sets; i++) {
1476  /* std layout mask for each remap set */
1477  num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1478  }
1479 
1480  for (i = 0; i < spkr_remap_sets; i++) {
1481  int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1482  if (get_bits_left(&s->gb) < 0)
1483  return -1;
1484 
1485  for (j = 0; j < num_spkrs[i]; j++) {
1486  int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1487  int num_dec_ch = av_popcount(remap_dec_ch_mask);
1488  skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1489  }
1490  }
1491 
1492  } else {
1493  skip_bits(&s->gb, 3); // representation type
1494  }
1495  }
1496 
1497  drc_code_present = get_bits1(&s->gb);
1498  if (drc_code_present)
1499  get_bits(&s->gb, 8); // drc code
1500 
1501  if (get_bits1(&s->gb))
1502  skip_bits(&s->gb, 5); // dialog normalization code
1503 
1504  if (drc_code_present && embedded_stereo)
1505  get_bits(&s->gb, 8); // drc stereo code
1506 
1507  if (s->mix_metadata && get_bits1(&s->gb)) {
1508  skip_bits(&s->gb, 1); // external mix
1509  skip_bits(&s->gb, 6); // post mix gain code
1510 
1511  if (get_bits(&s->gb, 2) != 3) // mixer drc code
1512  skip_bits(&s->gb, 3); // drc limit
1513  else
1514  skip_bits(&s->gb, 8); // custom drc code
1515 
1516  if (get_bits1(&s->gb)) // channel specific scaling
1517  for (i = 0; i < s->num_mix_configs; i++)
1518  skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1519  else
1520  skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1521 
1522  for (i = 0; i < s->num_mix_configs; i++) {
1523  if (get_bits_left(&s->gb) < 0)
1524  return -1;
1525  dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1526  if (embedded_6ch)
1527  dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1528  if (embedded_stereo)
1529  dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1530  }
1531  }
1532 
1533  switch (get_bits(&s->gb, 2)) {
1534  case 0: extensions_mask = get_bits(&s->gb, 12); break;
1535  case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
1536  case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
1537  case 3: extensions_mask = 0; /* aux coding */ break;
1538  }
1539 
1540  /* not parsed further, we were only interested in the extensions mask */
1541 
1542  if (get_bits_left(&s->gb) < 0)
1543  return -1;
1544 
1545  if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1546  av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1547  return -1;
1548  }
1549  skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1550 
1551  if (extensions_mask & DCA_EXT_EXSS_XLL)
1552  s->profile = FF_PROFILE_DTS_HD_MA;
1553  else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1554  DCA_EXT_EXSS_XXCH))
1555  s->profile = FF_PROFILE_DTS_HD_HRA;
1556 
1557  if (!(extensions_mask & DCA_EXT_CORE))
1558  av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1559  if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1560  av_log(s->avctx, AV_LOG_WARNING,
1561  "DTS extensions detection mismatch (%d, %d)\n",
1562  extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1563 
1564  return 0;
1565 }
1566 
1570 static void dca_exss_parse_header(DCAContext *s)
1571 {
1572  int ss_index;
1573  int blownup;
1574  int num_audiop = 1;
1575  int num_assets = 1;
1576  int active_ss_mask[8];
1577  int i, j;
1578 
1579  if (get_bits_left(&s->gb) < 52)
1580  return;
1581 
1582  skip_bits(&s->gb, 8); // user data
1583  ss_index = get_bits(&s->gb, 2);
1584 
1585  blownup = get_bits1(&s->gb);
1586  skip_bits(&s->gb, 8 + 4 * blownup); // header_size
1587  skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1588 
1589  s->static_fields = get_bits1(&s->gb);
1590  if (s->static_fields) {
1591  skip_bits(&s->gb, 2); // reference clock code
1592  skip_bits(&s->gb, 3); // frame duration code
1593 
1594  if (get_bits1(&s->gb))
1595  skip_bits_long(&s->gb, 36); // timestamp
1596 
1597  /* a single stream can contain multiple audio assets that can be
1598  * combined to form multiple audio presentations */
1599 
1600  num_audiop = get_bits(&s->gb, 3) + 1;
1601  if (num_audiop > 1) {
1602  av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1603  /* ignore such streams for now */
1604  return;
1605  }
1606 
1607  num_assets = get_bits(&s->gb, 3) + 1;
1608  if (num_assets > 1) {
1609  av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1610  /* ignore such streams for now */
1611  return;
1612  }
1613 
1614  for (i = 0; i < num_audiop; i++)
1615  active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1616 
1617  for (i = 0; i < num_audiop; i++)
1618  for (j = 0; j <= ss_index; j++)
1619  if (active_ss_mask[i] & (1 << j))
1620  skip_bits(&s->gb, 8); // active asset mask
1621 
1622  s->mix_metadata = get_bits1(&s->gb);
1623  if (s->mix_metadata) {
1624  int mix_out_mask_size;
1625 
1626  skip_bits(&s->gb, 2); // adjustment level
1627  mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1628  s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1629 
1630  for (i = 0; i < s->num_mix_configs; i++) {
1631  int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1632  s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1633  }
1634  }
1635  }
1636 
1637  for (i = 0; i < num_assets; i++)
1638  skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1639 
1640  for (i = 0; i < num_assets; i++) {
1641  if (dca_exss_parse_asset_header(s))
1642  return;
1643  }
1644 
1645  /* not parsed further, we were only interested in the extensions mask
1646  * from the asset header */
1647 }
1648 
1653 static int dca_decode_frame(AVCodecContext *avctx, void *data,
1654  int *got_frame_ptr, AVPacket *avpkt)
1655 {
1656  const uint8_t *buf = avpkt->data;
1657  int buf_size = avpkt->size;
1658 
1659  int lfe_samples;
1660  int num_core_channels = 0;
1661  int i, ret;
1662  float **samples_flt;
1663  DCAContext *s = avctx->priv_data;
1664  int channels, full_channels;
1665  int core_ss_end;
1666 
1667 
1668  s->xch_present = 0;
1669 
1670  s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1671  DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1672  if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
1673  av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1674  return AVERROR_INVALIDDATA;
1675  }
1676 
1677  init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1678  if ((ret = dca_parse_frame_header(s)) < 0) {
1679  //seems like the frame is corrupt, try with the next one
1680  return ret;
1681  }
1682  //set AVCodec values with parsed data
1683  avctx->sample_rate = s->sample_rate;
1684  avctx->bit_rate = s->bit_rate;
1685 
1686  s->profile = FF_PROFILE_DTS;
1687 
1688  for (i = 0; i < (s->sample_blocks / 8); i++) {
1689  if ((ret = dca_decode_block(s, 0, i))) {
1690  av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
1691  return ret;
1692  }
1693  }
1694 
1695  /* record number of core channels incase less than max channels are requested */
1696  num_core_channels = s->prim_channels;
1697 
1698  if (s->ext_coding)
1699  s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
1700  else
1701  s->core_ext_mask = 0;
1702 
1703  core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1704 
1705  /* only scan for extensions if ext_descr was unknown or indicated a
1706  * supported XCh extension */
1707  if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
1708 
1709  /* if ext_descr was unknown, clear s->core_ext_mask so that the
1710  * extensions scan can fill it up */
1711  s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
1712 
1713  /* extensions start at 32-bit boundaries into bitstream */
1714  skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1715 
1716  while (core_ss_end - get_bits_count(&s->gb) >= 32) {
1717  uint32_t bits = get_bits_long(&s->gb, 32);
1718 
1719  switch (bits) {
1720  case 0x5a5a5a5a: {
1721  int ext_amode, xch_fsize;
1722 
1723  s->xch_base_channel = s->prim_channels;
1724 
1725  /* validate sync word using XCHFSIZE field */
1726  xch_fsize = show_bits(&s->gb, 10);
1727  if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1728  (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1729  continue;
1730 
1731  /* skip length-to-end-of-frame field for the moment */
1732  skip_bits(&s->gb, 10);
1733 
1734  s->core_ext_mask |= DCA_EXT_XCH;
1735 
1736  /* extension amode(number of channels in extension) should be 1 */
1737  /* AFAIK XCh is not used for more channels */
1738  if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1739  av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1740  " supported!\n", ext_amode);
1741  continue;
1742  }
1743 
1744  /* much like core primary audio coding header */
1745  dca_parse_audio_coding_header(s, s->xch_base_channel);
1746 
1747  for (i = 0; i < (s->sample_blocks / 8); i++)
1748  if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
1749  av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
1750  continue;
1751  }
1752 
1753  s->xch_present = 1;
1754  break;
1755  }
1756  case 0x47004a03:
1757  /* XXCh: extended channels */
1758  /* usually found either in core or HD part in DTS-HD HRA streams,
1759  * but not in DTS-ES which contains XCh extensions instead */
1760  s->core_ext_mask |= DCA_EXT_XXCH;
1761  break;
1762 
1763  case 0x1d95f262: {
1764  int fsize96 = show_bits(&s->gb, 12) + 1;
1765  if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1766  continue;
1767 
1768  av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
1769  get_bits_count(&s->gb));
1770  skip_bits(&s->gb, 12);
1771  av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1772  av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1773 
1774  s->core_ext_mask |= DCA_EXT_X96;
1775  break;
1776  }
1777  }
1778 
1779  skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1780  }
1781  } else {
1782  /* no supported extensions, skip the rest of the core substream */
1783  skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
1784  }
1785 
1786  if (s->core_ext_mask & DCA_EXT_X96)
1787  s->profile = FF_PROFILE_DTS_96_24;
1788  else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
1789  s->profile = FF_PROFILE_DTS_ES;
1790 
1791  /* check for ExSS (HD part) */
1792  if (s->dca_buffer_size - s->frame_size > 32 &&
1793  get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1794  dca_exss_parse_header(s);
1795 
1796  avctx->profile = s->profile;
1797 
1798  full_channels = channels = s->prim_channels + !!s->lfe;
1799 
1800  if (s->amode < 16) {
1801  avctx->channel_layout = dca_core_channel_layout[s->amode];
1802 
1803  if (s->xch_present && (!avctx->request_channels ||
1804  avctx->request_channels > num_core_channels + !!s->lfe)) {
1805  avctx->channel_layout |= AV_CH_BACK_CENTER;
1806  if (s->lfe) {
1807  avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1808  s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1809  } else {
1810  s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1811  }
1812  } else {
1813  channels = num_core_channels + !!s->lfe;
1814  s->xch_present = 0; /* disable further xch processing */
1815  if (s->lfe) {
1816  avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1817  s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1818  } else
1819  s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1820  }
1821 
1822  if (channels > !!s->lfe &&
1823  s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1824  return AVERROR_INVALIDDATA;
1825 
1826  if (avctx->request_channels == 2 && s->prim_channels > 2) {
1827  channels = 2;
1828  s->output = DCA_STEREO;
1829  avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1830  }
1831  } else {
1832  av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
1833  return AVERROR_INVALIDDATA;
1834  }
1835  avctx->channels = channels;
1836 
1837  /* get output buffer */
1838  s->frame.nb_samples = 256 * (s->sample_blocks / 8);
1839  if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
1840  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1841  return ret;
1842  }
1843  samples_flt = (float **) s->frame.extended_data;
1844 
1845  /* allocate buffer for extra channels if downmixing */
1846  if (avctx->channels < full_channels) {
1847  ret = av_samples_get_buffer_size(NULL, full_channels - channels,
1848  s->frame.nb_samples,
1849  avctx->sample_fmt, 0);
1850  if (ret < 0)
1851  return ret;
1852 
1853  av_fast_malloc(&s->extra_channels_buffer,
1854  &s->extra_channels_buffer_size, ret);
1855  if (!s->extra_channels_buffer)
1856  return AVERROR(ENOMEM);
1857 
1858  ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
1859  s->extra_channels_buffer,
1860  full_channels - channels,
1861  s->frame.nb_samples, avctx->sample_fmt, 0);
1862  if (ret < 0)
1863  return ret;
1864  }
1865 
1866  /* filter to get final output */
1867  for (i = 0; i < (s->sample_blocks / 8); i++) {
1868  int ch;
1869 
1870  for (ch = 0; ch < channels; ch++)
1871  s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
1872  for (; ch < full_channels; ch++)
1873  s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
1874 
1875  dca_filter_channels(s, i);
1876 
1877  /* If this was marked as a DTS-ES stream we need to subtract back- */
1878  /* channel from SL & SR to remove matrixed back-channel signal */
1879  if ((s->source_pcm_res & 1) && s->xch_present) {
1880  float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
1881  float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
1882  float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
1883  s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
1884  s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
1885  }
1886  }
1887 
1888  /* update lfe history */
1889  lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1890  for (i = 0; i < 2 * s->lfe * 4; i++)
1891  s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1892 
1893  *got_frame_ptr = 1;
1894  *(AVFrame *) data = s->frame;
1895 
1896  return buf_size;
1897 }
1898 
1899 
1900 
1907 static av_cold int dca_decode_init(AVCodecContext *avctx)
1908 {
1909  DCAContext *s = avctx->priv_data;
1910 
1911  s->avctx = avctx;
1912  dca_init_vlcs();
1913 
1914  avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
1915  ff_mdct_init(&s->imdct, 6, 1, 1.0);
1916  ff_synth_filter_init(&s->synth);
1917  ff_dcadsp_init(&s->dcadsp);
1918  ff_fmt_convert_init(&s->fmt_conv, avctx);
1919 
1920  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1921 
1922  /* allow downmixing to stereo */
1923  if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1924  avctx->request_channels == 2) {
1925  avctx->channels = avctx->request_channels;
1926  }
1927 
1928  avcodec_get_frame_defaults(&s->frame);
1929  avctx->coded_frame = &s->frame;
1930 
1931  return 0;
1932 }
1933 
1934 static av_cold int dca_decode_end(AVCodecContext *avctx)
1935 {
1936  DCAContext *s = avctx->priv_data;
1937  ff_mdct_end(&s->imdct);
1938  av_freep(&s->extra_channels_buffer);
1939  return 0;
1940 }
1941 
1942 static const AVProfile profiles[] = {
1943  { FF_PROFILE_DTS, "DTS" },
1944  { FF_PROFILE_DTS_ES, "DTS-ES" },
1945  { FF_PROFILE_DTS_96_24, "DTS 96/24" },
1946  { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1947  { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
1948  { FF_PROFILE_UNKNOWN },
1949 };
1950 
1951 AVCodec ff_dca_decoder = {
1952  .name = "dca",
1953  .type = AVMEDIA_TYPE_AUDIO,
1954  .id = AV_CODEC_ID_DTS,
1955  .priv_data_size = sizeof(DCAContext),
1956  .init = dca_decode_init,
1957  .decode = dca_decode_frame,
1958  .close = dca_decode_end,
1959  .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1960  .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
1961  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1962  AV_SAMPLE_FMT_NONE },
1963  .profiles = NULL_IF_CONFIG_SMALL(profiles),
1964 };