dcadec: remove scaling in lfe_interpolation_fir
[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 #if ARCH_X86
54 #   include "x86/dca.h"
55 #endif
56
57 //#define TRACE
58
59 #define DCA_PRIM_CHANNELS_MAX  (7)
60 #define DCA_SUBBANDS          (32)
61 #define DCA_ABITS_MAX         (32)      /* Should be 28 */
62 #define DCA_SUBSUBFRAMES_MAX   (4)
63 #define DCA_SUBFRAMES_MAX     (16)
64 #define DCA_BLOCKS_MAX        (16)
65 #define DCA_LFE_MAX            (3)
66
67 enum DCAMode {
68     DCA_MONO = 0,
69     DCA_CHANNEL,
70     DCA_STEREO,
71     DCA_STEREO_SUMDIFF,
72     DCA_STEREO_TOTAL,
73     DCA_3F,
74     DCA_2F1R,
75     DCA_3F1R,
76     DCA_2F2R,
77     DCA_3F2R,
78     DCA_4F2R
79 };
80
81 /* these are unconfirmed but should be mostly correct */
82 enum DCAExSSSpeakerMask {
83     DCA_EXSS_FRONT_CENTER          = 0x0001,
84     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
85     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
86     DCA_EXSS_LFE                   = 0x0008,
87     DCA_EXSS_REAR_CENTER           = 0x0010,
88     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
89     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
90     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
91     DCA_EXSS_OVERHEAD              = 0x0100,
92     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
93     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
94     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
95     DCA_EXSS_LFE2                  = 0x1000,
96     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
97     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
98     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
99 };
100
101 enum DCAExtensionMask {
102     DCA_EXT_CORE       = 0x001, ///< core in core substream
103     DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
104     DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
105     DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
106     DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
107     DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
108     DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
109     DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
110     DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
111     DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
112 };
113
114 /* -1 are reserved or unknown */
115 static const int dca_ext_audio_descr_mask[] = {
116     DCA_EXT_XCH,
117     -1,
118     DCA_EXT_X96,
119     DCA_EXT_XCH | DCA_EXT_X96,
120     -1,
121     -1,
122     DCA_EXT_XXCH,
123     -1,
124 };
125
126 /* extensions that reside in core substream */
127 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
128
129 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
130  * Some compromises have been made for special configurations. Most configurations
131  * are never used so complete accuracy is not needed.
132  *
133  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
134  * S  -> side, when both rear and back are configured move one of them to the side channel
135  * OV -> center back
136  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
137  */
138 static const uint64_t dca_core_channel_layout[] = {
139     AV_CH_FRONT_CENTER,                                                     ///< 1, A
140     AV_CH_LAYOUT_STEREO,                                                    ///< 2, A + B (dual mono)
141     AV_CH_LAYOUT_STEREO,                                                    ///< 2, L + R (stereo)
142     AV_CH_LAYOUT_STEREO,                                                    ///< 2, (L + R) + (L - R) (sum-difference)
143     AV_CH_LAYOUT_STEREO,                                                    ///< 2, LT + RT (left and right total)
144     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               ///< 3, C + L + R
145     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                ///< 3, L + R + S
146     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           ///< 4, C + L + R + S
147     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               ///< 4, L + R + SL + SR
148
149     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
150     AV_CH_SIDE_RIGHT,                                                       ///< 5, C + L + R + SL + SR
151
152     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
153     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               ///< 6, CL + CR + L + R + SL + SR
154
155     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
156     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                ///< 6, C + L + R + LR + RR + OV
157
158     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
159     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
160     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 6, CF + CR + LF + RF + LR + RR
161
162     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
163     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
164     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     ///< 7, CL + C + CR + L + R + SL + SR
165
166     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
167     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
168     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
169
170     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
171     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
172     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 ///< 8, CL + C + CR + L + R + SL + S + SR
173 };
174
175 static const int8_t dca_lfe_index[] = {
176     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
177 };
178
179 static const int8_t dca_channel_reorder_lfe[][9] = {
180     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
181     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
182     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
183     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
184     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
185     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
186     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
187     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
188     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
189     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
190     { 3,  4,  0,  1,  5,  6, -1, -1, -1},
191     { 2,  0,  1,  4,  5,  6, -1, -1, -1},
192     { 0,  6,  4,  5,  2,  3, -1, -1, -1},
193     { 4,  2,  5,  0,  1,  6,  7, -1, -1},
194     { 5,  6,  0,  1,  7,  3,  8,  4, -1},
195     { 4,  2,  5,  0,  1,  6,  8,  7, -1},
196 };
197
198 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
199     { 0,  2, -1, -1, -1, -1, -1, -1, -1},
200     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
201     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
202     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
203     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
204     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
205     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
206     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
207     { 0,  1,  4,  5,  3, -1, -1, -1, -1},
208     { 2,  0,  1,  5,  6,  4, -1, -1, -1},
209     { 3,  4,  0,  1,  6,  7,  5, -1, -1},
210     { 2,  0,  1,  4,  5,  6,  7, -1, -1},
211     { 0,  6,  4,  5,  2,  3,  7, -1, -1},
212     { 4,  2,  5,  0,  1,  7,  8,  6, -1},
213     { 5,  6,  0,  1,  8,  3,  9,  4,  7},
214     { 4,  2,  5,  0,  1,  6,  9,  8,  7},
215 };
216
217 static const int8_t dca_channel_reorder_nolfe[][9] = {
218     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
219     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
220     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
221     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
222     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
223     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
224     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
225     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
226     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
227     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
228     { 2,  3,  0,  1,  4,  5, -1, -1, -1},
229     { 2,  0,  1,  3,  4,  5, -1, -1, -1},
230     { 0,  5,  3,  4,  1,  2, -1, -1, -1},
231     { 3,  2,  4,  0,  1,  5,  6, -1, -1},
232     { 4,  5,  0,  1,  6,  2,  7,  3, -1},
233     { 3,  2,  4,  0,  1,  5,  7,  6, -1},
234 };
235
236 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
237     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
238     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
239     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
240     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
241     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
242     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
243     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
244     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
245     { 0,  1,  3,  4,  2, -1, -1, -1, -1},
246     { 2,  0,  1,  4,  5,  3, -1, -1, -1},
247     { 2,  3,  0,  1,  5,  6,  4, -1, -1},
248     { 2,  0,  1,  3,  4,  5,  6, -1, -1},
249     { 0,  5,  3,  4,  1,  2,  6, -1, -1},
250     { 3,  2,  4,  0,  1,  6,  7,  5, -1},
251     { 4,  5,  0,  1,  7,  2,  8,  3,  6},
252     { 3,  2,  4,  0,  1,  5,  8,  7,  6},
253 };
254
255 #define DCA_DOLBY                  101           /* FIXME */
256
257 #define DCA_CHANNEL_BITS             6
258 #define DCA_CHANNEL_MASK          0x3F
259
260 #define DCA_LFE                   0x80
261
262 #define HEADER_SIZE                 14
263
264 #define DCA_MAX_FRAME_SIZE       16384
265 #define DCA_MAX_EXSS_HEADER_SIZE  4096
266
267 #define DCA_BUFFER_PADDING_SIZE   1024
268
269 #define DCA_NSYNCAUX        0x9A1105A0
270
271 /** Bit allocation */
272 typedef struct {
273     int offset;                 ///< code values offset
274     int maxbits[8];             ///< max bits in VLC
275     int wrap;                   ///< wrap for get_vlc2()
276     VLC vlc[8];                 ///< actual codes
277 } BitAlloc;
278
279 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
280 static BitAlloc dca_tmode;             ///< transition mode VLCs
281 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
282 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
283
284 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
285                                          int idx)
286 {
287     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
288            ba->offset;
289 }
290
291 typedef struct {
292     AVClass *class;             ///< class for AVOptions
293     AVCodecContext *avctx;
294     /* Frame header */
295     int frame_type;             ///< type of the current frame
296     int samples_deficit;        ///< deficit sample count
297     int crc_present;            ///< crc is present in the bitstream
298     int sample_blocks;          ///< number of PCM sample blocks
299     int frame_size;             ///< primary frame byte size
300     int amode;                  ///< audio channels arrangement
301     int sample_rate;            ///< audio sampling rate
302     int bit_rate;               ///< transmission bit rate
303     int bit_rate_index;         ///< transmission bit rate index
304
305     int dynrange;               ///< embedded dynamic range flag
306     int timestamp;              ///< embedded time stamp flag
307     int aux_data;               ///< auxiliary data flag
308     int hdcd;                   ///< source material is mastered in HDCD
309     int ext_descr;              ///< extension audio descriptor flag
310     int ext_coding;             ///< extended coding flag
311     int aspf;                   ///< audio sync word insertion flag
312     int lfe;                    ///< low frequency effects flag
313     int predictor_history;      ///< predictor history flag
314     int header_crc;             ///< header crc check bytes
315     int multirate_inter;        ///< multirate interpolator switch
316     int version;                ///< encoder software revision
317     int copy_history;           ///< copy history
318     int source_pcm_res;         ///< source pcm resolution
319     int front_sum;              ///< front sum/difference flag
320     int surround_sum;           ///< surround sum/difference flag
321     int dialog_norm;            ///< dialog normalisation parameter
322
323     /* Primary audio coding header */
324     int subframes;              ///< number of subframes
325     int total_channels;         ///< number of channels including extensions
326     int prim_channels;          ///< number of primary audio channels
327     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
328     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
329     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
330     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
331     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
332     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
333     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
334     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
335
336     /* Primary audio coding side information */
337     int subsubframes[DCA_SUBFRAMES_MAX];                         ///< number of subsubframes
338     int partial_samples[DCA_SUBFRAMES_MAX];                      ///< partial subsubframe samples count
339     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
340     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
341     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
342     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
343     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
344     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
345     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
346     float downmix_coef[DCA_PRIM_CHANNELS_MAX + 1][2];            ///< stereo downmix coefficients
347     int dynrange_coef;                                           ///< dynamic range coefficient
348
349     /* Core substream's embedded downmix coefficients (cf. ETSI TS 102 114 V1.4.1)
350      * Input:  primary audio channels (incl. LFE if present)
351      * Output: downmix audio channels (up to 4, no LFE) */
352     uint8_t  core_downmix;                                       ///< embedded downmix coefficients available
353     uint8_t  core_downmix_amode;                                 ///< audio channel arrangement of embedded downmix
354     uint16_t core_downmix_codes[DCA_PRIM_CHANNELS_MAX + 1][4];   ///< embedded downmix coefficients (9-bit codes)
355
356     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
357
358     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
359     int lfe_scale_factor;
360
361     /* Subband samples history (for ADPCM) */
362     DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
363     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
364     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
365     int hist_index[DCA_PRIM_CHANNELS_MAX];
366     DECLARE_ALIGNED(32, float, raXin)[32];
367
368     int output;                 ///< type of output
369
370     DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
371     float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
372     float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
373     uint8_t *extra_channels_buffer;
374     unsigned int extra_channels_buffer_size;
375
376     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
377     int dca_buffer_size;        ///< how much data is in the dca_buffer
378
379     const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe
380     GetBitContext gb;
381     /* Current position in DCA frame */
382     int current_subframe;
383     int current_subsubframe;
384
385     int core_ext_mask;          ///< present extensions in the core substream
386
387     /* XCh extension information */
388     int xch_present;            ///< XCh extension present and valid
389     int xch_base_channel;       ///< index of first (only) channel containing XCH data
390     int xch_disable;            ///< whether the XCh extension should be decoded or not
391
392     /* ExSS header parser */
393     int static_fields;          ///< static fields present
394     int mix_metadata;           ///< mixing metadata present
395     int num_mix_configs;        ///< number of mix out configurations
396     int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
397
398     int profile;
399
400     int debug_flag;             ///< used for suppressing repeated error messages output
401     AVFloatDSPContext fdsp;
402     FFTContext imdct;
403     SynthFilterContext synth;
404     DCADSPContext dcadsp;
405     FmtConvertContext fmt_conv;
406 } DCAContext;
407
408 static const uint16_t dca_vlc_offs[] = {
409         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
410      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
411      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
412      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
413     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
414     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
415 };
416
417 static av_cold void dca_init_vlcs(void)
418 {
419     static int vlcs_initialized = 0;
420     int i, j, c = 14;
421     static VLC_TYPE dca_table[23622][2];
422
423     if (vlcs_initialized)
424         return;
425
426     dca_bitalloc_index.offset = 1;
427     dca_bitalloc_index.wrap = 2;
428     for (i = 0; i < 5; i++) {
429         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
430         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
431         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
432                  bitalloc_12_bits[i], 1, 1,
433                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
434     }
435     dca_scalefactor.offset = -64;
436     dca_scalefactor.wrap = 2;
437     for (i = 0; i < 5; i++) {
438         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
439         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
440         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
441                  scales_bits[i], 1, 1,
442                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
443     }
444     dca_tmode.offset = 0;
445     dca_tmode.wrap = 1;
446     for (i = 0; i < 4; i++) {
447         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
448         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
449         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
450                  tmode_bits[i], 1, 1,
451                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
452     }
453
454     for (i = 0; i < 10; i++)
455         for (j = 0; j < 7; j++) {
456             if (!bitalloc_codes[i][j])
457                 break;
458             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
459             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
460             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
461             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
462
463             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
464                      bitalloc_sizes[i],
465                      bitalloc_bits[i][j], 1, 1,
466                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
467             c++;
468         }
469     vlcs_initialized = 1;
470 }
471
472 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
473 {
474     while (len--)
475         *dst++ = get_bits(gb, bits);
476 }
477
478 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
479 {
480     int i, j;
481     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
482     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
483     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
484
485     s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
486     s->prim_channels  = s->total_channels;
487
488     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
489         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
490
491
492     for (i = base_channel; i < s->prim_channels; i++) {
493         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
494         if (s->subband_activity[i] > DCA_SUBBANDS)
495             s->subband_activity[i] = DCA_SUBBANDS;
496     }
497     for (i = base_channel; i < s->prim_channels; i++) {
498         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
499         if (s->vq_start_subband[i] > DCA_SUBBANDS)
500             s->vq_start_subband[i] = DCA_SUBBANDS;
501     }
502     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
503     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
504     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
505     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
506
507     /* Get codebooks quantization indexes */
508     if (!base_channel)
509         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
510     for (j = 1; j < 11; j++)
511         for (i = base_channel; i < s->prim_channels; i++)
512             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
513
514     /* Get scale factor adjustment */
515     for (j = 0; j < 11; j++)
516         for (i = base_channel; i < s->prim_channels; i++)
517             s->scalefactor_adj[i][j] = 1;
518
519     for (j = 1; j < 11; j++)
520         for (i = base_channel; i < s->prim_channels; i++)
521             if (s->quant_index_huffman[i][j] < thr[j])
522                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
523
524     if (s->crc_present) {
525         /* Audio header CRC check */
526         get_bits(&s->gb, 16);
527     }
528
529     s->current_subframe    = 0;
530     s->current_subsubframe = 0;
531
532 #ifdef TRACE
533     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
534     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
535     for (i = base_channel; i < s->prim_channels; i++) {
536         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
537                s->subband_activity[i]);
538         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
539                s->vq_start_subband[i]);
540         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
541                s->joint_intensity[i]);
542         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
543                s->transient_huffman[i]);
544         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
545                s->scalefactor_huffman[i]);
546         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
547                s->bitalloc_huffman[i]);
548         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
549         for (j = 0; j < 11; j++)
550             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
551         av_log(s->avctx, AV_LOG_DEBUG, "\n");
552         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
553         for (j = 0; j < 11; j++)
554             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
555         av_log(s->avctx, AV_LOG_DEBUG, "\n");
556     }
557 #endif
558
559     return 0;
560 }
561
562 static int dca_parse_frame_header(DCAContext *s)
563 {
564     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
565
566     /* Sync code */
567     skip_bits_long(&s->gb, 32);
568
569     /* Frame header */
570     s->frame_type        = get_bits(&s->gb, 1);
571     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
572     s->crc_present       = get_bits(&s->gb, 1);
573     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
574     s->frame_size        = get_bits(&s->gb, 14) + 1;
575     if (s->frame_size < 95)
576         return AVERROR_INVALIDDATA;
577     s->amode             = get_bits(&s->gb, 6);
578     s->sample_rate       = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
579     if (!s->sample_rate)
580         return AVERROR_INVALIDDATA;
581     s->bit_rate_index    = get_bits(&s->gb, 5);
582     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
583     if (!s->bit_rate)
584         return AVERROR_INVALIDDATA;
585
586     skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
587     s->dynrange          = get_bits(&s->gb, 1);
588     s->timestamp         = get_bits(&s->gb, 1);
589     s->aux_data          = get_bits(&s->gb, 1);
590     s->hdcd              = get_bits(&s->gb, 1);
591     s->ext_descr         = get_bits(&s->gb, 3);
592     s->ext_coding        = get_bits(&s->gb, 1);
593     s->aspf              = get_bits(&s->gb, 1);
594     s->lfe               = get_bits(&s->gb, 2);
595     s->predictor_history = get_bits(&s->gb, 1);
596
597     if (s->lfe > 2) {
598         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
599         return AVERROR_INVALIDDATA;
600     }
601
602     /* TODO: check CRC */
603     if (s->crc_present)
604         s->header_crc    = get_bits(&s->gb, 16);
605
606     s->multirate_inter   = get_bits(&s->gb, 1);
607     s->version           = get_bits(&s->gb, 4);
608     s->copy_history      = get_bits(&s->gb, 2);
609     s->source_pcm_res    = get_bits(&s->gb, 3);
610     s->front_sum         = get_bits(&s->gb, 1);
611     s->surround_sum      = get_bits(&s->gb, 1);
612     s->dialog_norm       = get_bits(&s->gb, 4);
613
614     /* FIXME: channels mixing levels */
615     s->output = s->amode;
616     if (s->lfe)
617         s->output |= DCA_LFE;
618
619 #ifdef TRACE
620     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
621     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
622     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
623     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
624            s->sample_blocks, s->sample_blocks * 32);
625     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
626     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
627            s->amode, dca_channels[s->amode]);
628     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
629            s->sample_rate);
630     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
631            s->bit_rate);
632     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
633     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
634     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
635     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
636     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
637     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
638     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
639     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
640     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
641            s->predictor_history);
642     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
643     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
644            s->multirate_inter);
645     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
646     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
647     av_log(s->avctx, AV_LOG_DEBUG,
648            "source pcm resolution: %i (%i bits/sample)\n",
649            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
650     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
651     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
652     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
653     av_log(s->avctx, AV_LOG_DEBUG, "\n");
654 #endif
655
656     /* Primary audio coding header */
657     s->subframes         = get_bits(&s->gb, 4) + 1;
658
659     return dca_parse_audio_coding_header(s, 0);
660 }
661
662
663 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
664 {
665     if (level < 5) {
666         /* huffman encoded */
667         value += get_bitalloc(gb, &dca_scalefactor, level);
668         value = av_clip(value, 0, (1 << log2range) - 1);
669     } else if (level < 8) {
670         if (level + 1 > log2range) {
671             skip_bits(gb, level + 1 - log2range);
672             value = get_bits(gb, log2range);
673         } else {
674             value = get_bits(gb, level + 1);
675         }
676     }
677     return value;
678 }
679
680 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
681 {
682     /* Primary audio coding side information */
683     int j, k;
684
685     if (get_bits_left(&s->gb) < 0)
686         return AVERROR_INVALIDDATA;
687
688     if (!base_channel) {
689         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
690         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
691     }
692
693     for (j = base_channel; j < s->prim_channels; j++) {
694         for (k = 0; k < s->subband_activity[j]; k++)
695             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
696     }
697
698     /* Get prediction codebook */
699     for (j = base_channel; j < s->prim_channels; j++) {
700         for (k = 0; k < s->subband_activity[j]; k++) {
701             if (s->prediction_mode[j][k] > 0) {
702                 /* (Prediction coefficient VQ address) */
703                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
704             }
705         }
706     }
707
708     /* Bit allocation index */
709     for (j = base_channel; j < s->prim_channels; j++) {
710         for (k = 0; k < s->vq_start_subband[j]; k++) {
711             if (s->bitalloc_huffman[j] == 6)
712                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
713             else if (s->bitalloc_huffman[j] == 5)
714                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
715             else if (s->bitalloc_huffman[j] == 7) {
716                 av_log(s->avctx, AV_LOG_ERROR,
717                        "Invalid bit allocation index\n");
718                 return AVERROR_INVALIDDATA;
719             } else {
720                 s->bitalloc[j][k] =
721                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
722             }
723
724             if (s->bitalloc[j][k] > 26) {
725                 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
726                         j, k, s->bitalloc[j][k]);
727                 return AVERROR_INVALIDDATA;
728             }
729         }
730     }
731
732     /* Transition mode */
733     for (j = base_channel; j < s->prim_channels; j++) {
734         for (k = 0; k < s->subband_activity[j]; k++) {
735             s->transition_mode[j][k] = 0;
736             if (s->subsubframes[s->current_subframe] > 1 &&
737                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
738                 s->transition_mode[j][k] =
739                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
740             }
741         }
742     }
743
744     if (get_bits_left(&s->gb) < 0)
745         return AVERROR_INVALIDDATA;
746
747     for (j = base_channel; j < s->prim_channels; j++) {
748         const uint32_t *scale_table;
749         int scale_sum, log_size;
750
751         memset(s->scale_factor[j], 0,
752                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
753
754         if (s->scalefactor_huffman[j] == 6) {
755             scale_table = scale_factor_quant7;
756             log_size = 7;
757         } else {
758             scale_table = scale_factor_quant6;
759             log_size = 6;
760         }
761
762         /* When huffman coded, only the difference is encoded */
763         scale_sum = 0;
764
765         for (k = 0; k < s->subband_activity[j]; k++) {
766             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
767                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
768                 s->scale_factor[j][k][0] = scale_table[scale_sum];
769             }
770
771             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
772                 /* Get second scale factor */
773                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
774                 s->scale_factor[j][k][1] = scale_table[scale_sum];
775             }
776         }
777     }
778
779     /* Joint subband scale factor codebook select */
780     for (j = base_channel; j < s->prim_channels; j++) {
781         /* Transmitted only if joint subband coding enabled */
782         if (s->joint_intensity[j] > 0)
783             s->joint_huff[j] = get_bits(&s->gb, 3);
784     }
785
786     if (get_bits_left(&s->gb) < 0)
787         return AVERROR_INVALIDDATA;
788
789     /* Scale factors for joint subband coding */
790     for (j = base_channel; j < s->prim_channels; j++) {
791         int source_channel;
792
793         /* Transmitted only if joint subband coding enabled */
794         if (s->joint_intensity[j] > 0) {
795             int scale = 0;
796             source_channel = s->joint_intensity[j] - 1;
797
798             /* When huffman coded, only the difference is encoded
799              * (is this valid as well for joint scales ???) */
800
801             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
802                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
803                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
804             }
805
806             if (!(s->debug_flag & 0x02)) {
807                 av_log(s->avctx, AV_LOG_DEBUG,
808                        "Joint stereo coding not supported\n");
809                 s->debug_flag |= 0x02;
810             }
811         }
812     }
813
814     /* Dynamic range coefficient */
815     if (!base_channel && s->dynrange)
816         s->dynrange_coef = get_bits(&s->gb, 8);
817
818     /* Side information CRC check word */
819     if (s->crc_present) {
820         get_bits(&s->gb, 16);
821     }
822
823     /*
824      * Primary audio data arrays
825      */
826
827     /* VQ encoded high frequency subbands */
828     for (j = base_channel; j < s->prim_channels; j++)
829         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
830             /* 1 vector -> 32 samples */
831             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
832
833     /* Low frequency effect data */
834     if (!base_channel && s->lfe) {
835         /* LFE samples */
836         int lfe_samples = 2 * s->lfe * (4 + block_index);
837         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
838         float lfe_scale;
839
840         for (j = lfe_samples; j < lfe_end_sample; j++) {
841             /* Signed 8 bits int */
842             s->lfe_data[j] = get_sbits(&s->gb, 8);
843         }
844
845         /* Scale factor index */
846         skip_bits(&s->gb, 1);
847         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
848
849         /* Quantization step size * scale factor */
850         lfe_scale = 0.035 * s->lfe_scale_factor;
851
852         for (j = lfe_samples; j < lfe_end_sample; j++)
853             s->lfe_data[j] *= lfe_scale;
854     }
855
856 #ifdef TRACE
857     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
858            s->subsubframes[s->current_subframe]);
859     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
860            s->partial_samples[s->current_subframe]);
861
862     for (j = base_channel; j < s->prim_channels; j++) {
863         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
864         for (k = 0; k < s->subband_activity[j]; k++)
865             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
866         av_log(s->avctx, AV_LOG_DEBUG, "\n");
867     }
868     for (j = base_channel; j < s->prim_channels; j++) {
869         for (k = 0; k < s->subband_activity[j]; k++)
870             av_log(s->avctx, AV_LOG_DEBUG,
871                    "prediction coefs: %f, %f, %f, %f\n",
872                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
873                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
874                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
875                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
876     }
877     for (j = base_channel; j < s->prim_channels; j++) {
878         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
879         for (k = 0; k < s->vq_start_subband[j]; k++)
880             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
881         av_log(s->avctx, AV_LOG_DEBUG, "\n");
882     }
883     for (j = base_channel; j < s->prim_channels; j++) {
884         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
885         for (k = 0; k < s->subband_activity[j]; k++)
886             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
887         av_log(s->avctx, AV_LOG_DEBUG, "\n");
888     }
889     for (j = base_channel; j < s->prim_channels; j++) {
890         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
891         for (k = 0; k < s->subband_activity[j]; k++) {
892             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
893                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
894             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
895                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
896         }
897         av_log(s->avctx, AV_LOG_DEBUG, "\n");
898     }
899     for (j = base_channel; j < s->prim_channels; j++) {
900         if (s->joint_intensity[j] > 0) {
901             int source_channel = s->joint_intensity[j] - 1;
902             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
903             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
904                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
905             av_log(s->avctx, AV_LOG_DEBUG, "\n");
906         }
907     }
908     for (j = base_channel; j < s->prim_channels; j++)
909         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
910             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
911     if (!base_channel && s->lfe) {
912         int lfe_samples = 2 * s->lfe * (4 + block_index);
913         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
914
915         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
916         for (j = lfe_samples; j < lfe_end_sample; j++)
917             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
918         av_log(s->avctx, AV_LOG_DEBUG, "\n");
919     }
920 #endif
921
922     return 0;
923 }
924
925 static void qmf_32_subbands(DCAContext *s, int chans,
926                             float samples_in[32][8], float *samples_out,
927                             float scale)
928 {
929     const float *prCoeff;
930
931     int sb_act = s->subband_activity[chans];
932
933     scale *= sqrt(1 / 8.0);
934
935     /* Select filter */
936     if (!s->multirate_inter)    /* Non-perfect reconstruction */
937         prCoeff = fir_32bands_nonperfect;
938     else                        /* Perfect reconstruction */
939         prCoeff = fir_32bands_perfect;
940
941     s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
942                               s->subband_fir_hist[chans],
943                               &s->hist_index[chans],
944                               s->subband_fir_noidea[chans], prCoeff,
945                               samples_out, s->raXin, scale);
946 }
947
948 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
949                                   int num_deci_sample, float *samples_in,
950                                   float *samples_out)
951 {
952     /* samples_in: An array holding decimated samples.
953      *   Samples in current subframe starts from samples_in[0],
954      *   while samples_in[-1], samples_in[-2], ..., stores samples
955      *   from last subframe as history.
956      *
957      * samples_out: An array holding interpolated samples
958      */
959
960     int idx;
961     const float *prCoeff;
962     int deciindex;
963
964     /* Select decimation filter */
965     if (decimation_select == 1) {
966         idx = 1;
967         prCoeff = lfe_fir_128;
968     } else {
969         idx = 0;
970         prCoeff = lfe_fir_64;
971     }
972     /* Interpolation */
973     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
974         s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);
975         samples_in++;
976         samples_out += 2 * 32 * (1 + idx);
977     }
978 }
979
980 /* downmixing routines */
981 #define MIX_REAR1(samples, s1, rs, coef)            \
982     samples[0][i] += samples[s1][i] * coef[rs][0];  \
983     samples[1][i] += samples[s1][i] * coef[rs][1];
984
985 #define MIX_REAR2(samples, s1, s2, rs, coef)                                          \
986     samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
987     samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
988
989 #define MIX_FRONT3(samples, coef)                                      \
990     t = samples[c][i];                                                 \
991     u = samples[l][i];                                                 \
992     v = samples[r][i];                                                 \
993     samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0];  \
994     samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
995
996 #define DOWNMIX_TO_STEREO(op1, op2)             \
997     for (i = 0; i < 256; i++) {                 \
998         op1                                     \
999         op2                                     \
1000     }
1001
1002 static void dca_downmix(float **samples, int srcfmt, int lfe_present,
1003                         float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
1004                         const int8_t *channel_mapping)
1005 {
1006     int c, l, r, sl, sr, s;
1007     int i;
1008     float t, u, v;
1009
1010     switch (srcfmt) {
1011     case DCA_MONO:
1012     case DCA_4F2R:
1013         av_log(NULL, 0, "Not implemented!\n");
1014         break;
1015     case DCA_CHANNEL:
1016     case DCA_STEREO:
1017     case DCA_STEREO_TOTAL:
1018     case DCA_STEREO_SUMDIFF:
1019         break;
1020     case DCA_3F:
1021         c = channel_mapping[0];
1022         l = channel_mapping[1];
1023         r = channel_mapping[2];
1024         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
1025         break;
1026     case DCA_2F1R:
1027         s = channel_mapping[2];
1028         DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
1029         break;
1030     case DCA_3F1R:
1031         c = channel_mapping[0];
1032         l = channel_mapping[1];
1033         r = channel_mapping[2];
1034         s = channel_mapping[3];
1035         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1036                           MIX_REAR1(samples, s, 3, coef));
1037         break;
1038     case DCA_2F2R:
1039         sl = channel_mapping[2];
1040         sr = channel_mapping[3];
1041         DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
1042         break;
1043     case DCA_3F2R:
1044         c  = channel_mapping[0];
1045         l  = channel_mapping[1];
1046         r  = channel_mapping[2];
1047         sl = channel_mapping[3];
1048         sr = channel_mapping[4];
1049         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1050                           MIX_REAR2(samples, sl, sr, 3, coef));
1051         break;
1052     }
1053     if (lfe_present) {
1054         int lf_buf = dca_lfe_index[srcfmt];
1055         int lf_idx = dca_channels [srcfmt];
1056         for (i = 0; i < 256; i++) {
1057             samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
1058             samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
1059         }
1060     }
1061 }
1062
1063
1064 #ifndef decode_blockcodes
1065 /* Very compact version of the block code decoder that does not use table
1066  * look-up but is slightly slower */
1067 static int decode_blockcode(int code, int levels, int32_t *values)
1068 {
1069     int i;
1070     int offset = (levels - 1) >> 1;
1071
1072     for (i = 0; i < 4; i++) {
1073         int div = FASTDIV(code, levels);
1074         values[i] = code - offset - div * levels;
1075         code = div;
1076     }
1077
1078     return code;
1079 }
1080
1081 static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
1082 {
1083     return decode_blockcode(code1, levels, values) |
1084            decode_blockcode(code2, levels, values + 4);
1085 }
1086 #endif
1087
1088 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
1089 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
1090
1091 #ifndef int8x8_fmul_int32
1092 static inline void int8x8_fmul_int32(DCADSPContext *dsp, float *dst,
1093                                      const int8_t *src, int scale)
1094 {
1095     dsp->int8x8_fmul_int32(dst, src, scale);
1096 }
1097 #endif
1098
1099 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
1100 {
1101     int k, l;
1102     int subsubframe = s->current_subsubframe;
1103
1104     const float *quant_step_table;
1105
1106     /* FIXME */
1107     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1108     LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
1109
1110     /*
1111      * Audio data
1112      */
1113
1114     /* Select quantization step size table */
1115     if (s->bit_rate_index == 0x1f)
1116         quant_step_table = lossless_quant_d;
1117     else
1118         quant_step_table = lossy_quant_d;
1119
1120     for (k = base_channel; k < s->prim_channels; k++) {
1121         float rscale[DCA_SUBBANDS];
1122
1123         if (get_bits_left(&s->gb) < 0)
1124             return AVERROR_INVALIDDATA;
1125
1126         for (l = 0; l < s->vq_start_subband[k]; l++) {
1127             int m;
1128
1129             /* Select the mid-tread linear quantizer */
1130             int abits = s->bitalloc[k][l];
1131
1132             float quant_step_size = quant_step_table[abits];
1133
1134             /*
1135              * Determine quantization index code book and its type
1136              */
1137
1138             /* Select quantization index code book */
1139             int sel = s->quant_index_huffman[k][abits];
1140
1141             /*
1142              * Extract bits from the bit stream
1143              */
1144             if (!abits) {
1145                 rscale[l] = 0;
1146                 memset(block + 8 * l, 0, 8 * sizeof(block[0]));
1147             } else {
1148                 /* Deal with transients */
1149                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1150                 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
1151                                s->scalefactor_adj[k][sel];
1152
1153                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
1154                     if (abits <= 7) {
1155                         /* Block code */
1156                         int block_code1, block_code2, size, levels, err;
1157
1158                         size   = abits_sizes[abits - 1];
1159                         levels = abits_levels[abits - 1];
1160
1161                         block_code1 = get_bits(&s->gb, size);
1162                         block_code2 = get_bits(&s->gb, size);
1163                         err = decode_blockcodes(block_code1, block_code2,
1164                                                 levels, block + 8 * l);
1165                         if (err) {
1166                             av_log(s->avctx, AV_LOG_ERROR,
1167                                    "ERROR: block code look-up failed\n");
1168                             return AVERROR_INVALIDDATA;
1169                         }
1170                     } else {
1171                         /* no coding */
1172                         for (m = 0; m < 8; m++)
1173                             block[8 * l + m] = get_sbits(&s->gb, abits - 3);
1174                     }
1175                 } else {
1176                     /* Huffman coded */
1177                     for (m = 0; m < 8; m++)
1178                         block[8 * l + m] = get_bitalloc(&s->gb,
1179                                                 &dca_smpl_bitalloc[abits], sel);
1180                 }
1181
1182             }
1183         }
1184
1185         s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
1186                                                block, rscale, 8 * s->vq_start_subband[k]);
1187
1188         for (l = 0; l < s->vq_start_subband[k]; l++) {
1189             int m;
1190             /*
1191              * Inverse ADPCM if in prediction mode
1192              */
1193             if (s->prediction_mode[k][l]) {
1194                 int n;
1195                 for (m = 0; m < 8; m++) {
1196                     for (n = 1; n <= 4; n++)
1197                         if (m >= n)
1198                             subband_samples[k][l][m] +=
1199                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1200                                  subband_samples[k][l][m - n] / 8192);
1201                         else if (s->predictor_history)
1202                             subband_samples[k][l][m] +=
1203                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1204                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
1205                 }
1206             }
1207         }
1208
1209         /*
1210          * Decode VQ encoded high frequencies
1211          */
1212         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1213             /* 1 vector -> 32 samples but we only need the 8 samples
1214              * for this subsubframe. */
1215             int hfvq = s->high_freq_vq[k][l];
1216
1217             if (!s->debug_flag & 0x01) {
1218                 av_log(s->avctx, AV_LOG_DEBUG,
1219                        "Stream with high frequencies VQ coding\n");
1220                 s->debug_flag |= 0x01;
1221             }
1222
1223             int8x8_fmul_int32(&s->dcadsp, subband_samples[k][l],
1224                               &high_freq_vq[hfvq][subsubframe * 8],
1225                               s->scale_factor[k][l][0]);
1226         }
1227     }
1228
1229     /* Check for DSYNC after subsubframe */
1230     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1231         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1232 #ifdef TRACE
1233             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1234 #endif
1235         } else {
1236             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1237             return AVERROR_INVALIDDATA;
1238         }
1239     }
1240
1241     /* Backup predictor history for adpcm */
1242     for (k = base_channel; k < s->prim_channels; k++)
1243         for (l = 0; l < s->vq_start_subband[k]; l++)
1244             AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]);
1245
1246     return 0;
1247 }
1248
1249 static int dca_filter_channels(DCAContext *s, int block_index)
1250 {
1251     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1252     int k;
1253
1254     /* 32 subbands QMF */
1255     for (k = 0; k < s->prim_channels; k++) {
1256 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
1257                                             0, 8388608.0, 8388608.0 };*/
1258         if (s->channel_order_tab[k] >= 0)
1259             qmf_32_subbands(s, k, subband_samples[k],
1260                             s->samples_chanptr[s->channel_order_tab[k]],
1261                             M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
1262     }
1263
1264     /* Generate LFE samples for this subsubframe FIXME!!! */
1265     if (s->lfe) {
1266         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1267                               s->lfe_data + 2 * s->lfe * (block_index + 4),
1268                               s->samples_chanptr[dca_lfe_index[s->amode]]);
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 };