Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ 8a92ec71

History | View | Annotate | Download (68.6 KB)

1
/*
2
 * DCA compatible decoder
3
 * Copyright (C) 2004 Gildas Bazin
4
 * Copyright (C) 2004 Benjamin Zores
5
 * Copyright (C) 2006 Benjamin Larsson
6
 * Copyright (C) 2007 Konstantin Shishkov
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24

    
25
#include <math.h>
26
#include <stddef.h>
27
#include <stdio.h>
28

    
29
#include "libavutil/common.h"
30
#include "libavutil/intmath.h"
31
#include "libavutil/intreadwrite.h"
32
#include "libavcore/audioconvert.h"
33
#include "avcodec.h"
34
#include "dsputil.h"
35
#include "fft.h"
36
#include "get_bits.h"
37
#include "put_bits.h"
38
#include "dcadata.h"
39
#include "dcahuff.h"
40
#include "dca.h"
41
#include "synth_filter.h"
42
#include "dcadsp.h"
43

    
44
//#define TRACE
45

    
46
#define DCA_PRIM_CHANNELS_MAX (7)
47
#define DCA_SUBBANDS (32)
48
#define DCA_ABITS_MAX (32)      /* Should be 28 */
49
#define DCA_SUBSUBFRAMES_MAX (4)
50
#define DCA_SUBFRAMES_MAX (16)
51
#define DCA_BLOCKS_MAX (16)
52
#define DCA_LFE_MAX (3)
53

    
54
enum DCAMode {
55
    DCA_MONO = 0,
56
    DCA_CHANNEL,
57
    DCA_STEREO,
58
    DCA_STEREO_SUMDIFF,
59
    DCA_STEREO_TOTAL,
60
    DCA_3F,
61
    DCA_2F1R,
62
    DCA_3F1R,
63
    DCA_2F2R,
64
    DCA_3F2R,
65
    DCA_4F2R
66
};
67

    
68
/* these are unconfirmed but should be mostly correct */
69
enum DCAExSSSpeakerMask {
70
    DCA_EXSS_FRONT_CENTER          = 0x0001,
71
    DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
72
    DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
73
    DCA_EXSS_LFE                   = 0x0008,
74
    DCA_EXSS_REAR_CENTER           = 0x0010,
75
    DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
76
    DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
77
    DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
78
    DCA_EXSS_OVERHEAD              = 0x0100,
79
    DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
80
    DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
81
    DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
82
    DCA_EXSS_LFE2                  = 0x1000,
83
    DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
84
    DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
85
    DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
86
};
87

    
88
enum DCAExtensionMask {
89
    DCA_EXT_CORE       = 0x001, ///< core in core substream
90
    DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream
91
    DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream
92
    DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream
93
    DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)
94
    DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS
95
    DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS
96
    DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS
97
    DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS
98
    DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS
99
};
100

    
101
/* Tables for mapping dts channel configurations to libavcodec multichannel api.
102
 * Some compromises have been made for special configurations. Most configurations
103
 * are never used so complete accuracy is not needed.
104
 *
105
 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
106
 * S  -> side, when both rear and back are configured move one of them to the side channel
107
 * OV -> center back
108
 * All 2 channel configurations -> CH_LAYOUT_STEREO
109
 */
110

    
111
static const int64_t dca_core_channel_layout[] = {
112
    AV_CH_FRONT_CENTER,                                                      ///< 1, A
113
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, A + B (dual mono)
114
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, L + R (stereo)
115
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, (L+R) + (L-R) (sum-difference)
116
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, LT +RT (left and right total)
117
    AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER,                                  ///< 3, C+L+R
118
    AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER,                                   ///< 3, L+R+S
119
    AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|CH_BACK_CENTER,                   ///< 4, C + L + R+ S
120
    AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                    ///< 4, L + R +SL+ SR
121
    AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
122
    AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER,                    ///< 6, CL + CR + L + R + SL + SR
123
    AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT|AV_CH_FRONT_CENTER|AV_CH_BACK_CENTER,                                      ///< 6, C + L + R+ LR + RR + OV
124
    AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT,   ///< 6, CF+ CR+LF+ RF+LR + RR
125
    AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
126
    AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
127
    AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_BACK_CENTER|AV_CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
128
};
129

    
130
static const int8_t dca_lfe_index[] = {
131
    1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
132
};
133

    
134
static const int8_t dca_channel_reorder_lfe[][9] = {
135
    { 0, -1, -1, -1, -1, -1, -1, -1, -1},
136
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
137
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
138
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
139
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
140
    { 2,  0,  1, -1, -1, -1, -1, -1, -1},
141
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
142
    { 2,  0,  1,  4, -1, -1, -1, -1, -1},
143
    { 0,  1,  3,  4, -1, -1, -1, -1, -1},
144
    { 2,  0,  1,  4,  5, -1, -1, -1, -1},
145
    { 3,  4,  0,  1,  5,  6, -1, -1, -1},
146
    { 2,  0,  1,  4,  5,  6, -1, -1, -1},
147
    { 0,  6,  4,  5,  2,  3, -1, -1, -1},
148
    { 4,  2,  5,  0,  1,  6,  7, -1, -1},
149
    { 5,  6,  0,  1,  7,  3,  8,  4, -1},
150
    { 4,  2,  5,  0,  1,  6,  8,  7, -1},
151
};
152

    
153
static const int8_t dca_channel_reorder_lfe_xch[][9] = {
154
    { 0,  2, -1, -1, -1, -1, -1, -1, -1},
155
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
156
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
157
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
158
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
159
    { 2,  0,  1,  4, -1, -1, -1, -1, -1},
160
    { 0,  1,  3,  4, -1, -1, -1, -1, -1},
161
    { 2,  0,  1,  4,  5, -1, -1, -1, -1},
162
    { 0,  1,  4,  5,  3, -1, -1, -1, -1},
163
    { 2,  0,  1,  5,  6,  4, -1, -1, -1},
164
    { 3,  4,  0,  1,  6,  7,  5, -1, -1},
165
    { 2,  0,  1,  4,  5,  6,  7, -1, -1},
166
    { 0,  6,  4,  5,  2,  3,  7, -1, -1},
167
    { 4,  2,  5,  0,  1,  7,  8,  6, -1},
168
    { 5,  6,  0,  1,  8,  3,  9,  4,  7},
169
    { 4,  2,  5,  0,  1,  6,  9,  8,  7},
170
};
171

    
172
static const int8_t dca_channel_reorder_nolfe[][9] = {
173
    { 0, -1, -1, -1, -1, -1, -1, -1, -1},
174
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
175
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
176
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
177
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
178
    { 2,  0,  1, -1, -1, -1, -1, -1, -1},
179
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
180
    { 2,  0,  1,  3, -1, -1, -1, -1, -1},
181
    { 0,  1,  2,  3, -1, -1, -1, -1, -1},
182
    { 2,  0,  1,  3,  4, -1, -1, -1, -1},
183
    { 2,  3,  0,  1,  4,  5, -1, -1, -1},
184
    { 2,  0,  1,  3,  4,  5, -1, -1, -1},
185
    { 0,  5,  3,  4,  1,  2, -1, -1, -1},
186
    { 3,  2,  4,  0,  1,  5,  6, -1, -1},
187
    { 4,  5,  0,  1,  6,  2,  7,  3, -1},
188
    { 3,  2,  4,  0,  1,  5,  7,  6, -1},
189
};
190

    
191
static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
192
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
193
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
194
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
195
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
196
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
197
    { 2,  0,  1,  3, -1, -1, -1, -1, -1},
198
    { 0,  1,  2,  3, -1, -1, -1, -1, -1},
199
    { 2,  0,  1,  3,  4, -1, -1, -1, -1},
200
    { 0,  1,  3,  4,  2, -1, -1, -1, -1},
201
    { 2,  0,  1,  4,  5,  3, -1, -1, -1},
202
    { 2,  3,  0,  1,  5,  6,  4, -1, -1},
