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