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