203
    { 2,  0,  1,  3,  4,  5,  6, -1, -1},
204
    { 0,  5,  3,  4,  1,  2,  6, -1, -1},
205
    { 3,  2,  4,  0,  1,  6,  7,  5, -1},
206
    { 4,  5,  0,  1,  7,  2,  8,  3,  6},
207
    { 3,  2,  4,  0,  1,  5,  8,  7,  6},
208
};
209

    
210
#define DCA_DOLBY 101           /* FIXME */
211

    
212
#define DCA_CHANNEL_BITS 6
213
#define DCA_CHANNEL_MASK 0x3F
214

    
215
#define DCA_LFE 0x80
216

    
217
#define HEADER_SIZE 14
218

    
219
#define DCA_MAX_FRAME_SIZE 16384
220
#define DCA_MAX_EXSS_HEADER_SIZE 4096
221

    
222
#define DCA_BUFFER_PADDING_SIZE 1024
223

    
224
/** Bit allocation */
225
typedef struct {
226
    int offset;                 ///< code values offset
227
    int maxbits[8];             ///< max bits in VLC
228
    int wrap;                   ///< wrap for get_vlc2()
229
    VLC vlc[8];                 ///< actual codes
230
} BitAlloc;
231

    
232
static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
233
static BitAlloc dca_tmode;             ///< transition mode VLCs
234
static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
235
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
236

    
237
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
238
{
239
    return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
240
}
241

    
242
typedef struct {
243
    AVCodecContext *avctx;
244
    /* Frame header */
245
    int frame_type;             ///< type of the current frame
246
    int samples_deficit;        ///< deficit sample count
247
    int crc_present;            ///< crc is present in the bitstream
248
    int sample_blocks;          ///< number of PCM sample blocks
249
    int frame_size;             ///< primary frame byte size
250
    int amode;                  ///< audio channels arrangement
251
    int sample_rate;            ///< audio sampling rate
252
    int bit_rate;               ///< transmission bit rate
253
    int bit_rate_index;         ///< transmission bit rate index
254

    
255
    int downmix;                ///< embedded downmix enabled
256
    int dynrange;               ///< embedded dynamic range flag
257
    int timestamp;              ///< embedded time stamp flag
258
    int aux_data;               ///< auxiliary data flag
259
    int hdcd;                   ///< source material is mastered in HDCD
260
    int ext_descr;              ///< extension audio descriptor flag
261
    int ext_coding;             ///< extended coding flag
262
    int aspf;                   ///< audio sync word insertion flag
263
    int lfe;                    ///< low frequency effects flag
264
    int predictor_history;      ///< predictor history flag
265
    int header_crc;             ///< header crc check bytes
266
    int multirate_inter;        ///< multirate interpolator switch
267
    int version;                ///< encoder software revision
268
    int copy_history;           ///< copy history
269
    int source_pcm_res;         ///< source pcm resolution
270
    int front_sum;              ///< front sum/difference flag
271
    int surround_sum;           ///< surround sum/difference flag
272
    int dialog_norm;            ///< dialog normalisation parameter
273

    
274
    /* Primary audio coding header */
275
    int subframes;              ///< number of subframes
276
    int is_channels_set;        ///< check for if the channel number is already set
277
    int total_channels;         ///< number of channels including extensions
278
    int prim_channels;          ///< number of primary audio channels
279
    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
280
    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
281
    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
282
    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
283
    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
284
    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
285
    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
286
    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
287

    
288
    /* Primary audio coding side information */
289
    int subsubframes[DCA_SUBFRAMES_MAX];           ///< number of subsubframes
290
    int partial_samples[DCA_SUBFRAMES_MAX];        ///< partial subsubframe samples count
291
    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
292
    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
293
    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
294
    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
295
    int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
296
    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
297
    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
298
    int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
299
    int dynrange_coef;                                           ///< dynamic range coefficient
300

    
301
    int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
302

    
303
    float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
304
    int lfe_scale_factor;
305

    
306
    /* Subband samples history (for ADPCM) */
307
    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
308
    DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
309
    DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
310
    int hist_index[DCA_PRIM_CHANNELS_MAX];
311
    DECLARE_ALIGNED(16, float, raXin)[32];
312

    
313
    int output;                 ///< type of output
314
    float scale_bias;           ///< output scale
315

    
316
    DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
317
    DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
318
    const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
319

    
320
    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
321
    int dca_buffer_size;        ///< how much data is in the dca_buffer
322

    
323
    const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
324
    GetBitContext gb;
325
    /* Current position in DCA frame */
326
    int current_subframe;
327
    int current_subsubframe;
328

    
329
    /* XCh extension information */
330
    int xch_present;
331
    int xch_base_channel;       ///< index of first (only) channel containing XCH data
332

    
333
    /* Other detected extensions in the core substream */
334
    int xxch_present;
335
    int x96_present;
336

    
337
    /* ExSS header parser */
338
    int static_fields;          ///< static fields present
339
    int mix_metadata;           ///< mixing metadata present
340
    int num_mix_configs;        ///< number of mix out configurations
341
    int mix_config_num_ch[4];   ///< number of channels in each mix out configuration
342

    
343
    int profile;
344

    
345
    int debug_flag;             ///< used for suppressing repeated error messages output
346
    DSPContext dsp;
347
    FFTContext imdct;
348
    SynthFilterContext synth;
349
    DCADSPContext dcadsp;
350
} DCAContext;
351

    
352
static const uint16_t dca_vlc_offs[] = {
353
        0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
354
     5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
355
     5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
356
     7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
357
    12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
358
    18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
359
};
360

    
361
static av_cold void dca_init_vlcs(void)
362
{
363
    static int vlcs_initialized = 0;
364
    int i, j, c = 14;
365
    static VLC_TYPE dca_table[23622][2];
366

    
367
    if (vlcs_initialized)
368
        return;
369

    
370
    dca_bitalloc_index.offset = 1;
371
    dca_bitalloc_index.wrap = 2;
372
    for (i = 0; i < 5; i++) {
373
        dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
374
        dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
375
        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
376
                 bitalloc_12_bits[i], 1, 1,
377
                 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
378
    }
379
    dca_scalefactor.offset = -64;
380
    dca_scalefactor.wrap = 2;
381
    for (i = 0; i < 5; i++) {
382
        dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
383
        dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
384
        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
385
                 scales_bits[i], 1, 1,
386
                 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
387
    }
388
    dca_tmode.offset = 0;
389
    dca_tmode.wrap = 1;
390
    for (i = 0; i < 4; i++) {
391
        dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
392
        dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
393
        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
394
                 tmode_bits[i], 1, 1,
395
                 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
396
    }
397

    
398
    for (i = 0; i < 10; i++)
399
        for (j = 0; j < 7; j++){
400
            if (!bitalloc_codes[i][j]) break;
401
            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
402
            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
403
            dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
404
            dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
405
            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
406
                     bitalloc_sizes[i],
407
                     bitalloc_bits[i][j], 1, 1,
408
                     bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
409
            c++;
410
        }
411
    vlcs_initialized = 1;
412
}
413

    
414
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
415
{
416
    while(len--)
417
        *dst++ = get_bits(gb, bits);
418
}
419

    
420
static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
421
{
422
    int i, j;
423
    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
424
    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
425
    static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
426

    
427
    s->total_channels    = get_bits(&s->gb, 3) + 1 + base_channel;
428
    s->prim_channels     = s->total_channels;
429

    
430
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
431
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;
432

    
433

    
434
    for (i = base_channel; i < s->prim_channels; i++) {
435
        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
436
        if (s->subband_activity[i] > DCA_SUBBANDS)
437
            s->subband_activity[i] = DCA_SUBBANDS;
438
    }
439
    for (i = base_channel; i < s->prim_channels; i++) {
440
        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
441
        if (s->vq_start_subband[i] > DCA_SUBBANDS)
442
            s->vq_start_subband[i] = DCA_SUBBANDS;
443
    }
444
    get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
445
    get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
446
    get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
447
    get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
448

    
449
    /* Get codebooks quantization indexes */
450
    if (!base_channel)
451
        memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
452
    for (j = 1; j < 11; j++)
453
        for (i = base_channel; i < s->prim_channels; i++)
454
            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
455

    
456
    /* Get scale factor adjustment */
457
    for (j = 0; j < 11; j++)
458
        for (i = base_channel; i < s->prim_channels; i++)
459
            s->scalefactor_adj[i][j] = 1;
460

    
461
    for (j = 1; j < 11; j++)
462
        for (i = base_channel; i < s->prim_channels; i++)
463
            if (s->quant_index_huffman[i][j] < thr[j])
464
                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
465

    
466
    if (s->crc_present) {
467
        /* Audio header CRC check */
468
        get_bits(&s->gb, 16);
469
    }
470

    
471
    s->current_subframe = 0;
472
    s->current_subsubframe = 0;
473

    
474
#ifdef TRACE
475
    av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
476
    av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
477
    for (i = base_channel; i < s->prim_channels; i++){
478
        av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
479
        av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
480
        av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
481
        av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
482
        av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
483
        av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
484
        av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
485
        for (j = 0; j < 11; j++)
486
            av_log(s->avctx, AV_LOG_DEBUG, " %i",
487
                   s->quant_index_huffman[i][j]);
488
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
489
        av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
490
        for (j = 0; j < 11; j++)
491
            av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
492
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
493
    }
494
#endif
495

    
496
  return 0;
497
}
498

    
499
static int dca_parse_frame_header(DCAContext * s)
500
{
501
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
502

    
503
    /* Sync code */
504
    get_bits(&s->gb, 32);
505

    
506
    /* Frame header */
507
    s->frame_type        = get_bits(&s->gb, 1);
508
    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
509
    s->crc_present       = get_bits(&s->gb, 1);
510
    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
511
    s->frame_size        = get_bits(&s->gb, 14) + 1;
512
    if (s->frame_size < 95)
513
        return -1;
514
    s->amode             = get_bits(&s->gb, 6);
515
    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
516
    if (!s->sample_rate)
517
        return -1;
518
    s->bit_rate_index    = get_bits(&s->gb, 5);
519
    s->bit_rate          = dca_bit_rates[s->bit_rate_index];
520
    if (!s->bit_rate)
521
        return -1;
522

    
523
    s->downmix           = get_bits(&s->gb, 1);
524
    s->dynrange          = get_bits(&s->gb, 1);
525
    s->timestamp         = get_bits(&s->gb, 1);
526
    s->aux_data          = get_bits(&s->gb, 1);
527
    s->hdcd              = get_bits(&s->gb, 1);
528
    s->ext_descr         = get_bits(&s->gb, 3);
529
    s->ext_coding        = get_bits(&s->gb, 1);
530
    s->aspf              = get_bits(&s->gb, 1);
531
    s->lfe               = get_bits(&s->gb, 2);
532
    s->predictor_history = get_bits(&s->gb, 1);
533

    
534
    /* TODO: check CRC */
535
    if (s->crc_present)
536
        s->header_crc    = get_bits(&s->gb, 16);
537

    
538
    s->multirate_inter   = get_bits(&s->gb, 1);
539
    s->version           = get_bits(&s->gb, 4);
540
    s->copy_history      = get_bits(&s->gb, 2);
541
    s->source_pcm_res    = get_bits(&s->gb, 3);
542
    s->front_sum         = get_bits(&s->gb, 1);
543
    s->surround_sum      = get_bits(&s->gb, 1);
544
    s->dialog_norm       = get_bits(&s->gb, 4);
545

    
546
    /* FIXME: channels mixing levels */
547
    s->output = s->amode;
548
    if (s->lfe) s->output |= DCA_LFE;
549

    
550
#ifdef TRACE
551
    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
552
    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
553
    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
554
    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
555
           s->sample_blocks, s->sample_blocks * 32);
