Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ 63c3b716

History | View | Annotate | Download (48.4 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/intmath.h"
30
#include "libavutil/intreadwrite.h"
31
#include "avcodec.h"
32
#include "dsputil.h"
33
#include "fft.h"
34
#include "get_bits.h"
35
#include "put_bits.h"
36
#include "dcadata.h"
37
#include "dcahuff.h"
38
#include "dca.h"
39
#include "synth_filter.h"
40
#include "dcadsp.h"
41

    
42
//#define TRACE
43

    
44
#define DCA_PRIM_CHANNELS_MAX (5)
45
#define DCA_SUBBANDS (32)
46
#define DCA_ABITS_MAX (32)      /* Should be 28 */
47
#define DCA_SUBSUBFRAMES_MAX (4)
48
#define DCA_LFE_MAX (3)
49

    
50
enum DCAMode {
51
    DCA_MONO = 0,
52
    DCA_CHANNEL,
53
    DCA_STEREO,
54
    DCA_STEREO_SUMDIFF,
55
    DCA_STEREO_TOTAL,
56
    DCA_3F,
57
    DCA_2F1R,
58
    DCA_3F1R,
59
    DCA_2F2R,
60
    DCA_3F2R,
61
    DCA_4F2R
62
};
63

    
64
/* Tables for mapping dts channel configurations to libavcodec multichannel api.
65
 * Some compromises have been made for special configurations. Most configurations
66
 * are never used so complete accuracy is not needed.
67
 *
68
 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
69
 * S  -> side, when both rear and back are configured move one of them to the side channel
70
 * OV -> center back
71
 * All 2 channel configurations -> CH_LAYOUT_STEREO
72
 */
73

    
74
static const int64_t dca_core_channel_layout[] = {
75
    CH_FRONT_CENTER,                                               ///< 1, A
76
    CH_LAYOUT_STEREO,                                              ///< 2, A + B (dual mono)
77
    CH_LAYOUT_STEREO,                                              ///< 2, L + R (stereo)
78
    CH_LAYOUT_STEREO,                                              ///< 2, (L+R) + (L-R) (sum-difference)
79
    CH_LAYOUT_STEREO,                                              ///< 2, LT +RT (left and right total)
80
    CH_LAYOUT_STEREO|CH_FRONT_CENTER,                              ///< 3, C+L+R
81
    CH_LAYOUT_STEREO|CH_BACK_CENTER,                               ///< 3, L+R+S
82
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,               ///< 4, C + L + R+ S
83
    CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,                   ///< 4, L + R +SL+ SR
84
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT,   ///< 5, C + L + R+ SL+SR
85
    CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER,                 ///< 6, CL + CR + L + R + SL + SR
86
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,                                   ///< 6, C + L + R+ LR + RR + OV
87
    CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT,   ///< 6, CF+ CR+LF+ RF+LR + RR
88
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
89
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
90
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
91
};
92

    
93
static const int8_t dca_lfe_index[] = {
94
    1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
95
};
96

    
97
static const int8_t dca_channel_reorder_lfe[][8] = {
98
    { 0, -1, -1, -1, -1, -1, -1, -1},
99
    { 0,  1, -1, -1, -1, -1, -1, -1},
100
    { 0,  1, -1, -1, -1, -1, -1, -1},
101
    { 0,  1, -1, -1, -1, -1, -1, -1},
102
    { 0,  1, -1, -1, -1, -1, -1, -1},
103
    { 2,  0,  1, -1, -1, -1, -1, -1},
104
    { 0,  1,  3, -1, -1, -1, -1, -1},
105
    { 2,  0,  1,  4, -1, -1, -1, -1},
106
    { 0,  1,  3,  4, -1, -1, -1, -1},
107
    { 2,  0,  1,  4,  5, -1, -1, -1},
108
    { 3,  4,  0,  1,  5,  6, -1, -1},
109
    { 2,  0,  1,  4,  5,  6, -1, -1},
110
    { 0,  6,  4,  5,  2,  3, -1, -1},
111
    { 4,  2,  5,  0,  1,  6,  7, -1},
112
    { 5,  6,  0,  1,  7,  3,  8,  4},
113
    { 4,  2,  5,  0,  1,  6,  8,  7},
114
};
115

    
116
static const int8_t dca_channel_reorder_nolfe[][8] = {
117
    { 0, -1, -1, -1, -1, -1, -1, -1},
118
    { 0,  1, -1, -1, -1, -1, -1, -1},
119
    { 0,  1, -1, -1, -1, -1, -1, -1},
120
    { 0,  1, -1, -1, -1, -1, -1, -1},
121
    { 0,  1, -1, -1, -1, -1, -1, -1},
122
    { 2,  0,  1, -1, -1, -1, -1, -1},
123
    { 0,  1,  2, -1, -1, -1, -1, -1},
124
    { 2,  0,  1,  3, -1, -1, -1, -1},
125
    { 0,  1,  2,  3, -1, -1, -1, -1},
126
    { 2,  0,  1,  3,  4, -1, -1, -1},
127
    { 2,  3,  0,  1,  4,  5, -1, -1},
128
    { 2,  0,  1,  3,  4,  5, -1, -1},
129
    { 0,  5,  3,  4,  1,  2, -1, -1},
130
    { 3,  2,  4,  0,  1,  5,  6, -1},
131
    { 4,  5,  0,  1,  6,  2,  7,  3},
132
    { 3,  2,  4,  0,  1,  5,  7,  6},
133
};
134

    
135

    
136
#define DCA_DOLBY 101           /* FIXME */
137

    
138
#define DCA_CHANNEL_BITS 6
139
#define DCA_CHANNEL_MASK 0x3F
140

    
141
#define DCA_LFE 0x80
142

    
143
#define HEADER_SIZE 14
144

    
145
#define DCA_MAX_FRAME_SIZE 16384
146

    
147
/** Bit allocation */
148
typedef struct {
149
    int offset;                 ///< code values offset
150
    int maxbits[8];             ///< max bits in VLC
151
    int wrap;                   ///< wrap for get_vlc2()
152
    VLC vlc[8];                 ///< actual codes
153
} BitAlloc;
154

    
155
static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
156
static BitAlloc dca_tmode;             ///< transition mode VLCs
157
static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
158
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
159

    
160
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
161
{
162
    return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
163
}
164

    
165
typedef struct {
166
    AVCodecContext *avctx;
167
    /* Frame header */
168
    int frame_type;             ///< type of the current frame
169
    int samples_deficit;        ///< deficit sample count
170
    int crc_present;            ///< crc is present in the bitstream
171
    int sample_blocks;          ///< number of PCM sample blocks
172
    int frame_size;             ///< primary frame byte size
173
    int amode;                  ///< audio channels arrangement
174
    int sample_rate;            ///< audio sampling rate
175
    int bit_rate;               ///< transmission bit rate
176
    int bit_rate_index;         ///< transmission bit rate index
177

    
178
    int downmix;                ///< embedded downmix enabled
179
    int dynrange;               ///< embedded dynamic range flag
180
    int timestamp;              ///< embedded time stamp flag
181
    int aux_data;               ///< auxiliary data flag
182
    int hdcd;                   ///< source material is mastered in HDCD
183
    int ext_descr;              ///< extension audio descriptor flag
184
    int ext_coding;             ///< extended coding flag
185
    int aspf;                   ///< audio sync word insertion flag
186
    int lfe;                    ///< low frequency effects flag
187
    int predictor_history;      ///< predictor history flag
188
    int header_crc;             ///< header crc check bytes
189
    int multirate_inter;        ///< multirate interpolator switch
190
    int version;                ///< encoder software revision
191
    int copy_history;           ///< copy history
192
    int source_pcm_res;         ///< source pcm resolution
193
    int front_sum;              ///< front sum/difference flag
194
    int surround_sum;           ///< surround sum/difference flag
195
    int dialog_norm;            ///< dialog normalisation parameter
196

    
197
    /* Primary audio coding header */
198
    int subframes;              ///< number of subframes
199
    int total_channels;         ///< number of channels including extensions
200
    int prim_channels;          ///< number of primary audio channels
201
    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
202
    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
203
    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
204
    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
205
    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
206
    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
207
    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
208
    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
209

    
210
    /* Primary audio coding side information */
211
    int subsubframes;           ///< number of subsubframes
212
    int partial_samples;        ///< partial subsubframe samples count
213
    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
214
    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
215
    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
216
    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
217
    int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
218
    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
219
    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
220
    int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
221
    int dynrange_coef;                                           ///< dynamic range coefficient
222

    
223
    int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
224

    
225
    float lfe_data[2 * DCA_SUBSUBFRAMES_MAX * DCA_LFE_MAX *
226
                   2 /*history */ ];    ///< Low frequency effect data
227
    int lfe_scale_factor;
228

    
229
    /* Subband samples history (for ADPCM) */
230
    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
231
    DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
232
    DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
233
    int hist_index[DCA_PRIM_CHANNELS_MAX];
234
    DECLARE_ALIGNED(16, float, raXin)[32];
235

    
236
    int output;                 ///< type of output
237
    float add_bias;             ///< output bias
238
    float scale_bias;           ///< output scale
239

    
240
    DECLARE_ALIGNED(16, float, samples)[1536];  /* 6 * 256 = 1536, might only need 5 */
241
    const float *samples_chanptr[6];
242

    
243
    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
244
    int dca_buffer_size;        ///< how much data is in the dca_buffer
245

    
246
    const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
247
    GetBitContext gb;
248
    /* Current position in DCA frame */
249
    int current_subframe;
250
    int current_subsubframe;
251

    
252
    int debug_flag;             ///< used for suppressing repeated error messages output
253
    DSPContext dsp;
254
    FFTContext imdct;
255
    SynthFilterContext synth;
256
    DCADSPContext dcadsp;
257
} DCAContext;
258

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

    
268
static av_cold void dca_init_vlcs(void)
269
{
270
    static int vlcs_initialized = 0;
271
    int i, j, c = 14;
272
    static VLC_TYPE dca_table[23622][2];
273

    
274
    if (vlcs_initialized)
275
        return;
276

    
277
    dca_bitalloc_index.offset = 1;
278
    dca_bitalloc_index.wrap = 2;
279
    for (i = 0; i < 5; i++) {
280
        dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
281
        dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
282
        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
283
                 bitalloc_12_bits[i], 1, 1,
284
                 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
285
    }
286
    dca_scalefactor.offset = -64;
287
    dca_scalefactor.wrap = 2;
288
    for (i = 0; i < 5; i++) {
289
        dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
290
        dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
291
        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
292
                 scales_bits[i], 1, 1,
293
                 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
294
    }
295
    dca_tmode.offset = 0;
296
    dca_tmode.wrap = 1;
297
    for (i = 0; i < 4; i++) {
298
        dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
299
        dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
300
        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
301
                 tmode_bits[i], 1, 1,
302
                 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
303
    }
304

    
305
    for(i = 0; i < 10; i++)
306
        for(j = 0; j < 7; j++){
307
            if(!bitalloc_codes[i][j]) break;
308
            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
309
            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
310
            dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
311
            dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
312
            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
313
                     bitalloc_sizes[i],
314
                     bitalloc_bits[i][j], 1, 1,
315
                     bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
316
            c++;
317
        }
318
    vlcs_initialized = 1;
319
}
320

    
321
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
322
{
323
    while(len--)
324
        *dst++ = get_bits(gb, bits);
325
}
326

    
327
static int dca_parse_frame_header(DCAContext * s)
328
{
329
    int i, j;
330
    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
331
    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
332
    static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
333

    
334
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
335

    
336
    /* Sync code */
337
    get_bits(&s->gb, 32);
338

    
339
    /* Frame header */
340
    s->frame_type        = get_bits(&s->gb, 1);
341
    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
342
    s->crc_present       = get_bits(&s->gb, 1);
343
    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
344
    s->frame_size        = get_bits(&s->gb, 14) + 1;
345
    if (s->frame_size < 95)
346
        return -1;
347
    s->amode             = get_bits(&s->gb, 6);
348
    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
349
    if (!s->sample_rate)
350
        return -1;
351
    s->bit_rate_index    = get_bits(&s->gb, 5);
352
    s->bit_rate          = dca_bit_rates[s->bit_rate_index];
353
    if (!s->bit_rate)
354
        return -1;
355

    
356
    s->downmix           = get_bits(&s->gb, 1);
357
    s->dynrange          = get_bits(&s->gb, 1);
358
    s->timestamp         = get_bits(&s->gb, 1);
359
    s->aux_data          = get_bits(&s->gb, 1);
360
    s->hdcd              = get_bits(&s->gb, 1);
361
    s->ext_descr         = get_bits(&s->gb, 3);
362
    s->ext_coding        = get_bits(&s->gb, 1);
363
    s->aspf              = get_bits(&s->gb, 1);
364
    s->lfe               = get_bits(&s->gb, 2);
365
    s->predictor_history = get_bits(&s->gb, 1);
366

    
367
    /* TODO: check CRC */
368
    if (s->crc_present)
369
        s->header_crc    = get_bits(&s->gb, 16);
370

    
371
    s->multirate_inter   = get_bits(&s->gb, 1);
372
    s->version           = get_bits(&s->gb, 4);
373
    s->copy_history      = get_bits(&s->gb, 2);
374
    s->source_pcm_res    = get_bits(&s->gb, 3);
375
    s->front_sum         = get_bits(&s->gb, 1);
376
    s->surround_sum      = get_bits(&s->gb, 1);
377
    s->dialog_norm       = get_bits(&s->gb, 4);
378

    
379
    /* FIXME: channels mixing levels */
380
    s->output = s->amode;
381
    if(s->lfe) s->output |= DCA_LFE;
382

    
383
#ifdef TRACE
384
    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
385
    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
386
    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
387
    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
388
           s->sample_blocks, s->sample_blocks * 32);
389
    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
390
    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
391
           s->amode, dca_channels[s->amode]);
