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