556
    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
557
    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
558
           s->amode, dca_channels[s->amode]);
559
    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
560
           s->sample_rate);
561
    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
562
           s->bit_rate);
563
    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
564
    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
565
    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
566
    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
567
    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
568
    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
569
    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
570
    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
571
    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
572
    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
573
           s->predictor_history);
574
    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
575
    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
576
           s->multirate_inter);
577
    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
578
    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
579
    av_log(s->avctx, AV_LOG_DEBUG,
580
           "source pcm resolution: %i (%i bits/sample)\n",
581
           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
582
    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
583
    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
584
    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
585
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
586
#endif
587

    
588
    /* Primary audio coding header */
589
    s->subframes         = get_bits(&s->gb, 4) + 1;
590

    
591
    return dca_parse_audio_coding_header(s, 0);
592
}
593

    
594

    
595
static inline int get_scale(GetBitContext *gb, int level, int value)
596
{
597
   if (level < 5) {
598
       /* huffman encoded */
599
       value += get_bitalloc(gb, &dca_scalefactor, level);
600
   } else if (level < 8)
601
       value = get_bits(gb, level + 1);
602
   return value;
603
}
604

    
605
static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
606
{
607
    /* Primary audio coding side information */
608
    int j, k;
609

    
610
    if (get_bits_left(&s->gb) < 0)
611
        return -1;
612

    
613
    if (!base_channel) {
614
        s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
615
        s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
616
    }
617

    
618
    for (j = base_channel; j < s->prim_channels; j++) {
619
        for (k = 0; k < s->subband_activity[j]; k++)
620
            s->prediction_mode[j][k] = get_bits(&s->gb, 1);
621
    }
622

    
623
    /* Get prediction codebook */
624
    for (j = base_channel; j < s->prim_channels; j++) {
625
        for (k = 0; k < s->subband_activity[j]; k++) {
626
            if (s->prediction_mode[j][k] > 0) {
627
                /* (Prediction coefficient VQ address) */
628
                s->prediction_vq[j][k] = get_bits(&s->gb, 12);
629
            }
630
        }
631
    }
632

    
633
    /* Bit allocation index */
634
    for (j = base_channel; j < s->prim_channels; j++) {
635
        for (k = 0; k < s->vq_start_subband[j]; k++) {
636
            if (s->bitalloc_huffman[j] == 6)
637
                s->bitalloc[j][k] = get_bits(&s->gb, 5);
638
            else if (s->bitalloc_huffman[j] == 5)
639
                s->bitalloc[j][k] = get_bits(&s->gb, 4);
640
            else if (s->bitalloc_huffman[j] == 7) {
641
                av_log(s->avctx, AV_LOG_ERROR,
642
                       "Invalid bit allocation index\n");
643
                return -1;
644
            } else {
645
                s->bitalloc[j][k] =
646
                    get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
647
            }
648

    
649
            if (s->bitalloc[j][k] > 26) {
650
//                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
651
//                          j, k, s->bitalloc[j][k]);
652
                return -1;
653
            }
654
        }
655
    }
656

    
657
    /* Transition mode */
658
    for (j = base_channel; j < s->prim_channels; j++) {
659
        for (k = 0; k < s->subband_activity[j]; k++) {
660
            s->transition_mode[j][k] = 0;
661
            if (s->subsubframes[s->current_subframe] > 1 &&
662
                k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
663
                s->transition_mode[j][k] =
664
                    get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
665
            }
666
        }
667
    }
668

    
669
    if (get_bits_left(&s->gb) < 0)
670
        return -1;
671

    
672
    for (j = base_channel; j < s->prim_channels; j++) {
673
        const uint32_t *scale_table;
674
        int scale_sum;
675

    
676
        memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
677

    
678
        if (s->scalefactor_huffman[j] == 6)
679
            scale_table = scale_factor_quant7;
680
        else
681
            scale_table = scale_factor_quant6;
682

    
683
        /* When huffman coded, only the difference is encoded */
684
        scale_sum = 0;
685

    
686
        for (k = 0; k < s->subband_activity[j]; k++) {
687
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
688
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
689
                s->scale_factor[j][k][0] = scale_table[scale_sum];
690
            }
691

    
692
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
693
                /* Get second scale factor */
694
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
695
                s->scale_factor[j][k][1] = scale_table[scale_sum];
696
            }
697
        }