392
    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
393
           s->sample_rate);
394
    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
395
           s->bit_rate);
396
    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
397
    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
398
    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
399
    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
400
    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
401
    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
402
    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
403
    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
404
    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
405
    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
406
           s->predictor_history);
407
    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
408
    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
409
           s->multirate_inter);
410
    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
411
    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
412
    av_log(s->avctx, AV_LOG_DEBUG,
413
           "source pcm resolution: %i (%i bits/sample)\n",
414
           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
415
    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
416
    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
417
    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
418
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
419
#endif
420

    
421
    /* Primary audio coding header */
422
    s->subframes         = get_bits(&s->gb, 4) + 1;
423
    s->total_channels    = get_bits(&s->gb, 3) + 1;
424
    s->prim_channels     = s->total_channels;
425
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
426
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
427

    
428

    
429
    for (i = 0; i < s->prim_channels; i++) {
430
        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
431
        if (s->subband_activity[i] > DCA_SUBBANDS)
432
            s->subband_activity[i] = DCA_SUBBANDS;
433
    }
434
    for (i = 0; i < s->prim_channels; i++) {
435
        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
436
        if (s->vq_start_subband[i] > DCA_SUBBANDS)
437
            s->vq_start_subband[i] = DCA_SUBBANDS;
438
    }
439
    get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
440
    get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
441
    get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
442
    get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
443

    
444
    /* Get codebooks quantization indexes */
445
    memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
446
    for (j = 1; j < 11; j++)
447
        for (i = 0; i < s->prim_channels; i++)
448
            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
449

    
450
    /* Get scale factor adjustment */
451
    for (j = 0; j < 11; j++)
452
        for (i = 0; i < s->prim_channels; i++)
453
            s->scalefactor_adj[i][j] = 1;
454

    
455
    for (j = 1; j < 11; j++)
456
        for (i = 0; i < s->prim_channels; i++)
457
            if (s->quant_index_huffman[i][j] < thr[j])
458
                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
459

    
460
    if (s->crc_present) {
461
        /* Audio header CRC check */
462
        get_bits(&s->gb, 16);
463
    }
464

    
465
    s->current_subframe = 0;
466
    s->current_subsubframe = 0;
467

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

    
490
    return 0;
491
}
492

    
493

    
494
static inline int get_scale(GetBitContext *gb, int level, int value)
495
{
496
   if (level < 5) {
497
       /* huffman encoded */
498
       value += get_bitalloc(gb, &dca_scalefactor, level);
499
   } else if(level < 8)
500
       value = get_bits(gb, level + 1);
501
   return value;
502
}
503

    
504
static int dca_subframe_header(DCAContext * s)
505
{
506
    /* Primary audio coding side information */
507
    int j, k;
508

    
509
    s->subsubframes = get_bits(&s->gb, 2) + 1;
510
    s->partial_samples = get_bits(&s->gb, 3);
511
    for (j = 0; j < s->prim_channels; j++) {
512
        for (k = 0; k < s->subband_activity[j]; k++)
513
            s->prediction_mode[j][k] = get_bits(&s->gb, 1);
514
    }
515

    
516
    /* Get prediction codebook */
517
    for (j = 0; j < s->prim_channels; j++) {
518
        for (k = 0; k < s->subband_activity[j]; k++) {
519
            if (s->prediction_mode[j][k] > 0) {
520
                /* (Prediction coefficient VQ address) */
521
                s->prediction_vq[j][k] = get_bits(&s->gb, 12);
522
            }
523
        }
524
    }
525

    
526
    /* Bit allocation index */
527
    for (j = 0; j < s->prim_channels; j++) {
528
        for (k = 0; k < s->vq_start_subband[j]; k++) {
529
            if (s->bitalloc_huffman[j] == 6)
530
                s->bitalloc[j][k] = get_bits(&s->gb, 5);
531
            else if (s->bitalloc_huffman[j] == 5)
532
                s->bitalloc[j][k] = get_bits(&s->gb, 4);
533
            else if (s->bitalloc_huffman[j] == 7) {
534
                av_log(s->avctx, AV_LOG_ERROR,
535
                       "Invalid bit allocation index\n");
536
                return -1;
537
            } else {
538
                s->bitalloc[j][k] =
539
                    get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
540
            }
541

    
542
            if (s->bitalloc[j][k] > 26) {
543
//                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
544
//                          j, k, s->bitalloc[j][k]);
545
                return -1;
546
            }
547
        }
548
    }
549

    
550
    /* Transition mode */
551
    for (j = 0; j < s->prim_channels; j++) {
552
        for (k = 0; k < s->subband_activity[j]; k++) {
553
            s->transition_mode[j][k] = 0;
554
            if (s->subsubframes > 1 &&
555
                k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
556
                s->transition_mode[j][k] =
557
                    get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
558
            }
559
        }
560
    }
561

    
562
    for (j = 0; j < s->prim_channels; j++) {
563
        const uint32_t *scale_table;
564
        int scale_sum;
565

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

    
568
        if (s->scalefactor_huffman[j] == 6)
569
            scale_table = scale_factor_quant7;
570
        else
571
            scale_table = scale_factor_quant6;
572

    
573
        /* When huffman coded, only the difference is encoded */
574
        scale_sum = 0;
575

    
576
        for (k = 0; k < s->subband_activity[j]; k++) {
577
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
578
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
579
                s->scale_factor[j][k][0] = scale_table[scale_sum];
580
            }
581

    
582
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
583
                /* Get second scale factor */
584
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
585
                s->scale_factor[j][k][1] = scale_table[scale_sum];
586
            }
587
        }
