Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ 1360f07e

History | View | Annotate | Download (68.9 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 add_bias;             ///< output bias
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
} DCAContext;
352

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

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

    
368
    if (vlcs_initialized)
369
        return;
370

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

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

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

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

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

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

    
434

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

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

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

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

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

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

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

    
497
  return 0;
498
}
499

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

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

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

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

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

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

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

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

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

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

    
595

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
866
    return 0;
867
}
868

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

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

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

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

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

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

    
903
    }
904
}
905

    
906
static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
907
                                  int num_deci_sample, float *samples_in,
908
                                  float *samples_out, float scale,
909
                                  float bias)
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, bias);
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] - add_bias) * coef[rs][0];  \
943
     samples[i+256] += (samples[si1] - add_bias) * coef[rs][1];
944

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

    
949
#define MIX_FRONT3(samples, coef) \
950
    t = samples[i+c] - add_bias; \
951
    u = samples[i+l] - add_bias; \
952
    v = samples[i+r] - add_bias; \
953
    samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0] + add_bias; \
954
    samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1] + add_bias;
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, float add_bias)
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->dsp.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
                            s->add_bias );
1198
    }
1199

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

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

    
1214
    return 0;
1215
}
1216

    
1217

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

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

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

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

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

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

    
1241
    return 0;
1242
}
1243

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

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

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

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

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

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

    
1291
    return 0;
1292
}
1293

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

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

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

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

    
1355
/**
1356
 * Skip mixing coefficients of a single mix out configuration (HD)
1357
 */
1358
static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
1359
{
1360
    for (int i = 0; i < channels; i++) {
1361
        int mix_map_mask = get_bits(gb, out_ch);
1362
        int num_coeffs = av_popcount(mix_map_mask);
1363
        skip_bits_long(gb, num_coeffs * 6);
1364
    }
1365
}
1366

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1502
    if (extensions_mask & DCA_EXT_EXSS_XLL)
1503
        s->profile = FF_PROFILE_DTS_HD_MA;
1504
    else if (extensions_mask & DCA_EXT_EXSS_XBR)
1505
        s->profile = FF_PROFILE_DTS_HD_HRA;
1506
    else if (extensions_mask & DCA_EXT_EXSS_X96)
1507
        s->profile = FF_PROFILE_DTS_96_24;
1508
    else if (extensions_mask & DCA_EXT_EXSS_XXCH)
1509
        s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1510

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

    
1520
    return 0;
1521
}
1522

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

    
1537
    if (get_bits_left(&s->gb) < 52)
1538
        return;
1539

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1626

    
1627
    s->xch_present = 0;
1628
    s->x96_present = 0;
1629
    s->xxch_present = 0;
1630

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

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

    
1648
    s->profile = FF_PROFILE_DTS;
1649

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

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

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

    
1660
    core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
1661

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

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

    
1669
            s->xch_base_channel = s->prim_channels;
1670

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

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

    
1680
            s->profile = FFMAX(s->profile, FF_PROFILE_DTS_ES);
1681

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

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

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

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

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

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

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

    
1724
        skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1725
    }
1726

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

    
1732
    avctx->profile = s->profile;
1733

    
1734
    channels = s->prim_channels + !!s->lfe;
1735

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

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

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

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

    
1772

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

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

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

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

    
1809
        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1810
        samples += 256 * channels;
1811
    }
1812

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

    
1819
    return buf_size;
1820
}
1821

    
1822

    
1823

    
1824
/**
1825
 * DCA initialization
1826
 *
1827
 * @param avctx     pointer to the AVCodecContext
1828
 */
1829

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

    
1835
    s->avctx = avctx;
1836
    dca_init_vlcs();
1837

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

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

    
1847
    if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1848
        s->add_bias = 385.0f;
1849
        s->scale_bias = 1.0 / 32768.0;
1850
    } else {
1851
        s->add_bias = 0.0f;
1852
        s->scale_bias = 1.0;
1853

    
1854
        /* allow downmixing to stereo */
1855
        if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1856
                avctx->request_channels == 2) {
1857
            avctx->channels = avctx->request_channels;
1858
        }
1859
    }
1860

    
1861

    
1862
    return 0;
1863
}
1864

    
1865
static av_cold int dca_decode_end(AVCodecContext * avctx)
1866
{
1867
    DCAContext *s = avctx->priv_data;
1868
    ff_mdct_end(&s->imdct);
1869
    return 0;
1870
}
1871

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