Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ fe2ff6d2

History | View | Annotate | Download (68.7 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
#include "fmtconvert.h"
44

    
45
//#define TRACE
46

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

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

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

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

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

    
112
static const int64_t dca_core_channel_layout[] = {
113
    AV_CH_FRONT_CENTER,                                                      ///< 1, A
114
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, A + B (dual mono)
115
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, L + R (stereo)
116
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, (L+R) + (L-R) (sum-difference)
117
    AV_CH_LAYOUT_STEREO,                                                     ///< 2, LT +RT (left and right total)
118
    AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER,                                  ///< 3, C+L+R
119
    AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER,                                   ///< 3, L+R+S
120
    AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|CH_BACK_CENTER,                   ///< 4, C + L + R+ S
121
    AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                    ///< 4, L + R +SL+ SR
122
    AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
123
    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
124
    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
125
    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
126
    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
127
    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
128
    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
129
};
130

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

    
135
static const int8_t dca_channel_reorder_lfe[][9] = {
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
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
141
    { 2,  0,  1, -1, -1, -1, -1, -1, -1},
142
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
143
    { 2,  0,  1,  4, -1, -1, -1, -1, -1},
144
    { 0,  1,  3,  4, -1, -1, -1, -1, -1},
145
    { 2,  0,  1,  4,  5, -1, -1, -1, -1},
146
    { 3,  4,  0,  1,  5,  6, -1, -1, -1},
147
    { 2,  0,  1,  4,  5,  6, -1, -1, -1},
148
    { 0,  6,  4,  5,  2,  3, -1, -1, -1},
149
    { 4,  2,  5,  0,  1,  6,  7, -1, -1},
150
    { 5,  6,  0,  1,  7,  3,  8,  4, -1},
151
    { 4,  2,  5,  0,  1,  6,  8,  7, -1},
152
};
153

    
154
static const int8_t dca_channel_reorder_lfe_xch[][9] = {
155
    { 0,  2, -1, -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
    { 0,  1,  3, -1, -1, -1, -1, -1, -1},
160
    { 2,  0,  1,  4, -1, -1, -1, -1, -1},
161
    { 0,  1,  3,  4, -1, -1, -1, -1, -1},
162
    { 2,  0,  1,  4,  5, -1, -1, -1, -1},
163
    { 0,  1,  4,  5,  3, -1, -1, -1, -1},
164
    { 2,  0,  1,  5,  6,  4, -1, -1, -1},
165
    { 3,  4,  0,  1,  6,  7,  5, -1, -1},
166
    { 2,  0,  1,  4,  5,  6,  7, -1, -1},
167
    { 0,  6,  4,  5,  2,  3,  7, -1, -1},
168
    { 4,  2,  5,  0,  1,  7,  8,  6, -1},
169
    { 5,  6,  0,  1,  8,  3,  9,  4,  7},
170
    { 4,  2,  5,  0,  1,  6,  9,  8,  7},
171
};
172

    
173
static const int8_t dca_channel_reorder_nolfe[][9] = {
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
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
179
    { 2,  0,  1, -1, -1, -1, -1, -1, -1},
180
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
181
    { 2,  0,  1,  3, -1, -1, -1, -1, -1},
182
    { 0,  1,  2,  3, -1, -1, -1, -1, -1},
183
    { 2,  0,  1,  3,  4, -1, -1, -1, -1},
184
    { 2,  3,  0,  1,  4,  5, -1, -1, -1},
185
    { 2,  0,  1,  3,  4,  5, -1, -1, -1},
186
    { 0,  5,  3,  4,  1,  2, -1, -1, -1},
187
    { 3,  2,  4,  0,  1,  5,  6, -1, -1},
188
    { 4,  5,  0,  1,  6,  2,  7,  3, -1},
189
    { 3,  2,  4,  0,  1,  5,  7,  6, -1},
190
};
191

    
192
static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
193
    { 0,  1, -1, -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
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
198
    { 2,  0,  1,  3, -1, -1, -1, -1, -1},
199
    { 0,  1,  2,  3, -1, -1, -1, -1, -1},
200
    { 2,  0,  1,  3,  4, -1, -1, -1, -1},
201
    { 0,  1,  3,  4,  2, -1, -1, -1, -1},
202
    { 2,  0,  1,  4,  5,  3, -1, -1, -1},
203
    { 2,  3,  0,  1,  5,  6,  4, -1, -1},
204
    { 2,  0,  1,  3,  4,  5,  6, -1, -1},
205
    { 0,  5,  3,  4,  1,  2,  6, -1, -1},
206
    { 3,  2,  4,  0,  1,  6,  7,  5, -1},
207
    { 4,  5,  0,  1,  7,  2,  8,  3,  6},
208
    { 3,  2,  4,  0,  1,  5,  8,  7,  6},
209
};
210

    
211
#define DCA_DOLBY 101           /* FIXME */
212

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

    
216
#define DCA_LFE 0x80
217

    
218
#define HEADER_SIZE 14
219

    
220
#define DCA_MAX_FRAME_SIZE 16384
221
#define DCA_MAX_EXSS_HEADER_SIZE 4096
222

    
223
#define DCA_BUFFER_PADDING_SIZE 1024
224

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
344
    int profile;
345

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

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

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

    
369
    if (vlcs_initialized)
370
        return;
371

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

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

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

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

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

    
432
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
433
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;
434

    
435

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

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

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

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

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

    
473
    s->current_subframe = 0;
474
    s->current_subsubframe = 0;
475

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

    
498
  return 0;
499
}
500

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

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

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

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

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

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

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

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

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

    
593
    return dca_parse_audio_coding_header(s, 0);
594
}
595

    
596

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

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

    
612
    if (get_bits_left(&s->gb) < 0)