588
    }
589

    
590
    /* Joint subband scale factor codebook select */
591
    for (j = 0; j < s->prim_channels; j++) {
592
        /* Transmitted only if joint subband coding enabled */
593
        if (s->joint_intensity[j] > 0)
594
            s->joint_huff[j] = get_bits(&s->gb, 3);
595
    }
596

    
597
    /* Scale factors for joint subband coding */
598
    for (j = 0; j < s->prim_channels; j++) {
599
        int source_channel;
600

    
601
        /* Transmitted only if joint subband coding enabled */
602
        if (s->joint_intensity[j] > 0) {
603
            int scale = 0;
604
            source_channel = s->joint_intensity[j] - 1;
605

    
606
            /* When huffman coded, only the difference is encoded
607
             * (is this valid as well for joint scales ???) */
608

    
609
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
610
                scale = get_scale(&s->gb, s->joint_huff[j], 0);
611
                scale += 64;    /* bias */
612
                s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
613
            }
614

    
615
            if (!(s->debug_flag & 0x02)) {
616
                av_log(s->avctx, AV_LOG_DEBUG,
617
                       "Joint stereo coding not supported\n");
618
                s->debug_flag |= 0x02;
619
            }
620
        }
621
    }
622

    
623
    /* Stereo downmix coefficients */
