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