698
    }
699

    
700
    /* Joint subband scale factor codebook select */
701
    for (j = base_channel; j < s->prim_channels; j++) {
702
        /* Transmitted only if joint subband coding enabled */
703
        if (s->joint_intensity[j] > 0)
704
            s->joint_huff[j] = get_bits(&s->gb, 3);
705
    }
706

    
707
    if (get_bits_left(&s->gb) < 0)
708
        return -1;
709

    
710
    /* Scale factors for joint subband coding */
711
    for (j = base_channel; j < s->prim_channels; j++) {
712
        int source_channel;
713

    
714
        /* Transmitted only if joint subband coding enabled */
715
        if (s->joint_intensity[j] > 0) {
716
            int scale = 0;
717
            source_channel = s->joint_intensity[j] - 1;
718

    
719
            /* When huffman coded, only the difference is encoded
720
             * (is this valid as well for joint scales ???) */
721

    
722
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
723
                scale = get_scale(&s->gb, s->joint_huff[j], 0);
724
                scale += 64;    /* bias */
725
                s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
726
            }
727

    
728
            if (!(s->debug_flag & 0x02)) {
729
                av_log(s->avctx, AV_LOG_DEBUG,
730
                       "Joint stereo coding not supported\n");
731
                s->debug_flag |= 0x02;
732
            }
733
        }
734
    }
735

    
736
    /* Stereo downmix coefficients */
737
    if (!base_channel && s->prim_channels > 2) {
738
        if (s->downmix) {
739
            for (j = base_channel; j < s->prim_channels; j++) {
740
                s->downmix_coef[j][0] = get_bits(&s->gb, 7);
741
                s->downmix_coef[j][1] = get_bits(&s->gb, 7);
742
            }
743
        } else {
744
            int am = s->amode & DCA_CHANNEL_MASK;
745
            for (j = base_channel; j < s->prim_channels; j++) {
746
                s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
747
                s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
748
            }
749
        }
750
    }
751

    
752
    /* Dynamic range coefficient */
753
    if (!base_channel && s->dynrange)
754
        s->dynrange_coef = get_bits(&s->gb, 8);
755

    
756
    /* Side information CRC check word */
757
    if (s->crc_present) {
758
        get_bits(&s->gb, 16);
759
    }
760

    
761
    /*
762
     * Primary audio data arrays
763
     */
764

    
765
    /* VQ encoded high frequency subbands */
766
    for (j = base_channel; j < s->prim_channels; j++)
767
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
768
            /* 1 vector -> 32 samples */
769
            s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
770

    
771
    /* Low frequency effect data */
772
    if (!base_channel && s->lfe) {
773
        /* LFE samples */
774
        int lfe_samples = 2 * s->lfe * (4 + block_index);
775
        int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
776
        float lfe_scale;
777

    
778
        for (j = lfe_samples; j < lfe_end_sample; j++) {
779
            /* Signed 8 bits int */
780
            s->lfe_data[j] = get_sbits(&s->gb, 8);
781
        }
782

    
783
        /* Scale factor index */
784
        s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
785

    
786
        /* Quantization step size * scale factor */
787
        lfe_scale = 0.035 * s->lfe_scale_factor;
788

    
789
        for (j = lfe_samples; j < lfe_end_sample; j++)
790
            s->lfe_data[j] *= lfe_scale;
791
    }
792

    
793
#ifdef TRACE
794
    av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
795
    av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
796
           s->partial_samples[s->current_subframe]);
797
    for (j = base_channel; j < s->prim_channels; j++) {
798
        av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
799
        for (k = 0; k < s->subband_activity[j]; k++)
800
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
801
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
802
    }
803
    for (j = base_channel; j < s->prim_channels; j++) {
804
        for (k = 0; k < s->subband_activity[j]; k++)
805
                av_log(s->avctx, AV_LOG_DEBUG,
806
                       "prediction coefs: %f, %f, %f, %f\n",
807
                       (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
808
                       (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
809
                       (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
810
                       (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
811
    }
812
    for (j = base_channel; j < s->prim_channels; j++) {
813
        av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
814
        for (k = 0; k < s->vq_start_subband[j]; k++)
815
            av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
816
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
817
    }
818
    for (j = base_channel; j < s->prim_channels; j++) {
819
        av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
820
        for (k = 0; k < s->subband_activity[j]; k++)
821
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
822
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
823
    }
824
    for (j = base_channel; j < s->prim_channels; j++) {
825
        av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
826
        for (k = 0; k < s->subband_activity[j]; k++) {
827
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
828
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
829
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
830
                av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
831
        }
832
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
833
    }
834
    for (j = base_channel; j < s->prim_channels; j++) {
835
        if (s->joint_intensity[j] > 0) {
836
            int source_channel = s->joint_intensity[j] - 1;
837
            av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
838
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
839
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
840
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
841
        }
842
    }
843
    if (!base_channel && s->prim_channels > 2 && s->downmix) {
844
        av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
845
        for (j = 0; j < s->prim_channels; j++) {
846
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
847
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
848
        }
849
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
850
    }
851
    for (j = base_channel; j < s->prim_channels; j++)
852
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
853
            av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
854
    if (!base_channel && s->lfe) {
855
        int lfe_samples = 2 * s->lfe * (4 + block_index);
856
        int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
857

    
858
        av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
859
        for (j = lfe_samples; j < lfe_end_sample; j++)
860
            av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
861
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
862
    }
863
#endif
864

    
865
    return 0;
866
}
867

    
868
static void qmf_32_subbands(DCAContext * s, int chans,
869
                            float samples_in[32][8], float *samples_out,
870
                            float scale)
871
{
872
    const float *prCoeff;
873
    int i;
874

    
875
    int sb_act = s->subband_activity[chans];
876
    int subindex;
877

    
878
    scale *= sqrt(1/8.0);
879

    
880
    /* Select filter */
881
    if (!s->multirate_inter)    /* Non-perfect reconstruction */
882
        prCoeff = fir_32bands_nonperfect;
883
    else                        /* Perfect reconstruction */
884
        prCoeff = fir_32bands_perfect;
885

    
886
    /* Reconstructed channel sample index */
887
    for (subindex = 0; subindex < 8; subindex++) {
888
        /* Load in one sample from each subband and clear inactive subbands */
889
        for (i = 0; i < sb_act; i++){
890
            uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
891
            AV_WN32A(&s->raXin[i], v);
892
        }
893
        for (; i < 32; i++)
894
            s->raXin[i] = 0.0;
895

    
896
        s->synth.synth_filter_float(&s->imdct,
897
                              s->subband_fir_hist[chans], &s->hist_index[chans],
898
                              s->subband_fir_noidea[chans], prCoeff,
899
                              samples_out, s->raXin, scale);
900
        samples_out+= 32;
901

    
902
    }
903
}
904

    
905
static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
906
                                  int num_deci_sample, float *samples_in,
907
                                  float *samples_out, float scale)
908
{
909
    /* samples_in: An array holding decimated samples.
910
     *   Samples in current subframe starts from samples_in[0],
911
     *   while samples_in[-1], samples_in[-2], ..., stores samples
912
     *   from last subframe as history.
913
     *
914
     * samples_out: An array holding interpolated samples
915
     */
916

    
917
    int decifactor;
918
    const float *prCoeff;
919
    int deciindex;
920

    
921
    /* Select decimation filter */
922
    if (decimation_select == 1) {
923
        decifactor = 64;
924
        prCoeff = lfe_fir_128;
925
    } else {
926
        decifactor = 32;
927
        prCoeff = lfe_fir_64;
928
    }
929
    /* Interpolation */
930
    for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
931
        s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
932
                          scale);
933
        samples_in++;
934
        samples_out += 2 * decifactor;
935
    }
936
}
937

    
938
/* downmixing routines */
939
#define MIX_REAR1(samples, si1, rs, coef) \
940
     samples[i]     += samples[si1] * coef[rs][0];  \
941
     samples[i+256] += samples[si1] * coef[rs][1];
942

    
943
#define MIX_REAR2(samples, si1, si2, rs, coef) \
944
     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
945
     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
946

    
947
#define MIX_FRONT3(samples, coef) \
948
    t = samples[i+c]; \
949
    u = samples[i+l]; \
950
    v = samples[i+r]; \
951
    samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
952
    samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
953

    
954
#define DOWNMIX_TO_STEREO(op1, op2) \
955
    for (i = 0; i < 256; i++){ \
956
        op1 \
957
        op2 \
958
    }
959

    
960
static void dca_downmix(float *samples, int srcfmt,
961
                        int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
962
                        const int8_t *channel_mapping)
963
{
964
    int c,l,r,sl,sr,s;
965
    int i;
966
    float t, u, v;
967
    float coef[DCA_PRIM_CHANNELS_MAX][2];
968

    
969
    for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
970
        coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
971
        coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
972
    }
973

    
974
    switch (srcfmt) {
975
    case DCA_MONO:
976
    case DCA_CHANNEL:
977
    case DCA_STEREO_TOTAL:
978
    case DCA_STEREO_SUMDIFF:
979
    case DCA_4F2R:
980
        av_log(NULL, 0, "Not implemented!\n");
981
        break;
982
    case DCA_STEREO:
983
        break;
984
    case DCA_3F:
985
        c = channel_mapping[0] * 256;
986
        l = channel_mapping[1] * 256;
987
        r = channel_mapping[2] * 256;
988
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
989
        break;
990
    case DCA_2F1R:
991
        s = channel_mapping[2] * 256;
992
        DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef),);