624
    if (s->prim_channels > 2) {
625
        if(s->downmix) {
626
            for (j = 0; j < s->prim_channels; j++) {
627
                s->downmix_coef[j][0] = get_bits(&s->gb, 7);
628
                s->downmix_coef[j][1] = get_bits(&s->gb, 7);
629
            }
630
        } else {
631
            int am = s->amode & DCA_CHANNEL_MASK;
632
            for (j = 0; j < s->prim_channels; j++) {
633
                s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
634
                s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
635
            }
636
        }
637
    }
638

    
639
    /* Dynamic range coefficient */
640
    if (s->dynrange)
641
        s->dynrange_coef = get_bits(&s->gb, 8);
642

    
643
    /* Side information CRC check word */
644
    if (s->crc_present) {
645
        get_bits(&s->gb, 16);
646
    }
647

    
648
    /*
649
     * Primary audio data arrays
650
     */
651

    
652
    /* VQ encoded high frequency subbands */
653
    for (j = 0; j < s->prim_channels; j++)
654
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
655
            /* 1 vector -> 32 samples */
656
            s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
657

    
658
    /* Low frequency effect data */
659
    if (s->lfe) {
660
        /* LFE samples */
661
        int lfe_samples = 2 * s->lfe * s->subsubframes;
662
        float lfe_scale;
663

    
664
        for (j = lfe_samples; j < lfe_samples * 2; j++) {
665
            /* Signed 8 bits int */
666
            s->lfe_data[j] = get_sbits(&s->gb, 8);
667
        }
668

    
669
        /* Scale factor index */
670
        s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
671

    
672
        /* Quantization step size * scale factor */
673
        lfe_scale = 0.035 * s->lfe_scale_factor;
674

    
675
        for (j = lfe_samples; j < lfe_samples * 2; j++)
676
            s->lfe_data[j] *= lfe_scale;
677
    }
