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