993
        break;
994
    case DCA_3F1R:
995
        c = channel_mapping[0] * 256;
996
        l = channel_mapping[1] * 256;
997
        r = channel_mapping[2] * 256;
998
        s = channel_mapping[3] * 256;
999
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1000
                          MIX_REAR1(samples, i + s, 3, coef));
1001
        break;
1002
    case DCA_2F2R:
1003
        sl = channel_mapping[2] * 256;
1004
        sr = channel_mapping[3] * 256;
1005
        DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef),);
1006
        break;
1007
    case DCA_3F2R:
1008
        c =  channel_mapping[0] * 256;
1009
        l =  channel_mapping[1] * 256;
1010
        r =  channel_mapping[2] * 256;
1011
        sl = channel_mapping[3] * 256;
1012
        sr = channel_mapping[4] * 256;
1013
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
1014
                          MIX_REAR2(samples, i + sl, i + sr, 3, coef));
1015
        break;
1016
    }
1017
}
1018

    
1019

    
1020
/* Very compact version of the block code decoder that does not use table
1021
 * look-up but is slightly slower */
1022
static int decode_blockcode(int code, int levels, int *values)
1023
{
1024
    int i;
1025
    int offset = (levels - 1) >> 1;
1026

    
1027
    for (i = 0; i < 4; i++) {
1028
        int div = FASTDIV(code, levels);
1029
        values[i] = code - offset - div*levels;
1030
        code = div;
1031
    }
1032

    
1033
    if (code == 0)
1034
        return 0;
1035
    else {
1036
        av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
1037
        return -1;
1038
    }
1039
}
1040

    
1041
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
1042
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
1043

    
1044
static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
1045
{
1046
    int k, l;
1047
    int subsubframe = s->current_subsubframe;
1048

    
1049
    const float *quant_step_table;
1050

    
1051
    /* FIXME */
1052
    float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1053
    LOCAL_ALIGNED_16(int, block, [8]);
1054

    
1055
    /*
1056
     * Audio data
1057
     */
1058

    
1059
    /* Select quantization step size table */
1060
    if (s->bit_rate_index == 0x1f)
1061
        quant_step_table = lossless_quant_d;
1062
    else
1063
        quant_step_table = lossy_quant_d;
1064

    
1065
    for (k = base_channel; k < s->prim_channels; k++) {
1066
        if (get_bits_left(&s->gb) < 0)
1067
            return -1;
1068

    
1069
        for (l = 0; l < s->vq_start_subband[k]; l++) {
1070
            int m;
1071

    
1072
            /* Select the mid-tread linear quantizer */
1073
            int abits = s->bitalloc[k][l];
1074

    
1075
            float quant_step_size = quant_step_table[abits];
1076

    
1077
            /*
1078
             * Determine quantization index code book and its type
1079
             */
1080

    
1081
            /* Select quantization index code book */
1082
            int sel = s->quant_index_huffman[k][abits];
1083

    
1084
            /*
1085
             * Extract bits from the bit stream
1086
             */
1087
            if (!abits){
1088
                memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1089
            } else {
1090
                /* Deal with transients */
1091
                int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1092
                float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1093

    
1094
                if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1095
                    if (abits <= 7){
1096
                        /* Block code */
1097
                        int block_code1, block_code2, size, levels;
1098

    
1099
                        size = abits_sizes[abits-1];
1100
                        levels = abits_levels[abits-1];
1101

    
1102
                        block_code1 = get_bits(&s->gb, size);
1103
                        /* FIXME Should test return value */
1104
                        decode_blockcode(block_code1, levels, block);
1105
                        block_code2 = get_bits(&s->gb, size);
1106
                        decode_blockcode(block_code2, levels, &block[4]);
1107
                    }else{
1108
                        /* no coding */
1109
                        for (m = 0; m < 8; m++)
1110
                            block[m] = get_sbits(&s->gb, abits - 3);
1111
                    }
1112
                }else{
1113
                    /* Huffman coded */
1114
                    for (m = 0; m < 8; m++)
1115
                        block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1116
                }
1117

    
1118
                s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1119
                                                  block, rscale, 8);
1120
            }
1121

    
1122
            /*
1123
             * Inverse ADPCM if in prediction mode
1124
             */
1125
            if (s->prediction_mode[k][l]) {
1126
                int n;
1127
                for (m = 0; m < 8; m++) {
1128
                    for (n = 1; n <= 4; n++)
1129
                        if (m >= n)
1130
                            subband_samples[k][l][m] +=
1131
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1132
                                 subband_samples[k][l][m - n] / 8192);
1133
                        else if (s->predictor_history)
1134
                            subband_samples[k][l][m] +=
1135
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1136
                                 s->subband_samples_hist[k][l][m - n +
1137
                                                               4] / 8192);
1138
                }
1139
            }
1140
        }
1141

    
1142
        /*
1143
         * Decode VQ encoded high frequencies
1144
         */
1145
        for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1146
            /* 1 vector -> 32 samples but we only need the 8 samples
1147
             * for this subsubframe. */
1148
            int m;
1149

    
1150
            if (!s->debug_flag & 0x01) {
1151
                av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1152
                s->debug_flag |= 0x01;
1153
            }
1154

    
1155
            for (m = 0; m < 8; m++) {
1156
                subband_samples[k][l][m] =
1157
                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1158
                                                        m]
1159
                    * (float) s->scale_factor[k][l][0] / 16.0;
1160
            }
1161
        }
1162
    }
1163

    
1164
    /* Check for DSYNC after subsubframe */
1165
    if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1166
        if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1167
#ifdef TRACE
1168
            av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1169
#endif
1170
        } else {
1171
            av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1172
        }
1173
    }
1174

    
1175
    /* Backup predictor history for adpcm */
1176
    for (k = base_channel; k < s->prim_channels; k++)
1177
        for (l = 0; l < s->vq_start_subband[k]; l++)
1178
            memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1179
                        4 * sizeof(subband_samples[0][0][0]));
1180

    
1181
    return 0;