678

    
679
#ifdef TRACE
680
    av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
681
    av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
682
           s->partial_samples);
683
    for (j = 0; j < s->prim_channels; j++) {
684
        av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
685
        for (k = 0; k < s->subband_activity[j]; k++)
686
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
687
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
688
    }
689
    for (j = 0; j < s->prim_channels; j++) {
690
        for (k = 0; k < s->subband_activity[j]; k++)
691
                av_log(s->avctx, AV_LOG_DEBUG,
692
                       "prediction coefs: %f, %f, %f, %f\n",
693
                       (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
694
                       (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
695
                       (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
696
                       (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
697
    }
698
    for (j = 0; j < s->prim_channels; j++) {
699
        av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
700
        for (k = 0; k < s->vq_start_subband[j]; k++)
701
            av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
702
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
703
    }
704
    for (j = 0; j < s->prim_channels; j++) {
705
        av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
706
        for (k = 0; k < s->subband_activity[j]; k++)
707
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
708
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
709
    }
710
    for (j = 0; j < s->prim_channels; j++) {
711
        av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
712
        for (k = 0; k < s->subband_activity[j]; k++) {
713
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
714
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
715
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
716
                av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
717
        }
718
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
719
    }
720
    for (j = 0; j < s->prim_channels; j++) {
721
        if (s->joint_intensity[j] > 0) {
722
            int source_channel = s->joint_intensity[j] - 1;
723
            av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
724
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
725
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
726
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
727
        }
728
    }
729
    if (s->prim_channels > 2 && s->downmix) {
730
        av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
731
        for (j = 0; j < s->prim_channels; j++) {
732
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
733
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
734
        }
735
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
736
    }
737
    for (j = 0; j < s->prim_channels; j++)
738
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
739
            av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
740
    if(s->lfe){
741
        int lfe_samples = 2 * s->lfe * s->subsubframes;
742
        av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
743
        for (j = lfe_samples; j < lfe_samples * 2; j++)
744
            av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
745
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
746
    }
747
#endif
748

    
749
    return 0;
750
}
751

    
752
static void qmf_32_subbands(DCAContext * s, int chans,
753
                            float samples_in[32][8], float *samples_out,
754
                            float scale, float bias)
755
{
756
    const float *prCoeff;
757
    int i;
758

    
759
    int sb_act = s->subband_activity[chans];
760
    int subindex;
761

    
762
    scale *= sqrt(1/8.0);
763

    
764
    /* Select filter */
765
    if (!s->multirate_inter)    /* Non-perfect reconstruction */
766
        prCoeff = fir_32bands_nonperfect;
767
    else                        /* Perfect reconstruction */
768
        prCoeff = fir_32bands_perfect;
769

    
770
    /* Reconstructed channel sample index */
771
    for (subindex = 0; subindex < 8; subindex++) {
772
        /* Load in one sample from each subband and clear inactive subbands */
773
        for (i = 0; i < sb_act; i++){
774
            uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
775
            AV_WN32A(&s->raXin[i], v);
776
        }
777
        for (; i < 32; i++)
778
            s->raXin[i] = 0.0;
779

    
780
        s->synth.synth_filter_float(&s->imdct,
781
                              s->subband_fir_hist[chans], &s->hist_index[chans],
782
                              s->subband_fir_noidea[chans], prCoeff,
783
                              samples_out, s->raXin, scale, bias);
784
        samples_out+= 32;
785

    
786
    }
787
}
788

    
789
static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
790
                                  int num_deci_sample, float *samples_in,
791
                                  float *samples_out, float scale,
792
                                  float bias)
793
{
794
    /* samples_in: An array holding decimated samples.
795
     *   Samples in current subframe starts from samples_in[0],
796
     *   while samples_in[-1], samples_in[-2], ..., stores samples
797
     *   from last subframe as history.
798
     *
799
     * samples_out: An array holding interpolated samples
800
     */
801

    
802
    int decifactor;
803
    const float *prCoeff;
804
    int deciindex;
805

    
806
    /* Select decimation filter */
807
    if (decimation_select == 1) {
808
        decifactor = 64;
809
        prCoeff = lfe_fir_128;
810
    } else {
811
        decifactor = 32;
812
        prCoeff = lfe_fir_64;
813
    }
814
    /* Interpolation */
815
    for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
816
        s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
817
                          scale, bias);
818
        samples_in++;
819
        samples_out += 2 * decifactor;
820
    }
821
}
822

    
823
/* downmixing routines */
824
#define MIX_REAR1(samples, si1, rs, coef) \
825
     samples[i]     += samples[si1] * coef[rs][0]; \
826
     samples[i+256] += samples[si1] * coef[rs][1];
827

    
828
#define MIX_REAR2(samples, si1, si2, rs, coef) \
829
     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
830
     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
831

    
832
#define MIX_FRONT3(samples, coef) \
833
    t = samples[i]; \
834
    samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
835
    samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
836

    
837
#define DOWNMIX_TO_STEREO(op1, op2) \
838
    for(i = 0; i < 256; i++){ \
839
        op1 \
840
        op2 \
841
    }
842

    
843
static void dca_downmix(float *samples, int srcfmt,
844
                        int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
845
{
846
    int i;
847
    float t;
848
    float coef[DCA_PRIM_CHANNELS_MAX][2];
849

    
850
    for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
851
        coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
852
        coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
853
    }
854

    
855
    switch (srcfmt) {
856
    case DCA_MONO:
857
    case DCA_CHANNEL:
858
    case DCA_STEREO_TOTAL:
859
    case DCA_STEREO_SUMDIFF:
860
    case DCA_4F2R:
861
        av_log(NULL, 0, "Not implemented!\n");
862
        break;
863
    case DCA_STEREO:
864
        break;
865
    case DCA_3F:
866
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
867
        break;
868
    case DCA_2F1R:
869
        DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
870
        break;
871
    case DCA_3F1R:
872
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
873
                          MIX_REAR1(samples, i + 768, 3, coef));
874
        break;
875
    case DCA_2F2R:
876
        DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
877
        break;
878
    case DCA_3F2R:
879
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
880
                          MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
881
        break;
882
    }
883
}
884

    
885

    
886
/* Very compact version of the block code decoder that does not use table
887
 * look-up but is slightly slower */
