dca: map xxch side channels to AV_CH_SIDE_LEFT/RIGHT instead of REAR.
[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/float_dsp.h"
31 #include "libavutil/intmath.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/audioconvert.h"
35 #include "avcodec.h"
36 #include "dsputil.h"
37 #include "fft.h"
38 #include "get_bits.h"
39 #include "put_bits.h"
40 #include "dcadata.h"
41 #include "dcahuff.h"
42 #include "dca.h"
43 #include "dca_parser.h"
44 #include "synth_filter.h"
45 #include "dcadsp.h"
46 #include "fmtconvert.h"
47
48 #if ARCH_ARM
49 #   include "arm/dca.h"
50 #endif
51
52 //#define TRACE
53
54 #define DCA_PRIM_CHANNELS_MAX  (7)
55 #define DCA_SUBBANDS          (64)
56 #define DCA_ABITS_MAX         (32)      /* Should be 28 */
57 #define DCA_SUBSUBFRAMES_MAX   (4)
58 #define DCA_SUBFRAMES_MAX     (16)
59 #define DCA_BLOCKS_MAX        (16)
60 #define DCA_LFE_MAX            (3)
61 #define DCA_CHSETS_MAX         (4)
62 #define DCA_CHSET_CHANS_MAX    (8)
63
64 enum DCAMode {
65     DCA_MONO = 0,
66     DCA_CHANNEL,
67     DCA_STEREO,
68     DCA_STEREO_SUMDIFF,
69     DCA_STEREO_TOTAL,
70     DCA_3F,
71     DCA_2F1R,
72     DCA_3F1R,
73     DCA_2F2R,
74     DCA_3F2R,
75     DCA_4F2R
76 };
77
78 /* these are unconfirmed but should be mostly correct */
79 enum DCAExSSSpeakerMask {
80     DCA_EXSS_FRONT_CENTER          = 0x0001,
81     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
82     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
83     DCA_EXSS_LFE                   = 0x0008,
84     DCA_EXSS_REAR_CENTER           = 0x0010,
85     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
86     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
87     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
88     DCA_EXSS_OVERHEAD              = 0x0100,
89     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
90     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
91     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
92     DCA_EXSS_LFE2                  = 0x1000,
93     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
94     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
95     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
96 };
97
98 enum DCAXxchSpeakerMask {
99     DCA_XXCH_FRONT_CENTER          = 0x0000001,
100     DCA_XXCH_FRONT_LEFT            = 0x0000002,
101     DCA_XXCH_FRONT_RIGHT           = 0x0000004,
102     DCA_XXCH_SIDE_REAR_LEFT        = 0x0000008,
103     DCA_XXCH_SIDE_REAR_RIGHT       = 0x0000010,
104     DCA_XXCH_LFE1                  = 0x0000020,
105     DCA_XXCH_REAR_CENTER           = 0x0000040,
106     DCA_XXCH_SURROUND_REAR_LEFT    = 0x0000080,
107     DCA_XXCH_SURROUND_REAR_RIGHT   = 0x0000100,
108     DCA_XXCH_SIDE_SURROUND_LEFT    = 0x0000200,
109     DCA_XXCH_SIDE_SURROUND_RIGHT   = 0x0000400,
110     DCA_XXCH_FRONT_CENTER_LEFT     = 0x0000800,
111     DCA_XXCH_FRONT_CENTER_RIGHT    = 0x0001000,
112     DCA_XXCH_FRONT_HIGH_LEFT       = 0x0002000,
113     DCA_XXCH_FRONT_HIGH_CENTER     = 0x0004000,
114     DCA_XXCH_FRONT_HIGH_RIGHT      = 0x0008000,
115     DCA_XXCH_LFE2                  = 0x0010000,
116     DCA_XXCH_SIDE_FRONT_LEFT       = 0x0020000,
117     DCA_XXCH_SIDE_FRONT_RIGHT      = 0x0040000,
118     DCA_XXCH_OVERHEAD              = 0x0080000,
119     DCA_XXCH_SIDE_HIGH_LEFT        = 0x0100000,
120     DCA_XXCH_SIDE_HIGH_RIGHT       = 0x0200000,
121     DCA_XXCH_REAR_HIGH_CENTER      = 0x0400000,
122     DCA_XXCH_REAR_HIGH_LEFT        = 0x0800000,
123     DCA_XXCH_REAR_HIGH_RIGHT       = 0x1000000,
124     DCA_XXCH_REAR_LOW_CENTER       = 0x2000000,
125     DCA_XXCH_REAR_LOW_LEFT         = 0x4000000,
126     DCA_XXCH_REAR_LOW_RIGHT        = 0x8000000,
127 };
128
129 static const uint32_t map_xxch_to_native[28] = {
130     AV_CH_FRONT_CENTER,
131     AV_CH_FRONT_LEFT,
132     AV_CH_FRONT_RIGHT,
133     AV_CH_SIDE_LEFT,
134     AV_CH_SIDE_RIGHT,
135     AV_CH_LOW_FREQUENCY,
136     AV_CH_BACK_CENTER,
137     AV_CH_BACK_LEFT,
138     AV_CH_BACK_RIGHT,
139     AV_CH_SIDE_LEFT,           /* side surround left -- dup sur side L */
140     AV_CH_SIDE_RIGHT,          /* side surround right -- dup sur side R */
141     AV_CH_FRONT_LEFT_OF_CENTER,
142     AV_CH_FRONT_RIGHT_OF_CENTER,
143     AV_CH_TOP_FRONT_LEFT,
144     AV_CH_TOP_FRONT_CENTER,
145     AV_CH_TOP_FRONT_RIGHT,
146     AV_CH_LOW_FREQUENCY,        /* lfe2 -- duplicate lfe1 position */
147     AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
148     AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
149     AV_CH_TOP_CENTER,           /* overhead */
150     AV_CH_TOP_FRONT_LEFT,       /* side high left -- dup */
151     AV_CH_TOP_FRONT_RIGHT,      /* side high right -- dup */
152     AV_CH_TOP_BACK_CENTER,
153     AV_CH_TOP_BACK_LEFT,
154     AV_CH_TOP_BACK_RIGHT,
155     AV_CH_BACK_CENTER,          /* rear low center -- dup */
156     AV_CH_BACK_LEFT,            /* rear low left -- dup */
157     AV_CH_BACK_RIGHT            /* read low right -- dup  */
158 };
159
160 enum DCAExtensionMask {
161     DCA_EXT_CORE       = 0x001, ///< core in core substream
162     DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
163     DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
164     DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
165     DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
166     DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
167     DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
168     DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
169     DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
170     DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
171 };
172
173 /* -1 are reserved or unknown */
174 static const int dca_ext_audio_descr_mask[] = {
175     DCA_EXT_XCH,
176     -1,
177     DCA_EXT_X96,
178     DCA_EXT_XCH | DCA_EXT_X96,
179     -1,
180     -1,
181     DCA_EXT_XXCH,
182     -1,
183 };
184
185 /* extensions that reside in core substream */
186 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
187
188 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
189  * Some compromises have been made for special configurations. Most configurations
190  * are never used so complete accuracy is not needed.
191  *
192  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
193  * S  -> side, when both rear and back are configured move one of them to the side channel
194  * OV -> center back
195  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
196  */
197 static const uint64_t dca_core_channel_layout[] = {
198     AV_CH_FRONT_CENTER,                                                     ///< 1, A
199     AV_CH_LAYOUT_STEREO,                                                    ///< 2, A + B (dual mono)
200     AV_CH_LAYOUT_STEREO,                                                    ///< 2, L + R (stereo)
201     AV_CH_LAYOUT_STEREO,                                                    ///< 2, (L + R) + (L - R) (sum-difference)
202     AV_CH_LAYOUT_STEREO,                                                    ///< 2, LT + RT (left and right total)
203     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               ///< 3, C + L + R
204     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                ///< 3, L + R + S
205     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           ///< 4, C + L + R + S
206     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               ///< 4, L + R + SL + SR
207
208     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
209     AV_CH_SIDE_RIGHT,                                                       ///< 5, C + L + R + SL + SR
210
211     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
212     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               ///< 6, CL + CR + L + R + SL + SR
213
214     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
215     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                ///< 6, C + L + R + LR + RR + OV
216
217     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
218     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
219     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 6, CF + CR + LF + RF + LR + RR
220
221     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
222     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
223     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     ///< 7, CL + C + CR + L + R + SL + SR
224
225     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
226     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
227     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
228
229     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
230     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
231     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 ///< 8, CL + C + CR + L + R + SL + S + SR
232 };
233
234 static const int8_t dca_lfe_index[] = {
235     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
236 };
237
238 static const int8_t dca_channel_reorder_lfe[][9] = {
239     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
240     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
241     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
242     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
243     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
244     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
245     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
246     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
247     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
248     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
249     { 3,  4,  0,  1,  5,  6, -1, -1, -1},
250     { 2,  0,  1,  4,  5,  6, -1, -1, -1},
251     { 0,  6,  4,  5,  2,  3, -1, -1, -1},
252     { 4,  2,  5,  0,  1,  6,  7, -1, -1},
253     { 5,  6,  0,  1,  7,  3,  8,  4, -1},
254     { 4,  2,  5,  0,  1,  6,  8,  7, -1},
255 };
256
257 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
258     { 0,  2, -1, -1, -1, -1, -1, -1, -1},
259     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
260     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
261     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
262     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
263     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
264     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
265     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
266     { 0,  1,  4,  5,  3, -1, -1, -1, -1},
267     { 2,  0,  1,  5,  6,  4, -1, -1, -1},
268     { 3,  4,  0,  1,  6,  7,  5, -1, -1},
269     { 2,  0,  1,  4,  5,  6,  7, -1, -1},
270     { 0,  6,  4,  5,  2,  3,  7, -1, -1},
271     { 4,  2,  5,  0,  1,  7,  8,  6, -1},
272     { 5,  6,  0,  1,  8,  3,  9,  4,  7},
273     { 4,  2,  5,  0,  1,  6,  9,  8,  7},
274 };
275
276 static const int8_t dca_channel_reorder_nolfe[][9] = {
277     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
278     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
279     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
280     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
281     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
282     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
283     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
284     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
285     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
286     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
287     { 2,  3,  0,  1,  4,  5, -1, -1, -1},
288     { 2,  0,  1,  3,  4,  5, -1, -1, -1},
289     { 0,  5,  3,  4,  1,  2, -1, -1, -1},
290     { 3,  2,  4,  0,  1,  5,  6, -1, -1},
291     { 4,  5,  0,  1,  6,  2,  7,  3, -1},
292     { 3,  2,  4,  0,  1,  5,  7,  6, -1},
293 };
294
295 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
296     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
297     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
298     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
299     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
300     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
301     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
302     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
303     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
304     { 0,  1,  3,  4,  2, -1, -1, -1, -1},
305     { 2,  0,  1,  4,  5,  3, -1, -1, -1},
306     { 2,  3,  0,  1,  5,  6,  4, -1, -1},
307     { 2,  0,  1,  3,  4,  5,  6, -1, -1},
308     { 0,  5,  3,  4,  1,  2,  6, -1, -1},
309     { 3,  2,  4,  0,  1,  6,  7,  5, -1},
310     { 4,  5,  0,  1,  7,  2,  8,  3,  6},
311     { 3,  2,  4,  0,  1,  5,  8,  7,  6},
312 };
313
314 #define DCA_DOLBY                  101           /* FIXME */
315
316 #define DCA_CHANNEL_BITS             6
317 #define DCA_CHANNEL_MASK          0x3F
318
319 #define DCA_LFE                   0x80
320
321 #define HEADER_SIZE                 14
322
323 #define DCA_MAX_FRAME_SIZE       16384
324 #define DCA_MAX_EXSS_HEADER_SIZE  4096
325
326 #define DCA_BUFFER_PADDING_SIZE   1024
327
328 /** Bit allocation */
329 typedef struct {
330     int offset;                 ///< code values offset
331     int maxbits[8];             ///< max bits in VLC
332     int wrap;                   ///< wrap for get_vlc2()
333     VLC vlc[8];                 ///< actual codes
334 } BitAlloc;
335
336 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
337 static BitAlloc dca_tmode;             ///< transition mode VLCs
338 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
339 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
340
341 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
342                                          int idx)
343 {
344     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
345            ba->offset;
346 }
347
348 typedef struct {
349     AVCodecContext *avctx;
350     AVFrame frame;
351     /* Frame header */
352     int frame_type;             ///< type of the current frame
353     int samples_deficit;        ///< deficit sample count
354     int crc_present;            ///< crc is present in the bitstream
355     int sample_blocks;          ///< number of PCM sample blocks
356     int frame_size;             ///< primary frame byte size
357     int amode;                  ///< audio channels arrangement
358     int sample_rate;            ///< audio sampling rate
359     int bit_rate;               ///< transmission bit rate
360     int bit_rate_index;         ///< transmission bit rate index
361
362     int downmix;                ///< embedded downmix enabled
363     int dynrange;               ///< embedded dynamic range flag
364     int timestamp;              ///< embedded time stamp flag
365     int aux_data;               ///< auxiliary data flag
366     int hdcd;                   ///< source material is mastered in HDCD
367     int ext_descr;              ///< extension audio descriptor flag
368     int ext_coding;             ///< extended coding flag
369     int aspf;                   ///< audio sync word insertion flag
370     int lfe;                    ///< low frequency effects flag
371     int predictor_history;      ///< predictor history flag
372     int header_crc;             ///< header crc check bytes
373     int multirate_inter;        ///< multirate interpolator switch
374     int version;                ///< encoder software revision
375     int copy_history;           ///< copy history
376     int source_pcm_res;         ///< source pcm resolution
377     int front_sum;              ///< front sum/difference flag
378     int surround_sum;           ///< surround sum/difference flag
379     int dialog_norm;            ///< dialog normalisation parameter
380
381     /* Primary audio coding header */
382     int subframes;              ///< number of subframes
383     int total_channels;         ///< number of channels including extensions
384     int prim_channels;          ///< number of primary audio channels
385     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
386     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
387     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
388     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
389     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
390     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
391     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
392     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
393
394     /* Primary audio coding side information */
395     int subsubframes[DCA_SUBFRAMES_MAX];                         ///< number of subsubframes
396     int partial_samples[DCA_SUBFRAMES_MAX];                      ///< partial subsubframe samples count
397     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
398     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
399     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
400     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
401     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
402     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
403     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
404     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
405     int dynrange_coef;                                           ///< dynamic range coefficient
406
407     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
408
409     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
410     int lfe_scale_factor;
411
412     /* Subband samples history (for ADPCM) */
413     DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
414     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
415     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
416     int hist_index[DCA_PRIM_CHANNELS_MAX];
417     DECLARE_ALIGNED(32, float, raXin)[32];
418
419     int output;                 ///< type of output
420     float scale_bias;           ///< output scale
421
422     DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
423     DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX + 1) * 256];
424     const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
425
426     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
427     int dca_buffer_size;        ///< how much data is in the dca_buffer
428
429     const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe
430     GetBitContext gb;
431     /* Current position in DCA frame */
432     int current_subframe;
433     int current_subsubframe;
434
435     int core_ext_mask;          ///< present extensions in the core substream
436
437     /* XCh extension information */
438     int xch_present;            ///< XCh extension present and valid
439     int xch_base_channel;       ///< index of first (only) channel containing XCH data
440
441     /* XXCH extension information */
442     int xxch_chset;
443     int xxch_nbits_spk_mask;
444     int xxch_num_chsets;        /* number of channel sets */
445     uint32_t xxch_core_spkmask;
446     int xxch_num_chans[4];      /* num in channel set */
447     uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
448     int xxch_chset_nch[4];
449
450     uint32_t xxch_downmix;        /* downmix enabled per channel set */
451     uint32_t xxch_dmix_embedded;  /* lower layer has mix pre-embedded, per chset */
452     float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
453
454     int8_t xxch_order_tab[32];
455     int8_t lfe_index;
456
457     /* ExSS header parser */
458     int static_fields;          ///< static fields present
459     int mix_metadata;           ///< mixing metadata present
460     int num_mix_configs;        ///< number of mix out configurations
461     int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
462
463     int profile;
464
465     int debug_flag;             ///< used for suppressing repeated error messages output
466     AVFloatDSPContext fdsp;
467     FFTContext imdct;
468     SynthFilterContext synth;
469     DCADSPContext dcadsp;
470     FmtConvertContext fmt_conv;
471 } DCAContext;
472
473 static const uint16_t dca_vlc_offs[] = {
474         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
475      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
476      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
477      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
478     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
479     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
480 };
481
482 static av_cold void dca_init_vlcs(void)
483 {
484     static int vlcs_initialized = 0;
485     int i, j, c = 14;
486     static VLC_TYPE dca_table[23622][2];
487
488     if (vlcs_initialized)
489         return;
490
491     dca_bitalloc_index.offset = 1;
492     dca_bitalloc_index.wrap = 2;
493     for (i = 0; i < 5; i++) {
494         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
495         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
496         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
497                  bitalloc_12_bits[i], 1, 1,
498                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
499     }
500     dca_scalefactor.offset = -64;
501     dca_scalefactor.wrap = 2;
502     for (i = 0; i < 5; i++) {
503         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
504         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
505         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
506                  scales_bits[i], 1, 1,
507                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
508     }
509     dca_tmode.offset = 0;
510     dca_tmode.wrap = 1;
511     for (i = 0; i < 4; i++) {
512         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
513         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
514         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
515                  tmode_bits[i], 1, 1,
516                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
517     }
518
519     for (i = 0; i < 10; i++)
520         for (j = 0; j < 7; j++) {
521             if (!bitalloc_codes[i][j])
522                 break;
523             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
524             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
525             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
526             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
527
528             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
529                      bitalloc_sizes[i],
530                      bitalloc_bits[i][j], 1, 1,
531                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
532             c++;
533         }
534     vlcs_initialized = 1;
535 }
536
537 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
538 {
539     while (len--)
540         *dst++ = get_bits(gb, bits);
541 }
542
543 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
544                                          int xxch)
545 {
546     int i, j;
547     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
548     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
549     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
550     int hdr_pos = 0, hdr_size = 0;
551     float sign, mag, scale_factor;
552     int this_chans, acc_mask;
553     int embedded_downmix;
554     int nchans, mask[8];
555     int coeff, ichan;
556
557     /* xxch has arbitrary sized audio coding headers */
558     if (xxch) {
559         hdr_pos  = get_bits_count(&s->gb);
560         hdr_size = get_bits(&s->gb, 7) + 1;
561     }
562
563     nchans = get_bits(&s->gb, 3) + 1;
564     s->total_channels = nchans + base_channel;
565     s->prim_channels  = s->total_channels;
566
567     /* obtain speaker layout mask & downmix coefficients for XXCH */
568     if (xxch) {
569         acc_mask = s->xxch_core_spkmask;
570
571         this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
572         s->xxch_spk_masks[s->xxch_chset] = this_chans;
573         s->xxch_chset_nch[s->xxch_chset] = nchans;
574
575         for (i = 0; i <= s->xxch_chset; i++)
576             acc_mask |= s->xxch_spk_masks[i];
577
578         /* check for downmixing information */
579         if (get_bits1(&s->gb)) {
580             embedded_downmix = get_bits1(&s->gb);
581             scale_factor     =
582                 1.0f / dca_downmix_scale_factors[get_bits(&s->gb, 6) << 2];
583
584             for (i = base_channel; i < s->prim_channels; i++) {
585                 s->xxch_downmix |= (1 << i);
586                 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
587             }
588
589             for (j = base_channel; j < s->prim_channels; j++) {
590                 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
591                 if (mask[j])
592                     s->xxch_dmix_embedded |= (embedded_downmix << j);
593                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
594                     if (mask[j] & (1 << i)) {
595                         coeff = get_bits(&s->gb, 7);
596                         sign  = (coeff & 64) ? 1.0 : -1.0;
597                         mag   = dca_downmix_scale_factors[(coeff & 63) << 2];
598                         ichan = av_popcount((acc_mask & ~DCA_XXCH_LFE1)
599                                             & ((1 << i) - 1));
600                         s->xxch_dmix_coeff[j][ichan] = sign * mag * scale_factor;
601                     }
602                 }
603             }
604         }
605     }
606
607     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
608         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
609
610
611     for (i = base_channel; i < s->prim_channels; i++) {
612         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
613         if (s->subband_activity[i] > DCA_SUBBANDS)
614             s->subband_activity[i] = DCA_SUBBANDS;
615     }
616     for (i = base_channel; i < s->prim_channels; i++) {
617         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
618         if (s->vq_start_subband[i] > DCA_SUBBANDS)
619             s->vq_start_subband[i] = DCA_SUBBANDS;
620     }
621     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
622     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
623     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
624     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
625
626     /* Get codebooks quantization indexes */
627     if (!base_channel)
628         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
629     for (j = 1; j < 11; j++)
630         for (i = base_channel; i < s->prim_channels; i++)
631             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
632
633     /* Get scale factor adjustment */
634     for (j = 0; j < 11; j++)
635         for (i = base_channel; i < s->prim_channels; i++)
636             s->scalefactor_adj[i][j] = 1;
637
638     for (j = 1; j < 11; j++)
639         for (i = base_channel; i < s->prim_channels; i++)
640             if (s->quant_index_huffman[i][j] < thr[j])
641                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
642
643     if (!xxch) {
644         if (s->crc_present) {
645             /* Audio header CRC check */
646             get_bits(&s->gb, 16);
647         }
648     } else {
649         /* Skip to the end of the header, also ignore CRC if present  */
650         i = get_bits_count(&s->gb);
651         if (hdr_pos + 8 * hdr_size > i)
652             skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
653     }
654
655     s->current_subframe    = 0;
656     s->current_subsubframe = 0;
657
658 #ifdef TRACE
659     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
660     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
661     for (i = base_channel; i < s->prim_channels; i++) {
662         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
663                s->subband_activity[i]);
664         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
665                s->vq_start_subband[i]);
666         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
667                s->joint_intensity[i]);
668         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
669                s->transient_huffman[i]);
670         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
671                s->scalefactor_huffman[i]);
672         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
673                s->bitalloc_huffman[i]);
674         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
675         for (j = 0; j < 11; j++)
676             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
677         av_log(s->avctx, AV_LOG_DEBUG, "\n");
678         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
679         for (j = 0; j < 11; j++)
680             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
681         av_log(s->avctx, AV_LOG_DEBUG, "\n");
682     }
683 #endif
684
685     return 0;
686 }
687
688 static int dca_parse_frame_header(DCAContext *s)
689 {
690     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
691
692     /* Sync code */
693     skip_bits_long(&s->gb, 32);
694
695     /* Frame header */
696     s->frame_type        = get_bits(&s->gb, 1);
697     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
698     s->crc_present       = get_bits(&s->gb, 1);
699     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
700     s->frame_size        = get_bits(&s->gb, 14) + 1;
701     if (s->frame_size < 95)
702         return AVERROR_INVALIDDATA;
703     s->amode             = get_bits(&s->gb, 6);
704     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
705     if (!s->sample_rate)
706         return AVERROR_INVALIDDATA;
707     s->bit_rate_index    = get_bits(&s->gb, 5);
708     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
709     if (!s->bit_rate)
710         return AVERROR_INVALIDDATA;
711
712     s->downmix           = get_bits(&s->gb, 1); /* note: this is FixedBit == 0 */
713     s->dynrange          = get_bits(&s->gb, 1);
714     s->timestamp         = get_bits(&s->gb, 1);
715     s->aux_data          = get_bits(&s->gb, 1);
716     s->hdcd              = get_bits(&s->gb, 1);
717     s->ext_descr         = get_bits(&s->gb, 3);
718     s->ext_coding        = get_bits(&s->gb, 1);
719     s->aspf              = get_bits(&s->gb, 1);
720     s->lfe               = get_bits(&s->gb, 2);
721     s->predictor_history = get_bits(&s->gb, 1);
722
723     /* TODO: check CRC */
724     if (s->crc_present)
725         s->header_crc    = get_bits(&s->gb, 16);
726
727     s->multirate_inter   = get_bits(&s->gb, 1);
728     s->version           = get_bits(&s->gb, 4);
729     s->copy_history      = get_bits(&s->gb, 2);
730     s->source_pcm_res    = get_bits(&s->gb, 3);
731     s->front_sum         = get_bits(&s->gb, 1);
732     s->surround_sum      = get_bits(&s->gb, 1);
733     s->dialog_norm       = get_bits(&s->gb, 4);
734
735     /* FIXME: channels mixing levels */
736     s->output = s->amode;
737     if (s->lfe)
738         s->output |= DCA_LFE;
739
740 #ifdef TRACE
741     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
742     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
743     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
744     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
745            s->sample_blocks, s->sample_blocks * 32);
746     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
747     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
748            s->amode, dca_channels[s->amode]);
749     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
750            s->sample_rate);
751     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
752            s->bit_rate);
753     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
754     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
755     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
756     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
757     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
758     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
759     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
760     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
761     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
762     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
763            s->predictor_history);
764     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
765     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
766            s->multirate_inter);
767     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
768     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
769     av_log(s->avctx, AV_LOG_DEBUG,
770            "source pcm resolution: %i (%i bits/sample)\n",
771            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
772     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
773     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
774     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
775     av_log(s->avctx, AV_LOG_DEBUG, "\n");
776 #endif
777
778     /* Primary audio coding header */
779     s->subframes         = get_bits(&s->gb, 4) + 1;
780
781     return dca_parse_audio_coding_header(s, 0, 0);
782 }
783
784
785 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
786 {
787     if (level < 5) {
788         /* huffman encoded */
789         value += get_bitalloc(gb, &dca_scalefactor, level);
790         value = av_clip(value, 0, (1 << log2range) - 1);
791     } else if (level < 8) {
792         if (level + 1 > log2range) {
793             skip_bits(gb, level + 1 - log2range);
794             value = get_bits(gb, log2range);
795         } else {
796             value = get_bits(gb, level + 1);
797         }
798     }
799     return value;
800 }
801
802 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
803 {
804     /* Primary audio coding side information */
805     int j, k;
806
807     if (get_bits_left(&s->gb) < 0)
808         return AVERROR_INVALIDDATA;
809
810     if (!base_channel) {
811         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
812         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
813     }
814
815     for (j = base_channel; j < s->prim_channels; j++) {
816         for (k = 0; k < s->subband_activity[j]; k++)
817             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
818     }
819
820     /* Get prediction codebook */
821     for (j = base_channel; j < s->prim_channels; j++) {
822         for (k = 0; k < s->subband_activity[j]; k++) {
823             if (s->prediction_mode[j][k] > 0) {
824                 /* (Prediction coefficient VQ address) */
825                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
826             }
827         }
828     }
829
830     /* Bit allocation index */
831     for (j = base_channel; j < s->prim_channels; j++) {
832         for (k = 0; k < s->vq_start_subband[j]; k++) {
833             if (s->bitalloc_huffman[j] == 6)
834                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
835             else if (s->bitalloc_huffman[j] == 5)
836                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
837             else if (s->bitalloc_huffman[j] == 7) {
838                 av_log(s->avctx, AV_LOG_ERROR,
839                        "Invalid bit allocation index\n");
840                 return AVERROR_INVALIDDATA;
841             } else {
842                 s->bitalloc[j][k] =
843                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
844             }
845
846             if (s->bitalloc[j][k] > 26) {
847                 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
848                 //        j, k, s->bitalloc[j][k]);
849                 return AVERROR_INVALIDDATA;
850             }
851         }
852     }
853
854     /* Transition mode */
855     for (j = base_channel; j < s->prim_channels; j++) {
856         for (k = 0; k < s->subband_activity[j]; k++) {
857             s->transition_mode[j][k] = 0;
858             if (s->subsubframes[s->current_subframe] > 1 &&
859                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
860                 s->transition_mode[j][k] =
861                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
862             }
863         }
864     }
865
866     if (get_bits_left(&s->gb) < 0)
867         return AVERROR_INVALIDDATA;
868
869     for (j = base_channel; j < s->prim_channels; j++) {
870         const uint32_t *scale_table;
871         int scale_sum, log_size;
872
873         memset(s->scale_factor[j], 0,
874                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
875
876         if (s->scalefactor_huffman[j] == 6) {
877             scale_table = scale_factor_quant7;
878             log_size = 7;
879         } else {
880             scale_table = scale_factor_quant6;
881             log_size = 6;
882         }
883
884         /* When huffman coded, only the difference is encoded */
885         scale_sum = 0;
886
887         for (k = 0; k < s->subband_activity[j]; k++) {
888             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
889                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
890                 s->scale_factor[j][k][0] = scale_table[scale_sum];
891             }
892
893             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
894                 /* Get second scale factor */
895                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
896                 s->scale_factor[j][k][1] = scale_table[scale_sum];
897             }
898         }
899     }
900
901     /* Joint subband scale factor codebook select */
902     for (j = base_channel; j < s->prim_channels; j++) {
903         /* Transmitted only if joint subband coding enabled */
904         if (s->joint_intensity[j] > 0)
905             s->joint_huff[j] = get_bits(&s->gb, 3);
906     }
907
908     if (get_bits_left(&s->gb) < 0)
909         return AVERROR_INVALIDDATA;
910
911     /* Scale factors for joint subband coding */
912     for (j = base_channel; j < s->prim_channels; j++) {
913         int source_channel;
914
915         /* Transmitted only if joint subband coding enabled */
916         if (s->joint_intensity[j] > 0) {
917             int scale = 0;
918             source_channel = s->joint_intensity[j] - 1;
919
920             /* When huffman coded, only the difference is encoded
921              * (is this valid as well for joint scales ???) */
922
923             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
924                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
925                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
926             }
927
928             if (!(s->debug_flag & 0x02)) {
929                 av_log(s->avctx, AV_LOG_DEBUG,
930                        "Joint stereo coding not supported\n");
931                 s->debug_flag |= 0x02;
932             }
933         }
934     }
935
936     /* Stereo downmix coefficients */
937     if (!base_channel && s->prim_channels > 2) {
938         if (s->downmix) {
939             for (j = base_channel; j < s->prim_channels; j++) {
940                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
941                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
942             }
943         } else {
944             int am = s->amode & DCA_CHANNEL_MASK;
945             if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
946                 av_log(s->avctx, AV_LOG_ERROR,
947                        "Invalid channel mode %d\n", am);
948                 return AVERROR_INVALIDDATA;
949             }
950             for (j = base_channel; j < FFMIN(s->prim_channels, FF_ARRAY_ELEMS(dca_default_coeffs[am])); j++) {
951                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
952                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
953             }
954         }
955     }
956
957     /* Dynamic range coefficient */
958     if (!base_channel && s->dynrange)
959         s->dynrange_coef = get_bits(&s->gb, 8);
960
961     /* Side information CRC check word */
962     if (s->crc_present) {
963         get_bits(&s->gb, 16);
964     }
965
966     /*
967      * Primary audio data arrays
968      */
969
970     /* VQ encoded high frequency subbands */
971     for (j = base_channel; j < s->prim_channels; j++)
972         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
973             /* 1 vector -> 32 samples */
974             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
975
976     /* Low frequency effect data */
977     if (!base_channel && s->lfe) {
978         int quant7;
979         /* LFE samples */
980         int lfe_samples = 2 * s->lfe * (4 + block_index);
981         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
982         float lfe_scale;
983
984         for (j = lfe_samples; j < lfe_end_sample; j++) {
985             /* Signed 8 bits int */
986             s->lfe_data[j] = get_sbits(&s->gb, 8);
987         }
988
989         /* Scale factor index */
990         quant7 = get_bits(&s->gb, 8);
991         if (quant7 > 127) {
992             av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
993             return AVERROR_INVALIDDATA;
994         }
995         s->lfe_scale_factor = scale_factor_quant7[quant7];
996
997         /* Quantization step size * scale factor */
998         lfe_scale = 0.035 * s->lfe_scale_factor;
999
1000         for (j = lfe_samples; j < lfe_end_sample; j++)
1001             s->lfe_data[j] *= lfe_scale;
1002     }
1003
1004 #ifdef TRACE
1005     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
1006            s->subsubframes[s->current_subframe]);
1007     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
1008            s->partial_samples[s->current_subframe]);
1009
1010     for (j = base_channel; j < s->prim_channels; j++) {
1011         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
1012         for (k = 0; k < s->subband_activity[j]; k++)
1013             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
1014         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1015     }
1016     for (j = base_channel; j < s->prim_channels; j++) {
1017         for (k = 0; k < s->subband_activity[j]; k++)
1018             av_log(s->avctx, AV_LOG_DEBUG,
1019                    "prediction coefs: %f, %f, %f, %f\n",
1020                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
1021                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
1022                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
1023                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
1024     }
1025     for (j = base_channel; j < s->prim_channels; j++) {
1026         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
1027         for (k = 0; k < s->vq_start_subband[j]; k++)
1028             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
1029         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1030     }
1031     for (j = base_channel; j < s->prim_channels; j++) {
1032         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
1033         for (k = 0; k < s->subband_activity[j]; k++)
1034             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
1035         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1036     }
1037     for (j = base_channel; j < s->prim_channels; j++) {
1038         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
1039         for (k = 0; k < s->subband_activity[j]; k++) {
1040             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
1041                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
1042             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
1043                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
1044         }
1045         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1046     }
1047     for (j = base_channel; j < s->prim_channels; j++) {
1048         if (s->joint_intensity[j] > 0) {
1049             int source_channel = s->joint_intensity[j] - 1;
1050             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
1051             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
1052                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
1053             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1054         }
1055     }
1056     if (!base_channel && s->prim_channels > 2 && s->downmix) {
1057         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
1058         for (j = 0; j < s->prim_channels; j++) {
1059             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
1060                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
1061             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
1062                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
1063         }
1064         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1065     }
1066     for (j = base_channel; j < s->prim_channels; j++)
1067         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
1068             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
1069     if (!base_channel && s->lfe) {
1070         int lfe_samples = 2 * s->lfe * (4 + block_index);
1071         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
1072
1073         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
1074         for (j = lfe_samples; j < lfe_end_sample; j++)
1075             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
1076         av_log(s->avctx, AV_LOG_DEBUG, "\n");
1077     }
1078 #endif
1079
1080     return 0;
1081 }
1082
1083 static void qmf_32_subbands(DCAContext *s, int chans,
1084                             float samples_in[32][8], float *samples_out,
1085                             float scale)
1086 {
1087     const float *prCoeff;
1088     int i;
1089
1090     int sb_act = s->subband_activity[chans];
1091     int subindex;
1092
1093     scale *= sqrt(1 / 8.0);
1094
1095     /* Select filter */
1096     if (!s->multirate_inter)    /* Non-perfect reconstruction */
1097         prCoeff = fir_32bands_nonperfect;
1098     else                        /* Perfect reconstruction */
1099         prCoeff = fir_32bands_perfect;
1100
1101     for (i = sb_act; i < 32; i++)
1102         s->raXin[i] = 0.0;
1103
1104     /* Reconstructed channel sample index */
1105     for (subindex = 0; subindex < 8; subindex++) {
1106         /* Load in one sample from each subband and clear inactive subbands */
1107         for (i = 0; i < sb_act; i++) {
1108             unsigned sign = (i - 1) & 2;
1109             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
1110             AV_WN32A(&s->raXin[i], v);
1111         }
1112
1113         s->synth.synth_filter_float(&s->imdct,
1114                                     s->subband_fir_hist[chans],
1115                                     &s->hist_index[chans],
1116                                     s->subband_fir_noidea[chans], prCoeff,
1117                                     samples_out, s->raXin, scale);
1118         samples_out += 32;
1119     }
1120 }
1121
1122 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
1123                                   int num_deci_sample, float *samples_in,
1124                                   float *samples_out, float scale)
1125 {
1126     /* samples_in: An array holding decimated samples.
1127      *   Samples in current subframe starts from samples_in[0],
1128      *   while samples_in[-1], samples_in[-2], ..., stores samples
1129      *   from last subframe as history.
1130      *
1131      * samples_out: An array holding interpolated samples
1132      */
1133
1134     int decifactor;
1135     const float *prCoeff;
1136     int deciindex;
1137
1138     /* Select decimation filter */
1139     if (decimation_select == 1) {
1140         decifactor = 64;
1141         prCoeff = lfe_fir_128;
1142     } else {
1143         decifactor = 32;
1144         prCoeff = lfe_fir_64;
1145     }
1146     /* Interpolation */
1147     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
1148         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
1149         samples_in++;
1150         samples_out += 2 * decifactor;
1151     }
1152 }
1153
1154 /* downmixing routines */
1155 #define MIX_REAR1(samples, si1, rs, coef)           \
1156     samples[i]     += samples[si1] * coef[rs][0];   \
1157     samples[i+256] += samples[si1] * coef[rs][1];
1158
1159 #define MIX_REAR2(samples, si1, si2, rs, coef)                                     \
1160     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
1161     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
1162
1163 #define MIX_FRONT3(samples, coef)                                      \
1164     t = samples[i + c];                                                \
1165     u = samples[i + l];                                                \
1166     v = samples[i + r];                                                \
1167     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
1168     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
1169
1170 #define DOWNMIX_TO_STEREO(op1, op2)             \
1171     for (i = 0; i < 256; i++) {                 \
1172         op1                                     \
1173         op2                                     \
1174     }
1175
1176 static void dca_downmix(float *samples, int srcfmt,
1177                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
1178                         const int8_t *channel_mapping)
1179 {
1180     int c, l, r, sl, sr, s;
1181     int i;
1182     float t, u, v;
1183     float coef[DCA_PRIM_CHANNELS_MAX][2];
1184
1185     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
1186         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
1187         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
1188     }
1189
1190     switch (srcfmt) {
1191     case DCA_MONO:
1192     case DCA_CHANNEL:
1193     case DCA_STEREO_TOTAL:
1194     case DCA_STEREO_SUMDIFF:
1195     case DCA_4F2R:
1196         av_log(NULL, 0, "Not implemented!\n");
1197         break;
1198     case DCA_STEREO:
1199         break;
1200     case DCA_3F:
1201         c = channel_mapping[0] * 256;
1202         l = channel_mapping[1] * 256;
1203         r = channel_mapping[2] * 256;
1204         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1205         break;
1206     case DCA_2F1R:
1207         s = channel_mapping[2] * 256;
1208         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
1209         break;
1210     case DCA_3F1R:
1211         c = channel_mapping[0] * 256;
1212         l = channel_mapping[1] * 256;
1213         r = channel_mapping[2] * 256;
1214         s = channel_mapping[3] * 256;
1215         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1216                           MIX_REAR1(samples, i + s, 3, coef));
1217         break;
1218     case DCA_2F2R:
1219         sl = channel_mapping[2] * 256;
1220         sr = channel_mapping[3] * 256;
1221         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
1222         break;
1223     case DCA_3F2R:
1224         c  = channel_mapping[0] * 256;
1225         l  = channel_mapping[1] * 256;
1226         r  = channel_mapping[2] * 256;
1227         sl = channel_mapping[3] * 256;
1228         sr = channel_mapping[4] * 256;
1229         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1230                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1231         break;
1232     }
1233 }
1234
1235
1236 #ifndef decode_blockcodes
1237 /* Very compact version of the block code decoder that does not use table
1238  * look-up but is slightly slower */
1239 static int decode_blockcode(int code, int levels, int *values)
1240 {
1241     int i;
1242     int offset = (levels - 1) >> 1;
1243
1244     for (i = 0; i < 4; i++) {
1245         int div = FASTDIV(code, levels);
1246         values[i] = code - offset - div * levels;
1247         code = div;
1248     }
1249
1250     return code;
1251 }
1252
1253 static int decode_blockcodes(int code1, int code2, int levels, int *values)
1254 {
1255     return decode_blockcode(code1, levels, values) |
1256            decode_blockcode(code2, levels, values + 4);
1257 }
1258 #endif
1259
1260 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
1261 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
1262
1263 #ifndef int8x8_fmul_int32
1264 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
1265 {
1266     float fscale = scale / 16.0;
1267     int i;
1268     for (i = 0; i < 8; i++)
1269         dst[i] = src[i] * fscale;
1270 }
1271 #endif
1272
1273 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1274 {
1275     int k, l;
1276     int subsubframe = s->current_subsubframe;
1277
1278     const float *quant_step_table;
1279
1280     /* FIXME */
1281     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1282     LOCAL_ALIGNED_16(int, block, [8]);
1283
1284     /*
1285      * Audio data
1286      */
1287
1288     /* Select quantization step size table */
1289     if (s->bit_rate_index == 0x1f)
1290         quant_step_table = lossless_quant_d;
1291     else
1292         quant_step_table = lossy_quant_d;
1293
1294     for (k = base_channel; k < s->prim_channels; k++) {
1295         if (get_bits_left(&s->gb) < 0)
1296             return AVERROR_INVALIDDATA;
1297
1298         for (l = 0; l < s->vq_start_subband[k]; l++) {
1299             int m;
1300
1301             /* Select the mid-tread linear quantizer */
1302             int abits = s->bitalloc[k][l];
1303
1304             float quant_step_size = quant_step_table[abits];
1305
1306             /*
1307              * Determine quantization index code book and its type
1308              */
1309
1310             /* Select quantization index code book */
1311             int sel = s->quant_index_huffman[k][abits];
1312
1313             /*
1314              * Extract bits from the bit stream
1315              */
1316             if (!abits) {
1317                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1318             } else {
1319                 /* Deal with transients */
1320                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1321                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
1322                                s->scalefactor_adj[k][sel];
1323
1324                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1325                     if (abits <= 7) {
1326                         /* Block code */
1327                         int block_code1, block_code2, size, levels, err;
1328
1329                         size   = abits_sizes[abits - 1];
1330                         levels = abits_levels[abits - 1];
1331
1332                         block_code1 = get_bits(&s->gb, size);
1333                         block_code2 = get_bits(&s->gb, size);
1334                         err = decode_blockcodes(block_code1, block_code2,
1335                                                 levels, block);
1336                         if (err) {
1337                             av_log(s->avctx, AV_LOG_ERROR,
1338                                    "ERROR: block code look-up failed\n");
1339                             return AVERROR_INVALIDDATA;
1340                         }
1341                     } else {
1342                         /* no coding */
1343                         for (m = 0; m < 8; m++)
1344                             block[m] = get_sbits(&s->gb, abits - 3);
1345                     }
1346                 } else {
1347                     /* Huffman coded */
1348                     for (m = 0; m < 8; m++)
1349                         block[m] = get_bitalloc(&s->gb,
1350                                                 &dca_smpl_bitalloc[abits], sel);
1351                 }
1352
1353                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1354                                                        block, rscale, 8);
1355             }
1356
1357             /*
1358              * Inverse ADPCM if in prediction mode
1359              */
1360             if (s->prediction_mode[k][l]) {
1361                 int n;
1362                 for (m = 0; m < 8; m++) {
1363                     for (n = 1; n <= 4; n++)
1364                         if (m >= n)
1365                             subband_samples[k][l][m] +=
1366                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1367                                  subband_samples[k][l][m - n] / 8192);
1368                         else if (s->predictor_history)
1369                             subband_samples[k][l][m] +=
1370                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1371                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1372                 }
1373             }
1374         }
1375
1376         /*
1377          * Decode VQ encoded high frequencies
1378          */
1379         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1380             /* 1 vector -> 32 samples but we only need the 8 samples
1381              * for this subsubframe. */
1382             int hfvq = s->high_freq_vq[k][l];
1383
1384             if (!s->debug_flag & 0x01) {
1385                 av_log(s->avctx, AV_LOG_DEBUG,
1386                        "Stream with high frequencies VQ coding\n");
1387                 s->debug_flag |= 0x01;
1388             }
1389
1390             int8x8_fmul_int32(subband_samples[k][l],
1391                               &high_freq_vq[hfvq][subsubframe * 8],
1392                               s->scale_factor[k][l][0]);
1393         }
1394     }
1395
1396     /* Check for DSYNC after subsubframe */
1397     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1398         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1399 #ifdef TRACE
1400             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1401 #endif
1402         } else {
1403             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1404         }
1405     }
1406
1407     /* Backup predictor history for adpcm */
1408     for (k = base_channel; k < s->prim_channels; k++)
1409         for (l = 0; l < s->vq_start_subband[k]; l++)
1410             memcpy(s->subband_samples_hist[k][l],
1411                    &subband_samples[k][l][4],
1412                    4 * sizeof(subband_samples[0][0][0]));
1413
1414     return 0;
1415 }
1416
1417 static int dca_filter_channels(DCAContext *s, int block_index)
1418 {
1419     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1420     int k;
1421
1422     /* 32 subbands QMF */
1423     for (k = 0; k < s->prim_channels; k++) {
1424 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1425                                             0, 8388608.0, 8388608.0 };*/
1426         qmf_32_subbands(s, k, subband_samples[k],
1427                         &s->samples[256 * s->channel_order_tab[k]],
1428                         M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
1429     }
1430
1431     /* Down mixing */
1432     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1433         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1434     }
1435
1436     /* Generate LFE samples for this subsubframe FIXME!!! */
1437     if (s->output & DCA_LFE) {
1438         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1439                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1440                               &s->samples[256 * s->lfe_index],
1441                               (1.0 / 256.0) * s->scale_bias);
1442         /* Outputs 20bits pcm samples */
1443     }
1444
1445     return 0;
1446 }
1447
1448
1449 static int dca_subframe_footer(DCAContext *s, int base_channel)
1450 {
1451     int aux_data_count = 0, i;
1452
1453     /*
1454      * Unpack optional information
1455      */
1456
1457     /* presumably optional information only appears in the core? */
1458     if (!base_channel) {
1459         if (s->timestamp)
1460             skip_bits_long(&s->gb, 32);
1461
1462         if (s->aux_data)
1463             aux_data_count = get_bits(&s->gb, 6);
1464
1465         for (i = 0; i < aux_data_count; i++)
1466             get_bits(&s->gb, 8);
1467
1468         if (s->crc_present && (s->downmix || s->dynrange))
1469             get_bits(&s->gb, 16);
1470     }
1471
1472     return 0;
1473 }
1474
1475 /**
1476  * Decode a dca frame block
1477  *
1478  * @param s     pointer to the DCAContext
1479  */
1480
1481 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
1482 {
1483     int ret;
1484
1485     /* Sanity check */
1486     if (s->current_subframe >= s->subframes) {
1487         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1488                s->current_subframe, s->subframes);
1489         return AVERROR_INVALIDDATA;
1490     }
1491
1492     if (!s->current_subsubframe) {
1493 #ifdef TRACE
1494         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1495 #endif
1496         /* Read subframe header */
1497         if ((ret = dca_subframe_header(s, base_channel, block_index)))
1498             return ret;
1499     }
1500
1501     /* Read subsubframe */
1502 #ifdef TRACE
1503     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1504 #endif
1505     if ((ret = dca_subsubframe(s, base_channel, block_index)))
1506         return ret;
1507
1508     /* Update state */
1509     s->current_subsubframe++;
1510     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1511         s->current_subsubframe = 0;
1512         s->current_subframe++;
1513     }
1514     if (s->current_subframe >= s->subframes) {
1515 #ifdef TRACE
1516         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1517 #endif
1518         /* Read subframe footer */
1519         if ((ret = dca_subframe_footer(s, base_channel)))
1520             return ret;
1521     }
1522
1523     return 0;
1524 }
1525
1526 /**
1527  * Return the number of channels in an ExSS speaker mask (HD)
1528  */
1529 static int dca_exss_mask2count(int mask)
1530 {
1531     /* count bits that mean speaker pairs twice */
1532     return av_popcount(mask) +
1533            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
1534                                DCA_EXSS_FRONT_LEFT_RIGHT       |
1535                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
1536                                DCA_EXSS_WIDE_LEFT_RIGHT        |
1537                                DCA_EXSS_SIDE_LEFT_RIGHT        |
1538                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
1539                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
1540                                DCA_EXSS_REAR_LEFT_RIGHT        |
1541                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
1542 }
1543
1544 /**
1545  * Skip mixing coefficients of a single mix out configuration (HD)
1546  */
1547 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1548 {
1549     int i;
1550
1551     for (i = 0; i < channels; i++) {
1552         int mix_map_mask = get_bits(gb, out_ch);
1553         int num_coeffs = av_popcount(mix_map_mask);
1554         skip_bits_long(gb, num_coeffs * 6);
1555     }
1556 }
1557
1558 /**
1559  * Parse extension substream asset header (HD)
1560  */
1561 static int dca_exss_parse_asset_header(DCAContext *s)
1562 {
1563     int header_pos = get_bits_count(&s->gb);
1564     int header_size;
1565     int channels = 0;
1566     int embedded_stereo = 0;
1567     int embedded_6ch    = 0;
1568     int drc_code_present;
1569     int av_uninit(extensions_mask);
1570     int i, j;
1571
1572     if (get_bits_left(&s->gb) < 16)
1573         return -1;
1574
1575     /* We will parse just enough to get to the extensions bitmask with which
1576      * we can set the profile value. */
1577
1578     header_size = get_bits(&s->gb, 9) + 1;
1579     skip_bits(&s->gb, 3); // asset index
1580
1581     if (s->static_fields) {
1582         if (get_bits1(&s->gb))
1583             skip_bits(&s->gb, 4); // asset type descriptor
1584         if (get_bits1(&s->gb))
1585             skip_bits_long(&s->gb, 24); // language descriptor
1586
1587         if (get_bits1(&s->gb)) {
1588             /* How can one fit 1024 bytes of text here if the maximum value
1589              * for the asset header size field above was 512 bytes? */
1590             int text_length = get_bits(&s->gb, 10) + 1;
1591             if (get_bits_left(&s->gb) < text_length * 8)
1592                 return -1;
1593             skip_bits_long(&s->gb, text_length * 8); // info text
1594         }
1595
1596         skip_bits(&s->gb, 5); // bit resolution - 1
1597         skip_bits(&s->gb, 4); // max sample rate code
1598         channels = get_bits(&s->gb, 8) + 1;
1599
1600         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1601             int spkr_remap_sets;
1602             int spkr_mask_size = 16;
1603             int num_spkrs[7];
1604
1605             if (channels > 2)
1606                 embedded_stereo = get_bits1(&s->gb);
1607             if (channels > 6)
1608                 embedded_6ch = get_bits1(&s->gb);
1609
1610             if (get_bits1(&s->gb)) {
1611                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1612                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1613             }
1614
1615             spkr_remap_sets = get_bits(&s->gb, 3);
1616
1617             for (i = 0; i < spkr_remap_sets; i++) {
1618                 /* std layout mask for each remap set */
1619                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1620             }
1621
1622             for (i = 0; i < spkr_remap_sets; i++) {
1623                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1624                 if (get_bits_left(&s->gb) < 0)
1625                     return -1;
1626
1627                 for (j = 0; j < num_spkrs[i]; j++) {
1628                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1629                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
1630                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1631                 }
1632             }
1633
1634         } else {
1635             skip_bits(&s->gb, 3); // representation type
1636         }
1637     }
1638
1639     drc_code_present = get_bits1(&s->gb);
1640     if (drc_code_present)
1641         get_bits(&s->gb, 8); // drc code
1642
1643     if (get_bits1(&s->gb))
1644         skip_bits(&s->gb, 5); // dialog normalization code
1645
1646     if (drc_code_present && embedded_stereo)
1647         get_bits(&s->gb, 8); // drc stereo code
1648
1649     if (s->mix_metadata && get_bits1(&s->gb)) {
1650         skip_bits(&s->gb, 1); // external mix
1651         skip_bits(&s->gb, 6); // post mix gain code
1652
1653         if (get_bits(&s->gb, 2) != 3) // mixer drc code
1654             skip_bits(&s->gb, 3); // drc limit
1655         else
1656             skip_bits(&s->gb, 8); // custom drc code
1657
1658         if (get_bits1(&s->gb)) // channel specific scaling
1659             for (i = 0; i < s->num_mix_configs; i++)
1660                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1661         else
1662             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1663
1664         for (i = 0; i < s->num_mix_configs; i++) {
1665             if (get_bits_left(&s->gb) < 0)
1666                 return -1;
1667             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1668             if (embedded_6ch)
1669                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1670             if (embedded_stereo)
1671                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1672         }
1673     }
1674
1675     switch (get_bits(&s->gb, 2)) {
1676     case 0: extensions_mask = get_bits(&s->gb, 12); break;
1677     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1678     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1679     case 3: extensions_mask = 0; /* aux coding */   break;
1680     }
1681
1682     /* not parsed further, we were only interested in the extensions mask */
1683
1684     if (get_bits_left(&s->gb) < 0)
1685         return -1;
1686
1687     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1688         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1689         return -1;
1690     }
1691     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1692
1693     if (extensions_mask & DCA_EXT_EXSS_XLL)
1694         s->profile = FF_PROFILE_DTS_HD_MA;
1695     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1696                                 DCA_EXT_EXSS_XXCH))
1697         s->profile = FF_PROFILE_DTS_HD_HRA;
1698
1699     if (!(extensions_mask & DCA_EXT_CORE))
1700         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1701     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
1702         av_log(s->avctx, AV_LOG_WARNING,
1703                "DTS extensions detection mismatch (%d, %d)\n",
1704                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
1705
1706     return 0;
1707 }
1708
1709 static int dca_xbr_parse_frame(DCAContext *s)
1710 {
1711     int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
1712     int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
1713     int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
1714     int anctemp[DCA_CHSET_CHANS_MAX];
1715     int chset_fsize[DCA_CHSETS_MAX];
1716     int n_xbr_ch[DCA_CHSETS_MAX];
1717     int hdr_size, num_chsets, xbr_tmode, hdr_pos;
1718     int i, j, k, l, chset, chan_base;
1719
1720     av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
1721
1722     /* get bit position of sync header */
1723     hdr_pos = get_bits_count(&s->gb) - 32;
1724
1725     hdr_size = get_bits(&s->gb, 6) + 1;
1726     num_chsets = get_bits(&s->gb, 2) + 1;
1727
1728     for(i = 0; i < num_chsets; i++)
1729         chset_fsize[i] = get_bits(&s->gb, 14) + 1;
1730
1731     xbr_tmode = get_bits1(&s->gb);
1732
1733     for(i = 0; i < num_chsets; i++) {
1734         n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
1735         k = get_bits(&s->gb, 2) + 5;
1736         for(j = 0; j < n_xbr_ch[i]; j++)
1737             active_bands[i][j] = get_bits(&s->gb, k) + 1;
1738     }
1739
1740     /* skip to the end of the header */
1741     i = get_bits_count(&s->gb);
1742     if(hdr_pos + hdr_size * 8 > i)
1743         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1744
1745     /* loop over the channel data sets */
1746     /* only decode as many channels as we've decoded base data for */
1747     for(chset = 0, chan_base = 0;
1748         chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
1749         chan_base += n_xbr_ch[chset++]) {
1750         int start_posn = get_bits_count(&s->gb);
1751         int subsubframe = 0;
1752         int subframe = 0;
1753
1754         /* loop over subframes */
1755         for (k = 0; k < (s->sample_blocks / 8); k++) {
1756             /* parse header if we're on first subsubframe of a block */
1757             if(subsubframe == 0) {
1758                 /* Parse subframe header */
1759                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1760                     anctemp[i] = get_bits(&s->gb, 2) + 2;
1761                 }
1762
1763                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1764                     get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
1765                 }
1766
1767                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1768                     anctemp[i] = get_bits(&s->gb, 3);
1769                     if(anctemp[i] < 1) {
1770                         av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
1771                         return AVERROR_INVALIDDATA;
1772                     }
1773                 }
1774
1775                 /* generate scale factors */
1776                 for(i = 0; i < n_xbr_ch[chset]; i++) {
1777                     const uint32_t *scale_table;
1778                     int nbits;
1779
1780                     if (s->scalefactor_huffman[chan_base+i] == 6) {
1781                         scale_table = scale_factor_quant7;
1782                     } else {
1783                         scale_table = scale_factor_quant6;
1784                     }
1785
1786                     nbits = anctemp[i];
1787
1788                     for(j = 0; j < active_bands[chset][i]; j++) {
1789                         if(abits_high[i][j] > 0) {
1790                             scale_table_high[i][j][0] =
1791                                 scale_table[get_bits(&s->gb, nbits)];
1792
1793                             if(xbr_tmode && s->transition_mode[i][j]) {
1794                                 scale_table_high[i][j][1] =
1795                                     scale_table[get_bits(&s->gb, nbits)];
1796                             }
1797                         }
1798                     }
1799                 }
1800             }
1801
1802             /* decode audio array for this block */
1803             for(i = 0; i < n_xbr_ch[chset]; i++) {
1804                 for(j = 0; j < active_bands[chset][i]; j++) {
1805                     const int xbr_abits = abits_high[i][j];
1806                     const float quant_step_size = lossless_quant_d[xbr_abits];
1807                     const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
1808                     const float rscale = quant_step_size * scale_table_high[i][j][sfi];
1809                     float *subband_samples = s->subband_samples[k][chan_base+i][j];
1810                     int block[8];
1811
1812                     if(xbr_abits <= 0)
1813                         continue;
1814
1815                     if(xbr_abits > 7) {
1816                         get_array(&s->gb, block, 8, xbr_abits - 3);
1817                     } else {
1818                         int block_code1, block_code2, size, levels, err;
1819
1820                         size   = abits_sizes[xbr_abits - 1];
1821                         levels = abits_levels[xbr_abits - 1];
1822
1823                         block_code1 = get_bits(&s->gb, size);
1824                         block_code2 = get_bits(&s->gb, size);
1825                         err = decode_blockcodes(block_code1, block_code2,
1826                                                 levels, block);
1827                         if (err) {
1828                             av_log(s->avctx, AV_LOG_ERROR,
1829                                    "ERROR: DTS-XBR: block code look-up failed\n");
1830                             return AVERROR_INVALIDDATA;
1831                         }
1832                     }
1833
1834                     /* scale & sum into subband */
1835                     for(l = 0; l < 8; l++)
1836                         subband_samples[l] += (float)block[l] * rscale;
1837                 }
1838             }
1839
1840             /* check DSYNC marker */
1841             if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
1842                 if(get_bits(&s->gb, 16) != 0xffff) {
1843                     av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
1844                     return AVERROR_INVALIDDATA;
1845                 }
1846             }
1847
1848             /* advance sub-sub-frame index */
1849             if(++subsubframe >= s->subsubframes[subframe]) {
1850                 subsubframe = 0;
1851                 subframe++;
1852             }
1853         }
1854
1855         /* skip to next channel set */
1856         i = get_bits_count(&s->gb);
1857         if(start_posn + chset_fsize[chset] * 8 != i) {
1858             j = start_posn + chset_fsize[chset] * 8 - i;
1859             if(j < 0 || j >= 8)
1860                 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
1861                        " skipping further than expected (%d bits)\n", j);
1862             skip_bits_long(&s->gb, j);
1863         }
1864     }
1865
1866     return 0;
1867 }
1868
1869 /* parse initial header for XXCH and dump details */
1870 static int dca_xxch_decode_frame(DCAContext *s)
1871 {
1872     int hdr_size, chhdr_crc, spkmsk_bits, num_chsets, core_spk, hdr_pos;
1873     int i, chset, base_channel, chstart, fsize[8];
1874
1875     /* assume header word has already been parsed */
1876     hdr_pos     = get_bits_count(&s->gb) - 32;
1877     hdr_size    = get_bits(&s->gb, 6) + 1;
1878     chhdr_crc   = get_bits1(&s->gb);
1879     spkmsk_bits = get_bits(&s->gb, 5) + 1;
1880     num_chsets  = get_bits(&s->gb, 2) + 1;
1881
1882     for (i = 0; i < num_chsets; i++)
1883         fsize[i] = get_bits(&s->gb, 14) + 1;
1884
1885     core_spk               = get_bits(&s->gb, spkmsk_bits);
1886     s->xxch_core_spkmask   = core_spk;
1887     s->xxch_nbits_spk_mask = spkmsk_bits;
1888     s->xxch_downmix        = 0;
1889     s->xxch_dmix_embedded  = 0;
1890
1891     /* skip to the end of the header */
1892     i = get_bits_count(&s->gb);
1893     if (hdr_pos + hdr_size * 8 > i)
1894         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
1895
1896     for (chset = 0; chset < num_chsets; chset++) {
1897         chstart       = get_bits_count(&s->gb);
1898         base_channel  = s->prim_channels;
1899         s->xxch_chset = chset;
1900
1901         /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
1902            5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
1903         dca_parse_audio_coding_header(s, base_channel, 1);
1904
1905         /* decode channel data */
1906         for (i = 0; i < (s->sample_blocks / 8); i++) {
1907             if (dca_decode_block(s, base_channel, i)) {
1908                 av_log(s->avctx, AV_LOG_ERROR,
1909                        "Error decoding DTS-XXCH extension\n");
1910                 continue;
1911             }
1912         }
1913
1914         /* skip to end of this section */
1915         i = get_bits_count(&s->gb);
1916         if (chstart + fsize[chset] * 8 > i)
1917             skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
1918     }
1919     s->xxch_chset = num_chsets;
1920
1921     return 0;
1922 }
1923
1924 /**
1925  * Parse extension substream header (HD)
1926  */
1927 static void dca_exss_parse_header(DCAContext *s)
1928 {
1929     int asset_size[8];
1930     int ss_index;
1931     int blownup;
1932     int num_audiop = 1;
1933     int num_assets = 1;
1934     int active_ss_mask[8];
1935     int i, j;
1936     int start_posn;
1937     int hdrsize;
1938     uint32_t mkr;
1939
1940     if (get_bits_left(&s->gb) < 52)
1941         return;
1942
1943     start_posn = get_bits_count(&s->gb) - 32;
1944
1945     skip_bits(&s->gb, 8); // user data
1946     ss_index = get_bits(&s->gb, 2);
1947
1948     blownup = get_bits1(&s->gb);
1949     hdrsize = get_bits(&s->gb,  8 + 4 * blownup) + 1; // header_size
1950     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
1951
1952     s->static_fields = get_bits1(&s->gb);
1953     if (s->static_fields) {
1954         skip_bits(&s->gb, 2); // reference clock code
1955         skip_bits(&s->gb, 3); // frame duration code
1956
1957         if (get_bits1(&s->gb))
1958             skip_bits_long(&s->gb, 36); // timestamp
1959
1960         /* a single stream can contain multiple audio assets that can be
1961          * combined to form multiple audio presentations */
1962
1963         num_audiop = get_bits(&s->gb, 3) + 1;
1964         if (num_audiop > 1) {
1965             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1966             /* ignore such streams for now */
1967             return;
1968         }
1969
1970         num_assets = get_bits(&s->gb, 3) + 1;
1971         if (num_assets > 1) {
1972             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1973             /* ignore such streams for now */
1974             return;
1975         }
1976
1977         for (i = 0; i < num_audiop; i++)
1978             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1979
1980         for (i = 0; i < num_audiop; i++)
1981             for (j = 0; j <= ss_index; j++)
1982                 if (active_ss_mask[i] & (1 << j))
1983                     skip_bits(&s->gb, 8); // active asset mask
1984
1985         s->mix_metadata = get_bits1(&s->gb);
1986         if (s->mix_metadata) {
1987             int mix_out_mask_size;
1988
1989             skip_bits(&s->gb, 2); // adjustment level
1990             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
1991             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
1992
1993             for (i = 0; i < s->num_mix_configs; i++) {
1994                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
1995                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1996             }
1997         }
1998     }
1999
2000     for (i = 0; i < num_assets; i++)
2001         asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
2002
2003     for (i = 0; i < num_assets; i++) {
2004         if (dca_exss_parse_asset_header(s))
2005             return;
2006     }
2007
2008     /* not parsed further, we were only interested in the extensions mask
2009      * from the asset header */
2010
2011     if (num_assets > 0) {
2012         j = get_bits_count(&s->gb);
2013         if (start_posn + hdrsize * 8 > j)
2014             skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
2015
2016         for (i = 0; i < num_assets; i++) {
2017             start_posn = get_bits_count(&s->gb);
2018             mkr        = get_bits_long(&s->gb, 32);
2019
2020             /* parse extensions that we know about */
2021             if (mkr == 0x655e315e) {
2022                 dca_xbr_parse_frame(s);
2023             } else if (mkr == 0x47004a03) {
2024                 dca_xxch_decode_frame(s);
2025                 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
2026             } else {
2027                 av_log(s->avctx, AV_LOG_DEBUG,
2028                        "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
2029             }
2030
2031             /* skip to end of block */
2032             j = get_bits_count(&s->gb);
2033             if (start_posn + asset_size[i] * 8 > j)
2034                 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
2035         }
2036     }
2037 }
2038
2039 /**
2040  * Main frame decoding function
2041  * FIXME add arguments
2042  */
2043 static int dca_decode_frame(AVCodecContext *avctx, void *data,
2044                             int *got_frame_ptr, AVPacket *avpkt)
2045 {
2046     const uint8_t *buf = avpkt->data;
2047     int buf_size = avpkt->size;
2048     int channel_mask;
2049     int channel_layout;
2050     int lfe_samples;
2051     int num_core_channels = 0;
2052     int i, ret;
2053     float *samples_flt;
2054     float *src_chan;
2055     float *dst_chan;
2056     int16_t *samples_s16;
2057     DCAContext *s = avctx->priv_data;
2058     int core_ss_end;
2059     int channels;
2060     float scale;
2061     int achan;
2062     int chset;
2063     int mask;
2064     int lavc;
2065     int posn;
2066     int j, k;
2067
2068     s->xch_present = 0;
2069
2070     s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
2071                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
2072     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
2073         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
2074         return AVERROR_INVALIDDATA;
2075     }
2076
2077     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
2078     if ((ret = dca_parse_frame_header(s)) < 0) {
2079         //seems like the frame is corrupt, try with the next one
2080         return ret;
2081     }
2082     //set AVCodec values with parsed data
2083     avctx->sample_rate = s->sample_rate;
2084     avctx->bit_rate    = s->bit_rate;
2085
2086     s->profile = FF_PROFILE_DTS;
2087
2088     for (i = 0; i < (s->sample_blocks / 8); i++) {
2089         if ((ret = dca_decode_block(s, 0, i))) {
2090             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
2091             return ret;
2092         }
2093     }
2094
2095     /* record number of core channels incase less than max channels are requested */
2096     num_core_channels = s->prim_channels;
2097
2098     if (s->ext_coding)
2099         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
2100     else
2101         s->core_ext_mask = 0;
2102
2103     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
2104
2105     /* only scan for extensions if ext_descr was unknown or indicated a
2106      * supported XCh extension */
2107     if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
2108
2109         /* if ext_descr was unknown, clear s->core_ext_mask so that the
2110          * extensions scan can fill it up */
2111         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
2112
2113         /* extensions start at 32-bit boundaries into bitstream */
2114         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2115
2116         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
2117             uint32_t bits = get_bits_long(&s->gb, 32);
2118
2119             switch (bits) {
2120             case 0x5a5a5a5a: {
2121                 int ext_amode, xch_fsize;
2122
2123                 s->xch_base_channel = s->prim_channels;
2124
2125                 /* validate sync word using XCHFSIZE field */
2126                 xch_fsize = show_bits(&s->gb, 10);
2127                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
2128                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
2129                     continue;
2130
2131                 /* skip length-to-end-of-frame field for the moment */
2132                 skip_bits(&s->gb, 10);
2133
2134                 s->core_ext_mask |= DCA_EXT_XCH;
2135
2136                 /* extension amode(number of channels in extension) should be 1 */
2137                 /* AFAIK XCh is not used for more channels */
2138                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
2139                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
2140                            " supported!\n", ext_amode);
2141                     continue;
2142                 }
2143
2144                 /* much like core primary audio coding header */
2145                 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
2146
2147                 for (i = 0; i < (s->sample_blocks / 8); i++)
2148                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
2149                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
2150                         continue;
2151                     }
2152
2153                 s->xch_present = 1;
2154                 break;
2155             }
2156             case 0x47004a03:
2157                 /* XXCh: extended channels */
2158                 /* usually found either in core or HD part in DTS-HD HRA streams,
2159                  * but not in DTS-ES which contains XCh extensions instead */
2160                 s->core_ext_mask |= DCA_EXT_XXCH;
2161                 dca_xxch_decode_frame(s);
2162                 break;
2163
2164             case 0x1d95f262: {
2165                 int fsize96 = show_bits(&s->gb, 12) + 1;
2166                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
2167                     continue;
2168
2169                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
2170                        get_bits_count(&s->gb));
2171                 skip_bits(&s->gb, 12);
2172                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
2173                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
2174
2175                 s->core_ext_mask |= DCA_EXT_X96;
2176                 break;
2177             }
2178             }
2179
2180             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
2181         }
2182     } else {
2183         /* no supported extensions, skip the rest of the core substream */
2184         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
2185     }
2186
2187     if (s->core_ext_mask & DCA_EXT_X96)
2188         s->profile = FF_PROFILE_DTS_96_24;
2189     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
2190         s->profile = FF_PROFILE_DTS_ES;
2191
2192     /* check for ExSS (HD part) */
2193     if (s->dca_buffer_size - s->frame_size > 32 &&
2194         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
2195         dca_exss_parse_header(s);
2196
2197     avctx->profile = s->profile;
2198
2199     channels = s->prim_channels + !!s->lfe;
2200
2201     /* If we have XXCH then the channel layout is managed differently */
2202     /* note that XLL will also have another way to do things */
2203     if (!(s->core_ext_mask & DCA_EXT_XXCH)
2204         || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
2205             && avctx->request_channels
2206             < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
2207     { /* xxx should also do MA extensions */
2208         if (s->amode < 16) {
2209             avctx->channel_layout = dca_core_channel_layout[s->amode];
2210
2211             if (s->xch_present && (!avctx->request_channels ||
2212                                    avctx->request_channels
2213                                    > num_core_channels + !!s->lfe)) {
2214                 avctx->channel_layout |= AV_CH_BACK_CENTER;
2215                 if (s->lfe) {
2216                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2217                     s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
2218                 } else {
2219                     s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
2220                 }
2221             } else {
2222                 channels = num_core_channels + !!s->lfe;
2223                 s->xch_present = 0; /* disable further xch processing */
2224                 if (s->lfe) {
2225                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
2226                     s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
2227                 } else
2228                     s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
2229             }
2230
2231             if (channels > !!s->lfe &&
2232                 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
2233                 return AVERROR_INVALIDDATA;
2234
2235             if (avctx->request_channels == 2 && s->prim_channels > 2) {
2236                 channels = 2;
2237                 s->output = DCA_STEREO;
2238                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
2239             }
2240             else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
2241                 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
2242                 s->channel_order_tab = dca_channel_order_native;
2243             }
2244             s->lfe_index = dca_lfe_index[s->amode];
2245         } else {
2246             av_log(avctx, AV_LOG_ERROR,
2247                    "Non standard configuration %d !\n", s->amode);
2248             return AVERROR_INVALIDDATA;
2249         }
2250
2251         s->xxch_downmix = 0;
2252     } else {
2253         /* we only get here if an XXCH channel set can be added to the mix */
2254         channel_mask = s->xxch_core_spkmask;
2255
2256         if (avctx->request_channels > 0
2257             && avctx->request_channels < s->prim_channels) {
2258             channels = num_core_channels + !!s->lfe;
2259             for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
2260                                               <= avctx->request_channels; i++) {
2261                 channels += s->xxch_chset_nch[i];
2262                 channel_mask |= s->xxch_spk_masks[i];
2263             }
2264         } else {
2265             channels = s->prim_channels + !!s->lfe;
2266             for (i = 0; i < s->xxch_chset; i++) {
2267                 channel_mask |= s->xxch_spk_masks[i];
2268             }
2269         }
2270
2271         /* Given the DTS spec'ed channel mask, generate an avcodec version */
2272         channel_layout = 0;
2273         for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
2274             if (channel_mask & (1 << i)) {
2275                 channel_layout |= map_xxch_to_native[i];
2276             }
2277         }
2278
2279         /* make sure that we have managed to get equivelant dts/avcodec channel
2280          * masks in some sense -- unfortunately some channels could overlap */
2281         if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
2282             av_log(avctx, AV_LOG_DEBUG,
2283                    "DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
2284             return AVERROR_INVALIDDATA;
2285         }
2286
2287         avctx->channel_layout = channel_layout;
2288
2289         if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
2290             /* Estimate DTS --> avcodec ordering table */
2291             for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
2292                 mask = chset >= 0 ? s->xxch_spk_masks[chset]
2293                                   : s->xxch_core_spkmask;
2294                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
2295                     if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
2296                         lavc = map_xxch_to_native[i];
2297                         posn = av_popcount(channel_layout & (lavc - 1));
2298                         s->xxch_order_tab[j++] = posn;
2299                     }
2300                 }
2301             }
2302
2303             s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
2304         } else { /* native ordering */
2305             for (i = 0; i < channels; i++)
2306                 s->xxch_order_tab[i] = i;
2307
2308             s->lfe_index = channels - 1;
2309         }
2310
2311         s->channel_order_tab = s->xxch_order_tab;
2312     }
2313
2314     if (avctx->channels != channels) {
2315         if (avctx->channels)
2316             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
2317         avctx->channels = channels;
2318     }
2319
2320     /* get output buffer */
2321     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
2322     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
2323         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2324         return ret;
2325     }
2326     samples_flt = (float *)   s->frame.data[0];
2327     samples_s16 = (int16_t *) s->frame.data[0];
2328
2329     /* filter to get final output */
2330     for (i = 0; i < (s->sample_blocks / 8); i++) {
2331         dca_filter_channels(s, i);
2332
2333         /* If this was marked as a DTS-ES stream we need to subtract back- */
2334         /* channel from SL & SR to remove matrixed back-channel signal */
2335         if ((s->source_pcm_res & 1) && s->xch_present) {
2336             float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel]     * 256;
2337             float *lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
2338             float *rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
2339             s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
2340             s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
2341         }
2342
2343         /* If stream contains XXCH, we might need to undo an embedded downmix */
2344         if (s->xxch_downmix & s->xxch_dmix_embedded) {
2345             mask = s->xxch_downmix & s->xxch_dmix_embedded;
2346             for (j = 0; j < channels; j++) {
2347                 if (mask & (1 << j)) { /* this channel has been mixed-out */
2348                     src_chan = s->samples + s->channel_order_tab[j] * 256;
2349                     for (k = 0; k < channels - !!s->lfe; k++) {
2350                         achan = s->channel_order_tab[k];
2351                         scale = s->xxch_dmix_coeff[j][k];
2352                         if (scale != 0.0) {
2353                             dst_chan = s->samples + achan * 256;
2354                             s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
2355                                                        -scale, 256);
2356                         }
2357                     }
2358                 }
2359             }
2360         }
2361
2362         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
2363             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
2364                                          channels);
2365             samples_flt += 256 * channels;
2366         } else {
2367             s->fmt_conv.float_to_int16_interleave(samples_s16,
2368                                                   s->samples_chanptr, 256,
2369                                                   channels);
2370             samples_s16 += 256 * channels;
2371         }
2372     }
2373
2374     /* update lfe history */
2375     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
2376     for (i = 0; i < 2 * s->lfe * 4; i++)
2377         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
2378
2379     *got_frame_ptr    = 1;
2380     *(AVFrame *) data = s->frame;
2381
2382     return buf_size;
2383 }
2384
2385
2386
2387 /**
2388  * DCA initialization
2389  *
2390  * @param avctx     pointer to the AVCodecContext
2391  */
2392
2393 static av_cold int dca_decode_init(AVCodecContext *avctx)
2394 {
2395     DCAContext *s = avctx->priv_data;
2396     int i;
2397
2398     s->avctx = avctx;
2399     dca_init_vlcs();
2400
2401     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
2402     ff_mdct_init(&s->imdct, 6, 1, 1.0);
2403     ff_synth_filter_init(&s->synth);
2404     ff_dcadsp_init(&s->dcadsp);
2405     ff_fmt_convert_init(&s->fmt_conv, avctx);
2406
2407     for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
2408         s->samples_chanptr[i] = s->samples + i * 256;
2409
2410     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
2411         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
2412         s->scale_bias     = 1.0 / 32768.0;
2413     } else {
2414         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
2415         s->scale_bias     = 1.0;
2416     }
2417
2418     /* allow downmixing to stereo */
2419     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
2420         avctx->request_channels == 2) {
2421         avctx->channels = avctx->request_channels;
2422     }
2423
2424     avcodec_get_frame_defaults(&s->frame);
2425     avctx->coded_frame = &s->frame;
2426
2427     return 0;
2428 }
2429
2430 static av_cold int dca_decode_end(AVCodecContext *avctx)
2431 {
2432     DCAContext *s = avctx->priv_data;
2433     ff_mdct_end(&s->imdct);
2434     return 0;
2435 }
2436
2437 static const AVProfile profiles[] = {
2438     { FF_PROFILE_DTS,        "DTS"        },
2439     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
2440     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
2441     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
2442     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
2443     { FF_PROFILE_UNKNOWN },
2444 };
2445
2446 AVCodec ff_dca_decoder = {
2447     .name            = "dca",
2448     .type            = AVMEDIA_TYPE_AUDIO,
2449     .id              = CODEC_ID_DTS,
2450     .priv_data_size  = sizeof(DCAContext),
2451     .init            = dca_decode_init,
2452     .decode          = dca_decode_frame,
2453     .close           = dca_decode_end,
2454     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
2455     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
2456     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
2457                                                        AV_SAMPLE_FMT_S16,
2458                                                        AV_SAMPLE_FMT_NONE },
2459     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
2460 };