1182
}
1183

    
1184
static int dca_filter_channels(DCAContext * s, int block_index)
1185
{
1186
    float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1187
    int k;
1188

    
1189
    /* 32 subbands QMF */
1190
    for (k = 0; k < s->prim_channels; k++) {
1191
/*        static float pcm_to_double[8] =
1192
            {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1193
         qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1194
                         M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ );
1195
    }
1196

    
1197
    /* Down mixing */
1198
    if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1199
        dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
1200
    }
1201

    
1202
    /* Generate LFE samples for this subsubframe FIXME!!! */
1203
    if (s->output & DCA_LFE) {
1204
        lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1205
                              s->lfe_data + 2 * s->lfe * (block_index + 4),
1206
                              &s->samples[256 * dca_lfe_index[s->amode]],
1207
                              (1.0/256.0)*s->scale_bias);
1208
        /* Outputs 20bits pcm samples */
1209
    }
1210

    
1211
    return 0;
1212
}
1213

    
1214

    
1215
static int dca_subframe_footer(DCAContext * s, int base_channel)
1216
{
1217
    int aux_data_count = 0, i;
1218

    
1219
    /*
1220
     * Unpack optional information
1221
     */
1222

    
1223
    /* presumably optional information only appears in the core? */
1224
    if (!base_channel) {
1225
        if (s->timestamp)
1226
            get_bits(&s->gb, 32);
1227

    
1228
        if (s->aux_data)
1229
            aux_data_count = get_bits(&s->gb, 6);
1230

    
1231
        for (i = 0; i < aux_data_count; i++)
1232
            get_bits(&s->gb, 8);
1233

    
1234
        if (s->crc_present && (s->downmix || s->dynrange))
1235
            get_bits(&s->gb, 16);
1236
    }
1237

    
1238
    return 0;
1239
}
1240

    
1241
/**
1242
 * Decode a dca frame block
1243
 *
1244
 * @param s     pointer to the DCAContext
1245
 */
1246

    
1247
static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1248
{
1249

    
1250
    /* Sanity check */
1251
    if (s->current_subframe >= s->subframes) {
1252
        av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1253
               s->current_subframe, s->subframes);
1254
        return -1;
1255
    }
1256

    
1257
    if (!s->current_subsubframe) {
1258
#ifdef TRACE
1259
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1260
#endif
1261
        /* Read subframe header */
1262
        if (dca_subframe_header(s, base_channel, block_index))
1263
            return -1;
1264
    }
1265

    
1266
    /* Read subsubframe */
1267
#ifdef TRACE
1268
    av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1269
#endif
1270
    if (dca_subsubframe(s, base_channel, block_index))
1271
        return -1;
1272

    
1273
    /* Update state */
1274
    s->current_subsubframe++;
1275
    if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1276
        s->current_subsubframe = 0;
1277
        s->current_subframe++;
1278
    }
1279
    if (s->current_subframe >= s->subframes) {
1280
#ifdef TRACE
1281
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1282
#endif
1283
        /* Read subframe footer */
1284
        if (dca_subframe_footer(s, base_channel))
1285
            return -1;
1286
    }
1287

    
1288
    return 0;
1289
}
1290

    
1291
/**
1292
 * Convert bitstream to one representation based on sync marker
1293
 */
1294
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1295
                          int max_size)
1296
{
1297
    uint32_t mrk;
1298
    int i, tmp;
1299
    const uint16_t *ssrc = (const uint16_t *) src;
1300
    uint16_t *sdst = (uint16_t *) dst;
1301
    PutBitContext pb;
1302

    
1303
    if ((unsigned)src_size > (unsigned)max_size) {
1304
//        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1305
//        return -1;
1306
        src_size = max_size;
1307
    }
1308

    
1309
    mrk = AV_RB32(src);
1310
    switch (mrk) {
1311
    case DCA_MARKER_RAW_BE:
1312
        memcpy(dst, src, src_size);
1313
        return src_size;
1314
    case DCA_MARKER_RAW_LE:
1315
        for (i = 0; i < (src_size + 1) >> 1; i++)
1316
            *sdst++ = av_bswap16(*ssrc++);
1317
        return src_size;
1318
    case DCA_MARKER_14B_BE:
1319
    case DCA_MARKER_14B_LE:
1320
        init_put_bits(&pb, dst, max_size);
1321
        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1322
            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1323
            put_bits(&pb, 14, tmp);
1324
        }
1325
        flush_put_bits(&pb);
1326
        return (put_bits_count(&pb) + 7) >> 3;
1327
    default:
1328
        return -1;
1329
    }
1330
}
1331

    
1332
/**
1333
 * Return the number of channels in an ExSS speaker mask (HD)
1334
 */
1335
static int dca_exss_mask2count(int mask)
1336
{
1337
    /* count bits that mean speaker pairs twice */
1338
    return av_popcount(mask)
1339
        + av_popcount(mask & (
1340
            DCA_EXSS_CENTER_LEFT_RIGHT
1341
          | DCA_EXSS_FRONT_LEFT_RIGHT
1342
          | DCA_EXSS_FRONT_HIGH_LEFT_RIGHT
1343
          | DCA_EXSS_WIDE_LEFT_RIGHT
1344
          | DCA_EXSS_SIDE_LEFT_RIGHT
1345
          | DCA_EXSS_SIDE_HIGH_LEFT_RIGHT
1346
          | DCA_EXSS_SIDE_REAR_LEFT_RIGHT
1347
          | DCA_EXSS_REAR_LEFT_RIGHT
1348
          | DCA_EXSS_REAR_HIGH_LEFT_RIGHT
1349
          ));
1350
}
1351

    
1352
/**
1353
 * Skip mixing coefficients of a single mix out configuration (HD)
1354
 */
1355
static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1356
{
1357
    int i;
1358

    
1359
    for (i = 0; i < channels; i++) {
1360
        int mix_map_mask = get_bits(gb, out_ch);
1361
        int num_coeffs = av_popcount(mix_map_mask);
1362
        skip_bits_long(gb, num_coeffs * 6);
1363
    }
1364
}
1365

    
1366
/**
1367
 * Parse extension substream asset header (HD)
1368
 */
1369
static int dca_exss_parse_asset_header(DCAContext *s)
1370
{
1371
    int header_pos = get_bits_count(&s->gb);
1372
    int header_size;
1373
    int channels;
1374
    int embedded_stereo = 0;
1375
    int embedded_6ch = 0;
1376
    int drc_code_present;
1377
    int extensions_mask;
1378
    int i, j;
1379

    
1380
    if (get_bits_left(&s->gb) < 16)
1381
        return -1;
1382

    
1383
    /* We will parse just enough to get to the extensions bitmask with which
1384
     * we can set the profile value. */
1385

    
1386
    header_size = get_bits(&s->gb, 9) + 1;
1387
    skip_bits(&s->gb, 3); // asset index
1388

    
1389
    if (s->static_fields) {
1390
        if (get_bits1(&s->gb))
1391
            skip_bits(&s->gb, 4); // asset type descriptor
1392
        if (get_bits1(&s->gb))
1393
            skip_bits_long(&s->gb, 24); // language descriptor
1394

    
1395
        if (get_bits1(&s->gb)) {
1396
            /* How can one fit 1024 bytes of text here if the maximum value
1397
             * for the asset header size field above was 512 bytes? */
1398
            int text_length = get_bits(&s->gb, 10) + 1;
1399
            if (get_bits_left(&s->gb) < text_length * 8)
1400
                return -1;
1401
            skip_bits_long(&s->gb, text_length * 8); // info text
1402
        }
1403

    
1404
        skip_bits(&s->gb, 5); // bit resolution - 1
1405
        skip_bits(&s->gb, 4); // max sample rate code
1406
        channels = get_bits(&s->gb, 8) + 1;
1407

    
1408
        if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
1409
            int spkr_remap_sets;
1410
            int spkr_mask_size = 16;
1411
            int num_spkrs[7];
1412

    
1413
            if (channels > 2)
1414
                embedded_stereo = get_bits1(&s->gb);
1415
            if (channels > 6)
1416
                embedded_6ch = get_bits1(&s->gb);
1417

    
1418
            if (get_bits1(&s->gb)) {
1419
                spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1420
                skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
1421
            }
1422

    
1423
            spkr_remap_sets = get_bits(&s->gb, 3);
1424

    
1425
            for (i = 0; i < spkr_remap_sets; i++) {
1426
                /* std layout mask for each remap set */
1427
                num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
1428
            }
1429

    
1430
            for (i = 0; i < spkr_remap_sets; i++) {
1431
                int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
1432
                if (get_bits_left(&s->gb) < 0)
1433
                    return -1;
1434

    
1435
                for (j = 0; j < num_spkrs[i]; j++) {
1436
                    int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
1437
                    int num_dec_ch = av_popcount(remap_dec_ch_mask);
1438
                    skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
1439
                }
1440
            }
1441

    
1442
        } else {
1443
            skip_bits(&s->gb, 3); // representation type
1444
        }
1445
    }