888
static int decode_blockcode(int code, int levels, int *values)
889
{
890
    int i;
891
    int offset = (levels - 1) >> 1;
892

    
893
    for (i = 0; i < 4; i++) {
894
        int div = FASTDIV(code, levels);
895
        values[i] = code - offset - div*levels;
896
        code = div;
897
    }
898

    
899
    if (code == 0)
900
        return 0;
901
    else {
902
        av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
903
        return -1;
904
    }
905
}
906

    
907
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
908
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
909

    
910
static int dca_subsubframe(DCAContext * s)
911
{
912
    int k, l;
913
    int subsubframe = s->current_subsubframe;
914

    
915
    const float *quant_step_table;
916

    
917
    /* FIXME */
918
    LOCAL_ALIGNED_16(float, subband_samples, [DCA_PRIM_CHANNELS_MAX], [DCA_SUBBANDS][8]);
919
    LOCAL_ALIGNED_16(int, block, [8]);
920

    
921
    /*
922
     * Audio data
923
     */
924

    
925
    /* Select quantization step size table */
926
    if (s->bit_rate_index == 0x1f)
927
        quant_step_table = lossless_quant_d;
928
    else
929
        quant_step_table = lossy_quant_d;
930

    
931
    for (k = 0; k < s->prim_channels; k++) {
932
        for (l = 0; l < s->vq_start_subband[k]; l++) {
933
            int m;
934

    
935
            /* Select the mid-tread linear quantizer */
936
            int abits = s->bitalloc[k][l];
937

    
938
            float quant_step_size = quant_step_table[abits];
939

    
940
            /*
941
             * Determine quantization index code book and its type
942
             */
943

    
944
            /* Select quantization index code book */
945
            int sel = s->quant_index_huffman[k][abits];
946

    
947
            /*
948
             * Extract bits from the bit stream
949
             */
950
            if(!abits){
951
                memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
952
            } else {
953
                /* Deal with transients */
954
                int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
955
                float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
956

    
957
                if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
958
                    if(abits <= 7){
959
                        /* Block code */
960
                        int block_code1, block_code2, size, levels;
961

    
962
                        size = abits_sizes[abits-1];
963
                        levels = abits_levels[abits-1];
964

    
965
                        block_code1 = get_bits(&s->gb, size);
966
                        /* FIXME Should test return value */
967
                        decode_blockcode(block_code1, levels, block);
968
                        block_code2 = get_bits(&s->gb, size);
969
                        decode_blockcode(block_code2, levels, &block[4]);
970
                    }else{
971
                        /* no coding */
972
                        for (m = 0; m < 8; m++)
973
                            block[m] = get_sbits(&s->gb, abits - 3);
974
                    }
975
                }else{
976
                    /* Huffman coded */
977
                    for (m = 0; m < 8; m++)
978
                        block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
979
                }
980

    
981
                s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
982
                                                  block, rscale, 8);
983
            }
984

    
985
            /*
986
             * Inverse ADPCM if in prediction mode
987
             */
988
            if (s->prediction_mode[k][l]) {
989
                int n;
990
                for (m = 0; m < 8; m++) {
991
                    for (n = 1; n <= 4; n++)
992
                        if (m >= n)
993
                            subband_samples[k][l][m] +=
994
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
995
                                 subband_samples[k][l][m - n] / 8192);
996
                        else if (s->predictor_history)
997
                            subband_samples[k][l][m] +=
998
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
999
                                 s->subband_samples_hist[k][l][m - n +
1000
                                                               4] / 8192);
1001
                }
