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