1446

    
1447
    drc_code_present = get_bits1(&s->gb);
1448
    if (drc_code_present)
1449
        get_bits(&s->gb, 8); // drc code
1450

    
1451
    if (get_bits1(&s->gb))
1452
        skip_bits(&s->gb, 5); // dialog normalization code
1453

    
1454
    if (drc_code_present && embedded_stereo)
1455
        get_bits(&s->gb, 8); // drc stereo code
1456

    
1457
    if (s->mix_metadata && get_bits1(&s->gb)) {
1458
        skip_bits(&s->gb, 1); // external mix
1459
        skip_bits(&s->gb, 6); // post mix gain code
1460

    
1461
        if (get_bits(&s->gb, 2) != 3) // mixer drc code
1462
            skip_bits(&s->gb, 3); // drc limit
1463
        else
1464
            skip_bits(&s->gb, 8); // custom drc code
1465

    
1466
        if (get_bits1(&s->gb)) // channel specific scaling
1467
            for (i = 0; i < s->num_mix_configs; i++)
1468
                skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
1469
        else
1470
            skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
1471

    
1472
        for (i = 0; i < s->num_mix_configs; i++) {
1473
            if (get_bits_left(&s->gb) < 0)
1474
                return -1;
1475
            dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
1476
            if (embedded_6ch)
1477
                dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
1478
            if (embedded_stereo)
1479
                dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
1480
        }
1481
    }
1482

    
1483
    switch (get_bits(&s->gb, 2)) {
1484
    case 0: extensions_mask = get_bits(&s->gb, 12); break;
1485
    case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
1486
    case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
1487
    case 3: extensions_mask = 0; /* aux coding */   break;
1488
    }
1489

    
1490
    /* not parsed further, we were only interested in the extensions mask */
1491

    
1492
    if (get_bits_left(&s->gb) < 0)
1493
        return -1;
1494

    
1495
    if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
1496
        av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
1497
        return -1;
1498
    }
1499
    skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
1500

    
1501
    if (extensions_mask & DCA_EXT_EXSS_XLL)
1502
        s->profile = FF_PROFILE_DTS_HD_MA;
1503
    else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
1504
                                DCA_EXT_EXSS_XXCH))
1505
        s->profile = FF_PROFILE_DTS_HD_HRA;
1506

    
1507
    if (!(extensions_mask & DCA_EXT_CORE))
1508
        av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
1509
    if (!!(extensions_mask & DCA_EXT_XCH) != s->xch_present)
1510
        av_log(s->avctx, AV_LOG_WARNING, "DTS XCh detection mismatch.\n");
1511
    if (!!(extensions_mask & DCA_EXT_XXCH) != s->xxch_present)
1512
        av_log(s->avctx, AV_LOG_WARNING, "DTS XXCh detection mismatch.\n");
1513
    if (!!(extensions_mask & DCA_EXT_X96) != s->x96_present)
1514
        av_log(s->avctx, AV_LOG_WARNING, "DTS X96 detection mismatch.\n");
1515

    
1516
    return 0;
1517
}
1518

    
1519
/**
1520
 * Parse extension substream header (HD)
1521
 */
1522
static void dca_exss_parse_header(DCAContext *s)
1523
{
1524
    int ss_index;
1525
    int blownup;
1526
    int header_size;
1527
    int hd_size;
1528
    int num_audiop = 1;
1529
    int num_assets = 1;
1530
    int active_ss_mask[8];
1531
    int i, j;
1532

    
1533
    if (get_bits_left(&s->gb) < 52)
1534
        return;
1535

    
1536
    skip_bits(&s->gb, 8); // user data
1537
    ss_index = get_bits(&s->gb, 2);
1538

    
1539
    blownup = get_bits1(&s->gb);
1540
    header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
1541
    hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
1542

    
1543
    s->static_fields = get_bits1(&s->gb);
1544
    if (s->static_fields) {
1545
        skip_bits(&s->gb, 2); // reference clock code
1546
        skip_bits(&s->gb, 3); // frame duration code
1547

    
1548
        if (get_bits1(&s->gb))
1549
            skip_bits_long(&s->gb, 36); // timestamp
1550

    
1551
        /* a single stream can contain multiple audio assets that can be
1552
         * combined to form multiple audio presentations */
1553

    
1554
        num_audiop = get_bits(&s->gb, 3) + 1;
1555
        if (num_audiop > 1) {
1556
            av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
1557
            /* ignore such streams for now */
1558
            return;
1559
        }
1560

    
1561
        num_assets = get_bits(&s->gb, 3) + 1;
1562
        if (num_assets > 1) {
1563
            av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
1564
            /* ignore such streams for now */
1565
            return;
1566
        }
1567

    
1568
        for (i = 0; i < num_audiop; i++)
1569
            active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
1570

    
1571
        for (i = 0; i < num_audiop; i++)
1572
            for (j = 0; j <= ss_index; j++)
1573
                if (active_ss_mask[i] & (1 << j))
1574
                    skip_bits(&s->gb, 8); // active asset mask
1575

    
1576
        s->mix_metadata = get_bits1(&s->gb);
1577
        if (s->mix_metadata) {
1578
            int mix_out_mask_size;
1579

    
1580
            skip_bits(&s->gb, 2); // adjustment level
1581
            mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
1582
            s->num_mix_configs = get_bits(&s->gb, 2) + 1;
1583

    
1584
            for (i = 0; i < s->num_mix_configs; i++) {
1585
                int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
1586
                s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
1587
            }
1588
        }
1589
    }
1590

    
1591
    for (i = 0; i < num_assets; i++)
1592
        skip_bits_long(&s->gb, 16 + 4 * blownup); // asset size
1593

    
1594
    for (i = 0; i < num_assets; i++) {
1595
        if (dca_exss_parse_asset_header(s))
1596
            return;
1597
    }
1598

    
1599
    /* not parsed further, we were only interested in the extensions mask
1600
     * from the asset header */
1601
}
1602

    
1603
/**
1604
 * Main frame decoding function
1605
 * FIXME add arguments
1606
 */
1607
static int dca_decode_frame(AVCodecContext * avctx,
1608
                            void *data, int *data_size,
1609
                            AVPacket *avpkt)
1610
{
1611
    const uint8_t *buf = avpkt->data;
1612
    int buf_size = avpkt->size;
1613

    
1614
    int lfe_samples;
1615
    int num_core_channels = 0;
1616
    int i;
1617
    int16_t *samples = data;
1618
    DCAContext *s = avctx->priv_data;
1619
    int channels;
1620
    int core_ss_end;
1621

    
1622

    
1623
    s->xch_present = 0;
1624
    s->x96_present = 0;
1625
    s->xxch_present = 0;
1626

    
1627
    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
1628
                                               DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
1629
    if (s->dca_buffer_size == -1) {
1630
        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1631
        return -1;
1632
    }
1633

    
1634
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1635
    if (dca_parse_frame_header(s) < 0) {
1636
        //seems like the frame is corrupt, try with the next one
1637
        *data_size=0;
1638
        return buf_size;
1639
    }
1640
    //set AVCodec values with parsed data
1641
    avctx->sample_rate = s->sample_rate;
1642
    avctx->bit_rate = s->bit_rate;
1643

    
1644
    s->profile = FF_PROFILE_DTS;
1645

    
1646
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1647
        dca_decode_block(s, 0, i);
1648
    }