1002
            }
1003
        }
1004

    
1005
        /*
1006
         * Decode VQ encoded high frequencies
1007
         */
1008
        for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1009
            /* 1 vector -> 32 samples but we only need the 8 samples
1010
             * for this subsubframe. */
1011
            int m;
1012

    
1013
            if (!s->debug_flag & 0x01) {
1014
                av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1015
                s->debug_flag |= 0x01;
1016
            }
1017

    
1018
            for (m = 0; m < 8; m++) {
1019
                subband_samples[k][l][m] =
1020
                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1021
                                                        m]
1022
                    * (float) s->scale_factor[k][l][0] / 16.0;
1023
            }
1024
        }
1025
    }
1026

    
1027
    /* Check for DSYNC after subsubframe */
1028
    if (s->aspf || subsubframe == s->subsubframes - 1) {
1029
        if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1030
#ifdef TRACE
1031
            av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1032
#endif
1033
        } else {
1034
            av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1035
        }
1036
    }
1037

    
1038
    /* Backup predictor history for adpcm */
1039
    for (k = 0; k < s->prim_channels; k++)
1040
        for (l = 0; l < s->vq_start_subband[k]; l++)
1041
            memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1042
                        4 * sizeof(subband_samples[0][0][0]));
1043

    
1044
    /* 32 subbands QMF */
1045
    for (k = 0; k < s->prim_channels; k++) {
1046
/*        static float pcm_to_double[8] =
1047
            {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1048
         qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1049
                            M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1050
                            s->add_bias );
1051
    }
1052

    
1053
    /* Down mixing */
1054

    
1055
    if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1056
        dca_downmix(s->samples, s->amode, s->downmix_coef);
1057
    }
1058

    
1059
    /* Generate LFE samples for this subsubframe FIXME!!! */
1060
    if (s->output & DCA_LFE) {
1061
        int lfe_samples = 2 * s->lfe * s->subsubframes;
1062

    
1063
        lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1064
                              s->lfe_data + lfe_samples +
1065
                              2 * s->lfe * subsubframe,
1066
                              &s->samples[256 * dca_lfe_index[s->amode]],
1067
                              (1.0/256.0)*s->scale_bias,  s->add_bias);
1068
        /* Outputs 20bits pcm samples */
1069
    }
1070

    
1071
    return 0;
1072
}
1073

    
1074

    
1075
static int dca_subframe_footer(DCAContext * s)
1076
{
1077
    int aux_data_count = 0, i;
1078
    int lfe_samples;
1079

    
1080
    /*
1081
     * Unpack optional information
1082
     */
1083

    
1084
    if (s->timestamp)
1085
        get_bits(&s->gb, 32);
1086

    
1087
    if (s->aux_data)
1088
        aux_data_count = get_bits(&s->gb, 6);
1089

    
1090
    for (i = 0; i < aux_data_count; i++)
1091
        get_bits(&s->gb, 8);
1092

    
1093
    if (s->crc_present && (s->downmix || s->dynrange))
1094
        get_bits(&s->gb, 16);
1095

    
1096
    lfe_samples = 2 * s->lfe * s->subsubframes;
1097
    for (i = 0; i < lfe_samples; i++) {
1098
        s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1099
    }
1100

    
1101
    return 0;
1102
}
1103

    
1104
/**
1105
 * Decode a dca frame block
1106
 *
1107
 * @param s     pointer to the DCAContext
1108
 */
1109

    
1110
static int dca_decode_block(DCAContext * s)
1111
{
1112

    
1113
    /* Sanity check */
1114
    if (s->current_subframe >= s->subframes) {
1115
        av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1116
               s->current_subframe, s->subframes);
1117
        return -1;
1118
    }
1119

    
1120
    if (!s->current_subsubframe) {
1121
#ifdef TRACE
1122
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1123
#endif
1124
        /* Read subframe header */
1125
        if (dca_subframe_header(s))
1126
            return -1;
1127
    }
1128

    
1129
    /* Read subsubframe */
1130
#ifdef TRACE
1131
    av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1132
#endif
1133
    if (dca_subsubframe(s))
1134
        return -1;
1135

    
1136
    /* Update state */
1137
    s->current_subsubframe++;
1138
    if (s->current_subsubframe >= s->subsubframes) {
1139
        s->current_subsubframe = 0;
1140
        s->current_subframe++;
1141
    }
1142
    if (s->current_subframe >= s->subframes) {
1143
#ifdef TRACE
1144
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1145
#endif
1146
        /* Read subframe footer */
1147
        if (dca_subframe_footer(s))
1148
            return -1;
1149
    }
1150

    
1151
    return 0;
1152
}
1153

    
1154
/**
1155
 * Convert bitstream to one representation based on sync marker
1156
 */
1157
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1158
                          int max_size)
