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