1649

    
1650
    /* record number of core channels incase less than max channels are requested */
1651
    num_core_channels = s->prim_channels;
1652

    
1653
    /* extensions start at 32-bit boundaries into bitstream */
1654
    skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1655

    
1656
    core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1657

    
1658
    while(core_ss_end - get_bits_count(&s->gb) >= 32) {
1659
        uint32_t bits = get_bits_long(&s->gb, 32);
1660

    
1661
        switch(bits) {
1662
        case 0x5a5a5a5a: {
1663
            int ext_amode, xch_fsize;
1664

    
1665
            s->xch_base_channel = s->prim_channels;
1666

    
1667
            /* validate sync word using XCHFSIZE field */
1668
            xch_fsize = show_bits(&s->gb, 10);
1669
            if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1670
               (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1671
                continue;
1672

    
1673
            /* skip length-to-end-of-frame field for the moment */
1674
            skip_bits(&s->gb, 10);
1675

    
1676
            s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1677

    
1678
            /* extension amode should == 1, number of channels in extension */
1679
            /* AFAIK XCh is not used for more channels */
1680
            if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1681
                av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1682
                       " supported!\n",ext_amode);
1683
                continue;
1684
            }
1685

    
1686
            /* much like core primary audio coding header */
1687
            dca_parse_audio_coding_header(s, s->xch_base_channel);
1688

    
1689
            for (i = 0; i < (s->sample_blocks / 8); i++) {
1690
                dca_decode_block(s, s->xch_base_channel, i);
1691
            }
1692

    
1693
            s->xch_present = 1;
1694
            break;
1695
        }
1696
        case 0x47004a03:
1697
            /* XXCh: extended channels */
1698
            /* usually found either in core or HD part in DTS-HD HRA streams,
1699
             * but not in DTS-ES which contains XCh extensions instead */
1700
            s->xxch_present = 1;
1701
            s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1702
            break;
1703

    
1704
        case 0x1d95f262: {
1705
            int fsize96 = show_bits(&s->gb, 12) + 1;
1706
            if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
1707
                continue;
1708

    
1709
            av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
1710
            skip_bits(&s->gb, 12);
1711
            av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
1712
            av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1713

    
1714
            s->x96_present = 1;
1715
            s->profile = FFMAX(s->profile, FF_PROFILE_DTS_96_24);
1716
            break;
1717
        }
1718
        }
1719

    
1720
        skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1721
    }
1722

    
1723
    /* check for ExSS (HD part) */
1724
    if (s->dca_buffer_size - s->frame_size > 32
1725
        && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
1726
        dca_exss_parse_header(s);
1727

    
1728
    avctx->profile = s->profile;
1729

    
1730
    channels = s->prim_channels + !!s->lfe;
1731

    
1732
    if (s->amode<16) {
1733
        avctx->channel_layout = dca_core_channel_layout[s->amode];
1734

    
1735
        if (s->xch_present && (!avctx->request_channels ||
1736
                               avctx->request_channels > num_core_channels + !!s->lfe)) {
1737
            avctx->channel_layout |= AV_CH_BACK_CENTER;
1738
            if (s->lfe) {
1739
                avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1740
                s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1741
            } else {
1742
                s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1743
            }
1744
        } else {
1745
            channels = num_core_channels + !!s->lfe;
1746
            s->xch_present = 0; /* disable further xch processing */
1747
            if (s->lfe) {
1748
                avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1749
                s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1750
            } else
1751
                s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1752
        }
1753

    
1754
        if (channels > !!s->lfe &&
1755
            s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
1756
            return -1;
1757

    
1758
        if (avctx->request_channels == 2 && s->prim_channels > 2) {
1759
            channels = 2;
1760
            s->output = DCA_STEREO;
1761
            avctx->channel_layout = AV_CH_LAYOUT_STEREO;
1762
        }
1763
    } else {
1764
        av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1765
        return -1;
1766
    }
1767

    
1768

    
1769
    /* There is nothing that prevents a dts frame to change channel configuration
1770
       but FFmpeg doesn't support that so only set the channels if it is previously
1771
       unset. Ideally during the first probe for channels the crc should be checked
1772
       and only set avctx->channels when the crc is ok. Right now the decoder could
1773
       set the channels based on a broken first frame.*/
1774
    if (s->is_channels_set == 0) {
1775
        s->is_channels_set = 1;
1776
        avctx->channels = channels;
1777
    }
1778
    if (avctx->channels != channels) {
1779
        av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
1780
               "channels changing in stream. Skipping frame.\n");
1781
        return -1;
1782
    }
1783

    
1784
    if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1785
        return -1;
1786
    *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1787

    
1788
    /* filter to get final output */
1789
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1790
        dca_filter_channels(s, i);
1791

    
1792
        /* If this was marked as a DTS-ES stream we need to subtract back- */
1793
        /* channel from SL & SR to remove matrixed back-channel signal */
1794
        if((s->source_pcm_res & 1) && s->xch_present) {
1795
            float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1796
            float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1797
            float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1798
            int j;
1799
            for(j = 0; j < 256; ++j) {
1800
                lt_chan[j] -= back_chan[j] * M_SQRT1_2;
1801
                rt_chan[j] -= back_chan[j] * M_SQRT1_2;
1802
            }
1803
        }
1804

    
1805
        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1806
        samples += 256 * channels;
1807
    }
1808

    
1809
    /* update lfe history */
1810
    lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1811
    for (i = 0; i < 2 * s->lfe * 4; i++) {
1812
        s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1813
    }
1814

    
1815
    return buf_size;
1816
}
1817

    
1818

    
1819

    
1820
/**
1821
 * DCA initialization
1822
 *
1823
 * @param avctx     pointer to the AVCodecContext
1824
 */
1825

    
1826
static av_cold int dca_decode_init(AVCodecContext * avctx)
1827
{
1828
    DCAContext *s = avctx->priv_data;
1829
    int i;
1830

    
1831
    s->avctx = avctx;
1832
    dca_init_vlcs();
1833

    
1834
    dsputil_init(&s->dsp, avctx);
1835
    ff_mdct_init(&s->imdct, 6, 1, 1.0);
1836
    ff_synth_filter_init(&s->synth);
1837
    ff_dcadsp_init(&s->dcadsp);
1838

    
1839
    for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1840
        s->samples_chanptr[i] = s->samples + i * 256;
1841
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1842

    
1843
    s->scale_bias = 1.0;
1844

    
1845
    /* allow downmixing to stereo */
1846
    if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1847
        avctx->request_channels == 2) {
1848
        avctx->channels = avctx->request_channels;
1849
    }
1850

    
1851
    return 0;
1852
}
1853

    
1854
static av_cold int dca_decode_end(AVCodecContext * avctx)
1855
{
1856
    DCAContext *s = avctx->priv_data;
1857
    ff_mdct_end(&s->imdct);
1858
    return 0;
1859
}
1860

    
1861
static const AVProfile profiles[] = {
1862
    { FF_PROFILE_DTS,        "DTS"        },
1863
    { FF_PROFILE_DTS_ES,     "DTS-ES"     },
1864
    { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
1865
    { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
1866
    { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
1867
    { FF_PROFILE_UNKNOWN },
1868
};
1869

    
1870
AVCodec ff_dca_decoder = {
1871
    .name = "dca",
1872
    .type = AVMEDIA_TYPE_AUDIO,
1873
    .id = CODEC_ID_DTS,
1874
    .priv_data_size = sizeof(DCAContext),
1875
    .init = dca_decode_init,
1876
    .decode = dca_decode_frame,
1877
    .close = dca_decode_end,
1878
    .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1879
    .capabilities = CODEC_CAP_CHANNEL_CONF,
1880
    .profiles = NULL_IF_CONFIG_SMALL(profiles),
1881
};