1159
{
1160
    uint32_t mrk;
1161
    int i, tmp;
1162
    const uint16_t *ssrc = (const uint16_t *) src;
1163
    uint16_t *sdst = (uint16_t *) dst;
1164
    PutBitContext pb;
1165

    
1166
    if((unsigned)src_size > (unsigned)max_size) {
1167
//        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1168
//        return -1;
1169
        src_size = max_size;
1170
    }
1171

    
1172
    mrk = AV_RB32(src);
1173
    switch (mrk) {
1174
    case DCA_MARKER_RAW_BE:
1175
        memcpy(dst, src, src_size);
1176
        return src_size;
1177
    case DCA_MARKER_RAW_LE:
1178
        for (i = 0; i < (src_size + 1) >> 1; i++)
1179
            *sdst++ = bswap_16(*ssrc++);
1180
        return src_size;
1181
    case DCA_MARKER_14B_BE:
1182
    case DCA_MARKER_14B_LE:
1183
        init_put_bits(&pb, dst, max_size);
1184
        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1185
            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1186
            put_bits(&pb, 14, tmp);
1187
        }
1188
        flush_put_bits(&pb);
1189
        return (put_bits_count(&pb) + 7) >> 3;
1190
    default:
1191
        return -1;
1192
    }
1193
}
1194

    
1195
/**
1196
 * Main frame decoding function
1197
 * FIXME add arguments
1198
 */
1199
static int dca_decode_frame(AVCodecContext * avctx,
1200
                            void *data, int *data_size,
1201
                            AVPacket *avpkt)
1202
{
1203
    const uint8_t *buf = avpkt->data;
1204
    int buf_size = avpkt->size;
1205

    
1206
    int i;
1207
    int16_t *samples = data;
1208
    DCAContext *s = avctx->priv_data;
1209
    int channels;
1210

    
1211

    
1212
    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1213
    if (s->dca_buffer_size == -1) {
1214
        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1215
        return -1;
1216
    }
1217

    
1218
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1219
    if (dca_parse_frame_header(s) < 0) {
1220
        //seems like the frame is corrupt, try with the next one
1221
        *data_size=0;
1222
        return buf_size;
1223
    }
1224
    //set AVCodec values with parsed data
1225
    avctx->sample_rate = s->sample_rate;
1226
    avctx->bit_rate = s->bit_rate;
1227

    
1228
    channels = s->prim_channels + !!s->lfe;
1229

    
1230
    if (s->amode<16) {
1231
        avctx->channel_layout = dca_core_channel_layout[s->amode];
1232

    
1233
        if (s->lfe) {
1234
            avctx->channel_layout |= CH_LOW_FREQUENCY;
1235
            s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1236
        } else
1237
            s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1238

    
1239
        if (s->prim_channels > 0 &&
1240
            s->channel_order_tab[s->prim_channels - 1] < 0)
1241
            return -1;
1242

    
1243
        if(avctx->request_channels == 2 && s->prim_channels > 2) {
1244
            channels = 2;
1245
            s->output = DCA_STEREO;
1246
            avctx->channel_layout = CH_LAYOUT_STEREO;
1247
        }
1248
    } else {
1249
        av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1250
        return -1;
1251
    }
1252

    
1253

    
1254
    /* There is nothing that prevents a dts frame to change channel configuration
1255
       but FFmpeg doesn't support that so only set the channels if it is previously
1256
       unset. Ideally during the first probe for channels the crc should be checked
1257
       and only set avctx->channels when the crc is ok. Right now the decoder could
1258
       set the channels based on a broken first frame.*/
1259
    if (!avctx->channels)
1260
        avctx->channels = channels;
1261

    
1262
    if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1263
        return -1;
1264
    *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1265
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1266
        dca_decode_block(s);
1267
        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1268
        samples += 256 * channels;
1269
    }
1270

    
1271
    return buf_size;
1272
}
1273

    
1274

    
1275

    
1276
/**
1277
 * DCA initialization
1278
 *
1279
 * @param avctx     pointer to the AVCodecContext
1280
 */
1281

    
1282
static av_cold int dca_decode_init(AVCodecContext * avctx)
1283
{
1284
    DCAContext *s = avctx->priv_data;
1285
    int i;
1286

    
1287
    s->avctx = avctx;
1288
    dca_init_vlcs();
1289

    
1290
    dsputil_init(&s->dsp, avctx);
1291
    ff_mdct_init(&s->imdct, 6, 1, 1.0);
1292
    ff_synth_filter_init(&s->synth);
1293
    ff_dcadsp_init(&s->dcadsp);
1294

    
1295
    for(i = 0; i < 6; i++)
1296
        s->samples_chanptr[i] = s->samples + i * 256;
1297
    avctx->sample_fmt = SAMPLE_FMT_S16;
1298

    
1299
    if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1300
        s->add_bias = 385.0f;
1301
        s->scale_bias = 1.0 / 32768.0;
1302
    } else {
1303
        s->add_bias = 0.0f;
1304
        s->scale_bias = 1.0;
1305

    
1306
        /* allow downmixing to stereo */
1307
        if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1308
                avctx->request_channels == 2) {
1309
            avctx->channels = avctx->request_channels;
1310
        }
1311
    }
1312

    
1313

    
1314
    return 0;
1315
}
1316

    
1317
static av_cold int dca_decode_end(AVCodecContext * avctx)
1318
{
1319
    DCAContext *s = avctx->priv_data;
1320
    ff_mdct_end(&s->imdct);
1321
    return 0;
1322
}
1323

    
1324
AVCodec dca_decoder = {
1325
    .name = "dca",
1326
    .type = AVMEDIA_TYPE_AUDIO,
1327
    .id = CODEC_ID_DTS,
1328
    .priv_data_size = sizeof(DCAContext),
1329
    .init = dca_decode_init,
1330
    .decode = dca_decode_frame,
1331
    .close = dca_decode_end,
1332
    .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1333
};