613
        return -1;
614

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

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

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

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

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

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

    
671
    if (get_bits_left(&s->gb) < 0)
672
        return -1;
673

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

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

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

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

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

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

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

    
709
    if (get_bits_left(&s->gb) < 0)
710
        return -1;
711

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

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

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

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

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

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

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

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

    
763
    /*
764
     * Primary audio data arrays
765
     */
766

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

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

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

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

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

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

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

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

    
867
    return 0;
868
}
869

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

    
877
    int sb_act = s->subband_activity[chans];
878
    int subindex;
879

    
880
    scale *= sqrt(1/8.0);
881

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

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

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

    
904
    }
905
}
906

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

    
919
    int decifactor;
920
    const float *prCoeff;
921
    int deciindex;
922

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

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

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

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

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

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

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

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

    
1021

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

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

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

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

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

    
1051
    const float *quant_step_table;
1052

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

    
1057
    /*
1058
     * Audio data
1059
     */
1060

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

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

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

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

    
1077
            float quant_step_size = quant_step_table[abits];
1078

    
1079
            /*
1080
             * Determine quantization index code book and its type
1081
             */
1082

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

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

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

    
1101
                        size = abits_sizes[abits-1];
1102
                        levels = abits_levels[abits-1];
1103

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

    
1120
                s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
1121
                                                  block, rscale, 8);
1122
            }
1123

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

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

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

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

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

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

    
1183
    return 0;
1184
}
1185

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

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

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

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

    
1213
    return 0;
1214
}
1215

    
1216

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

    
1221
    /*
1222
     * Unpack optional information
1223
     */
1224

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

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

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

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

    
1240
    return 0;
1241
}
1242

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

    
1249
static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1250
{
1251

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

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

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

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

    
1290
    return 0;
1291
}
1292

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

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

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

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

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

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

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

    
1382
    if (get_bits_left(&s->gb) < 16)
1383
        return -1;
1384

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

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

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

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

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

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

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

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

    
1425
            spkr_remap_sets = get_bits(&s->gb, 3);
1426

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

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

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

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

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

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

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

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

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

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

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

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

    
1492
    /* not parsed further, we were only interested in the extensions mask */
1493

    
1494
    if (get_bits_left(&s->gb) < 0)
1495
        return -1;
1496

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

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

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

    
1518
    return 0;
1519
}
1520

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

    
1535
    if (get_bits_left(&s->gb) < 52)
1536
        return;
1537

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1624

    
1625
    s->xch_present = 0;
1626
    s->x96_present = 0;
1627
    s->xxch_present = 0;
1628

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

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

    
1646
    s->profile = FF_PROFILE_DTS;
1647

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

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

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

    
1658
    core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1659

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

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

    
1667
            s->xch_base_channel = s->prim_channels;
1668

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

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

    
1678
            s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1679

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

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

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

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

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

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

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

    
1722
        skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1723
    }
1724

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

    
1730
    avctx->profile = s->profile;
1731

    
1732
    channels = s->prim_channels + !!s->lfe;
1733

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

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

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

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

    
1770

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

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

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

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

    
1807
        s->fmt_conv.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1808
        samples += 256 * channels;
1809
    }
1810

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

    
1817
    return buf_size;
1818
}
1819

    
1820

    
1821

    
1822
/**
1823
 * DCA initialization
1824
 *
1825
 * @param avctx     pointer to the AVCodecContext
1826
 */
1827

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

    
1833
    s->avctx = avctx;
1834
    dca_init_vlcs();
1835

    
1836
    dsputil_init(&s->dsp, avctx);
1837
    ff_mdct_init(&s->imdct, 6, 1, 1.0);
1838
    ff_synth_filter_init(&s->synth);
1839
    ff_dcadsp_init(&s->dcadsp);
1840
    ff_fmt_convert_init(&s->fmt_conv, avctx);
1841

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

    
1846
    s->scale_bias = 1.0;
1847

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

    
1854
    return 0;
1855
}
1856

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

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

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