Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ 4a24837e

History | View | Annotate | Download (44.2 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
/**
26
 * @file dca.c
27
 */
28

    
29
#include <math.h>
30
#include <stddef.h>
31
#include <stdio.h>
32

    
33
#include "avcodec.h"
34
#include "dsputil.h"
35
#include "bitstream.h"
36
#include "dcadata.h"
37
#include "dcahuff.h"
38
#include "dca.h"
39

    
40
//#define TRACE
41

    
42
#define DCA_PRIM_CHANNELS_MAX (5)
43
#define DCA_SUBBANDS (32)
44
#define DCA_ABITS_MAX (32)      /* Should be 28 */
45
#define DCA_SUBSUBFAMES_MAX (4)
46
#define DCA_LFE_MAX (3)
47

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

    
62
#define DCA_DOLBY 101           /* FIXME */
63

    
64
#define DCA_CHANNEL_BITS 6
65
#define DCA_CHANNEL_MASK 0x3F
66

    
67
#define DCA_LFE 0x80
68

    
69
#define HEADER_SIZE 14
70
#define CONVERT_BIAS 384
71

    
72
#define DCA_MAX_FRAME_SIZE 16383
73

    
74
/** Bit allocation */
75
typedef struct {
76
    int offset;                 ///< code values offset
77
    int maxbits[8];             ///< max bits in VLC
78
    int wrap;                   ///< wrap for get_vlc2()
79
    VLC vlc[8];                 ///< actual codes
80
} BitAlloc;
81

    
82
static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
83
static BitAlloc dca_tmode;             ///< transition mode VLCs
84
static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
85
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
86

    
87
/** Pre-calculated cosine modulation coefs for the QMF */
88
static float cos_mod[544];
89

    
90
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
91
{
92
    return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
93
}
94

    
95
typedef struct {
96
    AVCodecContext *avctx;
97
    /* Frame header */
98
    int frame_type;             ///< type of the current frame
99
    int samples_deficit;        ///< deficit sample count
100
    int crc_present;            ///< crc is present in the bitstream
101
    int sample_blocks;          ///< number of PCM sample blocks
102
    int frame_size;             ///< primary frame byte size
103
    int amode;                  ///< audio channels arrangement
104
    int sample_rate;            ///< audio sampling rate
105
    int bit_rate;               ///< transmission bit rate
106

    
107
    int downmix;                ///< embedded downmix enabled
108
    int dynrange;               ///< embedded dynamic range flag
109
    int timestamp;              ///< embedded time stamp flag
110
    int aux_data;               ///< auxiliary data flag
111
    int hdcd;                   ///< source material is mastered in HDCD
112
    int ext_descr;              ///< extension audio descriptor flag
113
    int ext_coding;             ///< extended coding flag
114
    int aspf;                   ///< audio sync word insertion flag
115
    int lfe;                    ///< low frequency effects flag
116
    int predictor_history;      ///< predictor history flag
117
    int header_crc;             ///< header crc check bytes
118
    int multirate_inter;        ///< multirate interpolator switch
119
    int version;                ///< encoder software revision
120
    int copy_history;           ///< copy history
121
    int source_pcm_res;         ///< source pcm resolution
122
    int front_sum;              ///< front sum/difference flag
123
    int surround_sum;           ///< surround sum/difference flag
124
    int dialog_norm;            ///< dialog normalisation parameter
125

    
126
    /* Primary audio coding header */
127
    int subframes;              ///< number of subframes
128
    int total_channels;         ///< number of channels including extensions
129
    int prim_channels;          ///< number of primary audio channels
130
    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
131
    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
132
    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
133
    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
134
    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
135
    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
136
    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
137
    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
138

    
139
    /* Primary audio coding side information */
140
    int subsubframes;           ///< number of subsubframes
141
    int partial_samples;        ///< partial subsubframe samples count
142
    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
143
    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
144
    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
145
    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
146
    int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
147
    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
148
    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
149
    int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
150
    int dynrange_coef;                                           ///< dynamic range coefficient
151

    
152
    int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
153

    
154
    float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
155
                   2 /*history */ ];    ///< Low frequency effect data
156
    int lfe_scale_factor;
157

    
158
    /* Subband samples history (for ADPCM) */
159
    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
160
    float subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512];
161
    float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][64];
162

    
163
    int output;                 ///< type of output
164
    int bias;                   ///< output bias
165

    
166
    DECLARE_ALIGNED_16(float, samples[1536]);  /* 6 * 256 = 1536, might only need 5 */
167
    DECLARE_ALIGNED_16(int16_t, tsamples[1536]);
168

    
169
    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
170
    int dca_buffer_size;        ///< how much data is in the dca_buffer
171

    
172
    GetBitContext gb;
173
    /* Current position in DCA frame */
174
    int current_subframe;
175
    int current_subsubframe;
176

    
177
    int debug_flag;             ///< used for suppressing repeated error messages output
178
    DSPContext dsp;
179
} DCAContext;
180

    
181
static av_cold void dca_init_vlcs(void)
182
{
183
    static int vlcs_initialized = 0;
184
    int i, j;
185

    
186
    if (vlcs_initialized)
187
        return;
188

    
189
    dca_bitalloc_index.offset = 1;
190
    dca_bitalloc_index.wrap = 2;
191
    for (i = 0; i < 5; i++)
192
        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
193
                 bitalloc_12_bits[i], 1, 1,
194
                 bitalloc_12_codes[i], 2, 2, 1);
195
    dca_scalefactor.offset = -64;
196
    dca_scalefactor.wrap = 2;
197
    for (i = 0; i < 5; i++)
198
        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
199
                 scales_bits[i], 1, 1,
200
                 scales_codes[i], 2, 2, 1);
201
    dca_tmode.offset = 0;
202
    dca_tmode.wrap = 1;
203
    for (i = 0; i < 4; i++)
204
        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
205
                 tmode_bits[i], 1, 1,
206
                 tmode_codes[i], 2, 2, 1);
207

    
208
    for(i = 0; i < 10; i++)
209
        for(j = 0; j < 7; j++){
210
            if(!bitalloc_codes[i][j]) break;
211
            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
212
            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
213
            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
214
                     bitalloc_sizes[i],
215
                     bitalloc_bits[i][j], 1, 1,
216
                     bitalloc_codes[i][j], 2, 2, 1);
217
        }
218
    vlcs_initialized = 1;
219
}
220

    
221
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
222
{
223
    while(len--)
224
        *dst++ = get_bits(gb, bits);
225
}
226

    
227
static int dca_parse_frame_header(DCAContext * s)
228
{
229
    int i, j;
230
    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
231
    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
232
    static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
233

    
234
    s->bias = CONVERT_BIAS;
235

    
236
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
237

    
238
    /* Sync code */
239
    get_bits(&s->gb, 32);
240

    
241
    /* Frame header */
242
    s->frame_type        = get_bits(&s->gb, 1);
243
    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
244
    s->crc_present       = get_bits(&s->gb, 1);
245
    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
246
    s->frame_size        = get_bits(&s->gb, 14) + 1;
247
    if (s->frame_size < 95)
248
        return -1;
249
    s->amode             = get_bits(&s->gb, 6);
250
    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
251
    if (!s->sample_rate)
252
        return -1;
253
    s->bit_rate          = dca_bit_rates[get_bits(&s->gb, 5)];
254
    if (!s->bit_rate)
255
        return -1;
256

    
257
    s->downmix           = get_bits(&s->gb, 1);
258
    s->dynrange          = get_bits(&s->gb, 1);
259
    s->timestamp         = get_bits(&s->gb, 1);
260
    s->aux_data          = get_bits(&s->gb, 1);
261
    s->hdcd              = get_bits(&s->gb, 1);
262
    s->ext_descr         = get_bits(&s->gb, 3);
263
    s->ext_coding        = get_bits(&s->gb, 1);
264
    s->aspf              = get_bits(&s->gb, 1);
265
    s->lfe               = get_bits(&s->gb, 2);
266
    s->predictor_history = get_bits(&s->gb, 1);
267

    
268
    /* TODO: check CRC */
269
    if (s->crc_present)
270
        s->header_crc    = get_bits(&s->gb, 16);
271

    
272
    s->multirate_inter   = get_bits(&s->gb, 1);
273
    s->version           = get_bits(&s->gb, 4);
274
    s->copy_history      = get_bits(&s->gb, 2);
275
    s->source_pcm_res    = get_bits(&s->gb, 3);
276
    s->front_sum         = get_bits(&s->gb, 1);
277
    s->surround_sum      = get_bits(&s->gb, 1);
278
    s->dialog_norm       = get_bits(&s->gb, 4);
279

    
280
    /* FIXME: channels mixing levels */
281
    s->output = s->amode;
282
    if(s->lfe) s->output |= DCA_LFE;
283

    
284
#ifdef TRACE
285
    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
286
    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
287
    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
288
    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
289
           s->sample_blocks, s->sample_blocks * 32);
290
    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
291
    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
292
           s->amode, dca_channels[s->amode]);
293
    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i (%i Hz)\n",
294
           s->sample_rate, dca_sample_rates[s->sample_rate]);
295
    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i (%i bits/s)\n",
296
           s->bit_rate, dca_bit_rates[s->bit_rate]);
297
    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
298
    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
299
    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
300
    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
301
    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
302
    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
303
    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
304
    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
305
    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
306
    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
307
           s->predictor_history);
308
    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
309
    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
310
           s->multirate_inter);
311
    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
312
    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
313
    av_log(s->avctx, AV_LOG_DEBUG,
314
           "source pcm resolution: %i (%i bits/sample)\n",
315
           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
316
    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
317
    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
318
    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
319
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
320
#endif
321

    
322
    /* Primary audio coding header */
323
    s->subframes         = get_bits(&s->gb, 4) + 1;
324
    s->total_channels    = get_bits(&s->gb, 3) + 1;
325
    s->prim_channels     = s->total_channels;
326
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
327
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
328

    
329

    
330
    for (i = 0; i < s->prim_channels; i++) {
331
        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
332
        if (s->subband_activity[i] > DCA_SUBBANDS)
333
            s->subband_activity[i] = DCA_SUBBANDS;
334
    }
335
    for (i = 0; i < s->prim_channels; i++) {
336
        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
337
        if (s->vq_start_subband[i] > DCA_SUBBANDS)
338
            s->vq_start_subband[i] = DCA_SUBBANDS;
339
    }
340
    get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
341
    get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
342
    get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
343
    get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
344

    
345
    /* Get codebooks quantization indexes */
346
    memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
347
    for (j = 1; j < 11; j++)
348
        for (i = 0; i < s->prim_channels; i++)
349
            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
350

    
351
    /* Get scale factor adjustment */
352
    for (j = 0; j < 11; j++)
353
        for (i = 0; i < s->prim_channels; i++)
354
            s->scalefactor_adj[i][j] = 1;
355

    
356
    for (j = 1; j < 11; j++)
357
        for (i = 0; i < s->prim_channels; i++)
358
            if (s->quant_index_huffman[i][j] < thr[j])
359
                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
360

    
361
    if (s->crc_present) {
362
        /* Audio header CRC check */
363
        get_bits(&s->gb, 16);
364
    }
365

    
366
    s->current_subframe = 0;
367
    s->current_subsubframe = 0;
368

    
369
#ifdef TRACE
370
    av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
371
    av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
372
    for(i = 0; i < s->prim_channels; i++){
373
        av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
374
        av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
375
        av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
376
        av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
377
        av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
378
        av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
379
        av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
380
        for (j = 0; j < 11; j++)
381
            av_log(s->avctx, AV_LOG_DEBUG, " %i",
382
                   s->quant_index_huffman[i][j]);
383
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
384
        av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
385
        for (j = 0; j < 11; j++)
386
            av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
387
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
388
    }
389
#endif
390

    
391
    return 0;
392
}
393

    
394

    
395
static inline int get_scale(GetBitContext *gb, int level, int value)
396
{
397
   if (level < 5) {
398
       /* huffman encoded */
399
       value += get_bitalloc(gb, &dca_scalefactor, level);
400
   } else if(level < 8)
401
       value = get_bits(gb, level + 1);
402
   return value;
403
}
404

    
405
static int dca_subframe_header(DCAContext * s)
406
{
407
    /* Primary audio coding side information */
408
    int j, k;
409

    
410
    s->subsubframes = get_bits(&s->gb, 2) + 1;
411
    s->partial_samples = get_bits(&s->gb, 3);
412
    for (j = 0; j < s->prim_channels; j++) {
413
        for (k = 0; k < s->subband_activity[j]; k++)
414
            s->prediction_mode[j][k] = get_bits(&s->gb, 1);
415
    }
416

    
417
    /* Get prediction codebook */
418
    for (j = 0; j < s->prim_channels; j++) {
419
        for (k = 0; k < s->subband_activity[j]; k++) {
420
            if (s->prediction_mode[j][k] > 0) {
421
                /* (Prediction coefficient VQ address) */
422
                s->prediction_vq[j][k] = get_bits(&s->gb, 12);
423
            }
424
        }
425
    }
426

    
427
    /* Bit allocation index */
428
    for (j = 0; j < s->prim_channels; j++) {
429
        for (k = 0; k < s->vq_start_subband[j]; k++) {
430
            if (s->bitalloc_huffman[j] == 6)
431
                s->bitalloc[j][k] = get_bits(&s->gb, 5);
432
            else if (s->bitalloc_huffman[j] == 5)
433
                s->bitalloc[j][k] = get_bits(&s->gb, 4);
434
            else if (s->bitalloc_huffman[j] == 7) {
435
                av_log(s->avctx, AV_LOG_ERROR,
436
                       "Invalid bit allocation index\n");
437
                return -1;
438
            } else {
439
                s->bitalloc[j][k] =
440
                    get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
441
            }
442

    
443
            if (s->bitalloc[j][k] > 26) {
444
//                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
445
//                          j, k, s->bitalloc[j][k]);
446
                return -1;
447
            }
448
        }
449
    }
450

    
451
    /* Transition mode */
452
    for (j = 0; j < s->prim_channels; j++) {
453
        for (k = 0; k < s->subband_activity[j]; k++) {
454
            s->transition_mode[j][k] = 0;
455
            if (s->subsubframes > 1 &&
456
                k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
457
                s->transition_mode[j][k] =
458
                    get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
459
            }
460
        }
461
    }
462

    
463
    for (j = 0; j < s->prim_channels; j++) {
464
        const uint32_t *scale_table;
465
        int scale_sum;
466

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

    
469
        if (s->scalefactor_huffman[j] == 6)
470
            scale_table = scale_factor_quant7;
471
        else
472
            scale_table = scale_factor_quant6;
473

    
474
        /* When huffman coded, only the difference is encoded */
475
        scale_sum = 0;
476

    
477
        for (k = 0; k < s->subband_activity[j]; k++) {
478
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
479
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
480
                s->scale_factor[j][k][0] = scale_table[scale_sum];
481
            }
482

    
483
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
484
                /* Get second scale factor */
485
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
486
                s->scale_factor[j][k][1] = scale_table[scale_sum];
487
            }
488
        }
489
    }
490

    
491
    /* Joint subband scale factor codebook select */
492
    for (j = 0; j < s->prim_channels; j++) {
493
        /* Transmitted only if joint subband coding enabled */
494
        if (s->joint_intensity[j] > 0)
495
            s->joint_huff[j] = get_bits(&s->gb, 3);
496
    }
497

    
498
    /* Scale factors for joint subband coding */
499
    for (j = 0; j < s->prim_channels; j++) {
500
        int source_channel;
501

    
502
        /* Transmitted only if joint subband coding enabled */
503
        if (s->joint_intensity[j] > 0) {
504
            int scale = 0;
505
            source_channel = s->joint_intensity[j] - 1;
506

    
507
            /* When huffman coded, only the difference is encoded
508
             * (is this valid as well for joint scales ???) */
509

    
510
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
511
                scale = get_scale(&s->gb, s->joint_huff[j], 0);
512
                scale += 64;    /* bias */
513
                s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
514
            }
515

    
516
            if (!s->debug_flag & 0x02) {
517
                av_log(s->avctx, AV_LOG_DEBUG,
518
                       "Joint stereo coding not supported\n");
519
                s->debug_flag |= 0x02;
520
            }
521
        }
522
    }
523

    
524
    /* Stereo downmix coefficients */
525
    if (s->prim_channels > 2) {
526
        if(s->downmix) {
527
            for (j = 0; j < s->prim_channels; j++) {
528
                s->downmix_coef[j][0] = get_bits(&s->gb, 7);
529
                s->downmix_coef[j][1] = get_bits(&s->gb, 7);
530
            }
531
        } else {
532
            int am = s->amode & DCA_CHANNEL_MASK;
533
            for (j = 0; j < s->prim_channels; j++) {
534
                s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
535
                s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
536
            }
537
        }
538
    }
539

    
540
    /* Dynamic range coefficient */
541
    if (s->dynrange)
542
        s->dynrange_coef = get_bits(&s->gb, 8);
543

    
544
    /* Side information CRC check word */
545
    if (s->crc_present) {
546
        get_bits(&s->gb, 16);
547
    }
548

    
549
    /*
550
     * Primary audio data arrays
551
     */
552

    
553
    /* VQ encoded high frequency subbands */
554
    for (j = 0; j < s->prim_channels; j++)
555
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
556
            /* 1 vector -> 32 samples */
557
            s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
558

    
559
    /* Low frequency effect data */
560
    if (s->lfe) {
561
        /* LFE samples */
562
        int lfe_samples = 2 * s->lfe * s->subsubframes;
563
        float lfe_scale;
564

    
565
        for (j = lfe_samples; j < lfe_samples * 2; j++) {
566
            /* Signed 8 bits int */
567
            s->lfe_data[j] = get_sbits(&s->gb, 8);
568
        }
569

    
570
        /* Scale factor index */
571
        s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
572

    
573
        /* Quantization step size * scale factor */
574
        lfe_scale = 0.035 * s->lfe_scale_factor;
575

    
576
        for (j = lfe_samples; j < lfe_samples * 2; j++)
577
            s->lfe_data[j] *= lfe_scale;
578
    }
579

    
580
#ifdef TRACE
581
    av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
582
    av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
583
           s->partial_samples);
584
    for (j = 0; j < s->prim_channels; j++) {
585
        av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
586
        for (k = 0; k < s->subband_activity[j]; k++)
587
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
588
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
589
    }
590
    for (j = 0; j < s->prim_channels; j++) {
591
        for (k = 0; k < s->subband_activity[j]; k++)
592
                av_log(s->avctx, AV_LOG_DEBUG,
593
                       "prediction coefs: %f, %f, %f, %f\n",
594
                       (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
595
                       (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
596
                       (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
597
                       (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
598
    }
599
    for (j = 0; j < s->prim_channels; j++) {
600
        av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
601
        for (k = 0; k < s->vq_start_subband[j]; k++)
602
            av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
603
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
604
    }
605
    for (j = 0; j < s->prim_channels; j++) {
606
        av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
607
        for (k = 0; k < s->subband_activity[j]; k++)
608
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
609
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
610
    }
611
    for (j = 0; j < s->prim_channels; j++) {
612
        av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
613
        for (k = 0; k < s->subband_activity[j]; k++) {
614
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
615
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
616
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
617
                av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
618
        }
619
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
620
    }
621
    for (j = 0; j < s->prim_channels; j++) {
622
        if (s->joint_intensity[j] > 0) {
623
            int source_channel = s->joint_intensity[j] - 1;
624
            av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
625
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
626
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
627
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
628
        }
629
    }
630
    if (s->prim_channels > 2 && s->downmix) {
631
        av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
632
        for (j = 0; j < s->prim_channels; j++) {
633
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
634
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
635
        }
636
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
637
    }
638
    for (j = 0; j < s->prim_channels; j++)
639
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
640
            av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
641
    if(s->lfe){
642
        int lfe_samples = 2 * s->lfe * s->subsubframes;
643
        av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
644
        for (j = lfe_samples; j < lfe_samples * 2; j++)
645
            av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
646
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
647
    }
648
#endif
649

    
650
    return 0;
651
}
652

    
653
static void qmf_32_subbands(DCAContext * s, int chans,
654
                            float samples_in[32][8], float *samples_out,
655
                            float scale, float bias)
656
{
657
    const float *prCoeff;
658
    int i, j, k;
659
    float praXin[33], *raXin = &praXin[1];
660

    
661
    float *subband_fir_hist = s->subband_fir_hist[chans];
662
    float *subband_fir_hist2 = s->subband_fir_noidea[chans];
663

    
664
    int chindex = 0, subindex;
665

    
666
    praXin[0] = 0.0;
667

    
668
    /* Select filter */
669
    if (!s->multirate_inter)    /* Non-perfect reconstruction */
670
        prCoeff = fir_32bands_nonperfect;
671
    else                        /* Perfect reconstruction */
672
        prCoeff = fir_32bands_perfect;
673

    
674
    /* Reconstructed channel sample index */
675
    for (subindex = 0; subindex < 8; subindex++) {
676
        float t1, t2, sum[16], diff[16];
677

    
678
        /* Load in one sample from each subband and clear inactive subbands */
679
        for (i = 0; i < s->subband_activity[chans]; i++)
680
            raXin[i] = samples_in[i][subindex];
681
        for (; i < 32; i++)
682
            raXin[i] = 0.0;
683

    
684
        /* Multiply by cosine modulation coefficients and
685
         * create temporary arrays SUM and DIFF */
686
        for (j = 0, k = 0; k < 16; k++) {
687
            t1 = 0.0;
688
            t2 = 0.0;
689
            for (i = 0; i < 16; i++, j++){
690
                t1 += (raXin[2 * i] + raXin[2 * i + 1]) * cos_mod[j];
691
                t2 += (raXin[2 * i] + raXin[2 * i - 1]) * cos_mod[j + 256];
692
            }
693
            sum[k] = t1 + t2;
694
            diff[k] = t1 - t2;
695
        }
696

    
697
        j = 512;
698
        /* Store history */
699
        for (k = 0; k < 16; k++)
700
            subband_fir_hist[k] = cos_mod[j++] * sum[k];
701
        for (k = 0; k < 16; k++)
702
            subband_fir_hist[32-k-1] = cos_mod[j++] * diff[k];
703

    
704
        /* Multiply by filter coefficients */
705
        for (k = 31, i = 0; i < 32; i++, k--)
706
            for (j = 0; j < 512; j += 64){
707
                subband_fir_hist2[i]    += prCoeff[i+j]  * ( subband_fir_hist[i+j] - subband_fir_hist[j+k]);
708
                subband_fir_hist2[i+32] += prCoeff[i+j+32]*(-subband_fir_hist[i+j] - subband_fir_hist[j+k]);
709
            }
710

    
711
        /* Create 32 PCM output samples */
712
        for (i = 0; i < 32; i++)
713
            samples_out[chindex++] = subband_fir_hist2[i] * scale + bias;
714

    
715
        /* Update working arrays */
716
        memmove(&subband_fir_hist[32], &subband_fir_hist[0], (512 - 32) * sizeof(float));
717
        memmove(&subband_fir_hist2[0], &subband_fir_hist2[32], 32 * sizeof(float));
718
        memset(&subband_fir_hist2[32], 0, 32 * sizeof(float));
719
    }
720
}
721

    
722
static void lfe_interpolation_fir(int decimation_select,
723
                                  int num_deci_sample, float *samples_in,
724
                                  float *samples_out, float scale,
725
                                  float bias)
726
{
727
    /* samples_in: An array holding decimated samples.
728
     *   Samples in current subframe starts from samples_in[0],
729
     *   while samples_in[-1], samples_in[-2], ..., stores samples
730
     *   from last subframe as history.
731
     *
732
     * samples_out: An array holding interpolated samples
733
     */
734

    
735
    int decifactor, k, j;
736
    const float *prCoeff;
737

    
738
    int interp_index = 0;       /* Index to the interpolated samples */
739
    int deciindex;
740

    
741
    /* Select decimation filter */
742
    if (decimation_select == 1) {
743
        decifactor = 128;
744
        prCoeff = lfe_fir_128;
745
    } else {
746
        decifactor = 64;
747
        prCoeff = lfe_fir_64;
748
    }
749
    /* Interpolation */
750
    for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
751
        /* One decimated sample generates decifactor interpolated ones */
752
        for (k = 0; k < decifactor; k++) {
753
            float rTmp = 0.0;
754
            //FIXME the coeffs are symetric, fix that
755
            for (j = 0; j < 512 / decifactor; j++)
756
                rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
757
            samples_out[interp_index++] = rTmp / scale + bias;
758
        }
759
    }
760
}
761

    
762
/* downmixing routines */
763
#define MIX_REAR1(samples, si1, rs, coef) \
764
     samples[i]     += samples[si1] * coef[rs][0]; \
765
     samples[i+256] += samples[si1] * coef[rs][1];
766

    
767
#define MIX_REAR2(samples, si1, si2, rs, coef) \
768
     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
769
     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
770

    
771
#define MIX_FRONT3(samples, coef) \
772
    t = samples[i]; \
773
    samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
774
    samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
775

    
776
#define DOWNMIX_TO_STEREO(op1, op2) \
777
    for(i = 0; i < 256; i++){ \
778
        op1 \
779
        op2 \
780
    }
781

    
782
static void dca_downmix(float *samples, int srcfmt,
783
                        int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
784
{
785
    int i;
786
    float t;
787
    float coef[DCA_PRIM_CHANNELS_MAX][2];
788

    
789
    for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
790
        coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
791
        coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
792
    }
793

    
794
    switch (srcfmt) {
795
    case DCA_MONO:
796
    case DCA_CHANNEL:
797
    case DCA_STEREO_TOTAL:
798
    case DCA_STEREO_SUMDIFF:
799
    case DCA_4F2R:
800
        av_log(NULL, 0, "Not implemented!\n");
801
        break;
802
    case DCA_STEREO:
803
        break;
804
    case DCA_3F:
805
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
806
        break;
807
    case DCA_2F1R:
808
        DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
809
        break;
810
    case DCA_3F1R:
811
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
812
                          MIX_REAR1(samples, i + 768, 3, coef));
813
        break;
814
    case DCA_2F2R:
815
        DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
816
        break;
817
    case DCA_3F2R:
818
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
819
                          MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
820
        break;
821
    }
822
}
823

    
824

    
825
/* Very compact version of the block code decoder that does not use table
826
 * look-up but is slightly slower */
827
static int decode_blockcode(int code, int levels, int *values)
828
{
829
    int i;
830
    int offset = (levels - 1) >> 1;
831

    
832
    for (i = 0; i < 4; i++) {
833
        values[i] = (code % levels) - offset;
834
        code /= levels;
835
    }
836

    
837
    if (code == 0)
838
        return 0;
839
    else {
840
        av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
841
        return -1;
842
    }
843
}
844

    
845
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
846
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
847

    
848
static int dca_subsubframe(DCAContext * s)
849
{
850
    int k, l;
851
    int subsubframe = s->current_subsubframe;
852

    
853
    const float *quant_step_table;
854

    
855
    /* FIXME */
856
    float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
857

    
858
    /*
859
     * Audio data
860
     */
861

    
862
    /* Select quantization step size table */
863
    if (s->bit_rate == 0x1f)
864
        quant_step_table = lossless_quant_d;
865
    else
866
        quant_step_table = lossy_quant_d;
867

    
868
    for (k = 0; k < s->prim_channels; k++) {
869
        for (l = 0; l < s->vq_start_subband[k]; l++) {
870
            int m;
871

    
872
            /* Select the mid-tread linear quantizer */
873
            int abits = s->bitalloc[k][l];
874

    
875
            float quant_step_size = quant_step_table[abits];
876
            float rscale;
877

    
878
            /*
879
             * Determine quantization index code book and its type
880
             */
881

    
882
            /* Select quantization index code book */
883
            int sel = s->quant_index_huffman[k][abits];
884

    
885
            /*
886
             * Extract bits from the bit stream
887
             */
888
            if(!abits){
889
                memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
890
            }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
891
                if(abits <= 7){
892
                    /* Block code */
893
                    int block_code1, block_code2, size, levels;
894
                    int block[8];
895

    
896
                    size = abits_sizes[abits-1];
897
                    levels = abits_levels[abits-1];
898

    
899
                    block_code1 = get_bits(&s->gb, size);
900
                    /* FIXME Should test return value */
901
                    decode_blockcode(block_code1, levels, block);
902
                    block_code2 = get_bits(&s->gb, size);
903
                    decode_blockcode(block_code2, levels, &block[4]);
904
                    for (m = 0; m < 8; m++)
905
                        subband_samples[k][l][m] = block[m];
906
                }else{
907
                    /* no coding */
908
                    for (m = 0; m < 8; m++)
909
                        subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
910
                }
911
            }else{
912
                /* Huffman coded */
913
                for (m = 0; m < 8; m++)
914
                    subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
915
            }
916

    
917
            /* Deal with transients */
918
            if (s->transition_mode[k][l] &&
919
                subsubframe >= s->transition_mode[k][l])
920
                rscale = quant_step_size * s->scale_factor[k][l][1];
921
            else
922
                rscale = quant_step_size * s->scale_factor[k][l][0];
923

    
924
            rscale *= s->scalefactor_adj[k][sel];
925

    
926
            for (m = 0; m < 8; m++)
927
                subband_samples[k][l][m] *= rscale;
928

    
929
            /*
930
             * Inverse ADPCM if in prediction mode
931
             */
932
            if (s->prediction_mode[k][l]) {
933
                int n;
934
                for (m = 0; m < 8; m++) {
935
                    for (n = 1; n <= 4; n++)
936
                        if (m >= n)
937
                            subband_samples[k][l][m] +=
938
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
939
                                 subband_samples[k][l][m - n] / 8192);
940
                        else if (s->predictor_history)
941
                            subband_samples[k][l][m] +=
942
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
943
                                 s->subband_samples_hist[k][l][m - n +
944
                                                               4] / 8192);
945
                }
946
            }
947
        }
948

    
949
        /*
950
         * Decode VQ encoded high frequencies
951
         */
952
        for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
953
            /* 1 vector -> 32 samples but we only need the 8 samples
954
             * for this subsubframe. */
955
            int m;
956

    
957
            if (!s->debug_flag & 0x01) {
958
                av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
959
                s->debug_flag |= 0x01;
960
            }
961

    
962
            for (m = 0; m < 8; m++) {
963
                subband_samples[k][l][m] =
964
                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
965
                                                        m]
966
                    * (float) s->scale_factor[k][l][0] / 16.0;
967
            }
968
        }
969
    }
970

    
971
    /* Check for DSYNC after subsubframe */
972
    if (s->aspf || subsubframe == s->subsubframes - 1) {
973
        if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
974
#ifdef TRACE
975
            av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
976
#endif
977
        } else {
978
            av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
979
        }
980
    }
981

    
982
    /* Backup predictor history for adpcm */
983
    for (k = 0; k < s->prim_channels; k++)
984
        for (l = 0; l < s->vq_start_subband[k]; l++)
985
            memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
986
                        4 * sizeof(subband_samples[0][0][0]));
987

    
988
    /* 32 subbands QMF */
989
    for (k = 0; k < s->prim_channels; k++) {
990
/*        static float pcm_to_double[8] =
991
            {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
992
         qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * k],
993
                            2.0 / 3 /*pcm_to_double[s->source_pcm_res] */ ,
994
                            0 /*s->bias */ );
995
    }
996

    
997
    /* Down mixing */
998

    
999
    if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1000
        dca_downmix(s->samples, s->amode, s->downmix_coef);
1001
    }
1002

    
1003
    /* Generate LFE samples for this subsubframe FIXME!!! */
1004
    if (s->output & DCA_LFE) {
1005
        int lfe_samples = 2 * s->lfe * s->subsubframes;
1006
        int i_channels = dca_channels[s->output & DCA_CHANNEL_MASK];
1007

    
1008
        lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1009
                              s->lfe_data + lfe_samples +
1010
                              2 * s->lfe * subsubframe,
1011
                              &s->samples[256 * i_channels],
1012
                              256.0, 0 /* s->bias */);
1013
        /* Outputs 20bits pcm samples */
1014
    }
1015

    
1016
    return 0;
1017
}
1018

    
1019

    
1020
static int dca_subframe_footer(DCAContext * s)
1021
{
1022
    int aux_data_count = 0, i;
1023
    int lfe_samples;
1024

    
1025
    /*
1026
     * Unpack optional information
1027
     */
1028

    
1029
    if (s->timestamp)
1030
        get_bits(&s->gb, 32);
1031

    
1032
    if (s->aux_data)
1033
        aux_data_count = get_bits(&s->gb, 6);
1034

    
1035
    for (i = 0; i < aux_data_count; i++)
1036
        get_bits(&s->gb, 8);
1037

    
1038
    if (s->crc_present && (s->downmix || s->dynrange))
1039
        get_bits(&s->gb, 16);
1040

    
1041
    lfe_samples = 2 * s->lfe * s->subsubframes;
1042
    for (i = 0; i < lfe_samples; i++) {
1043
        s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1044
    }
1045

    
1046
    return 0;
1047
}
1048

    
1049
/**
1050
 * Decode a dca frame block
1051
 *
1052
 * @param s     pointer to the DCAContext
1053
 */
1054

    
1055
static int dca_decode_block(DCAContext * s)
1056
{
1057

    
1058
    /* Sanity check */
1059
    if (s->current_subframe >= s->subframes) {
1060
        av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1061
               s->current_subframe, s->subframes);
1062
        return -1;
1063
    }
1064

    
1065
    if (!s->current_subsubframe) {
1066
#ifdef TRACE
1067
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1068
#endif
1069
        /* Read subframe header */
1070
        if (dca_subframe_header(s))
1071
            return -1;
1072
    }
1073

    
1074
    /* Read subsubframe */
1075
#ifdef TRACE
1076
    av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1077
#endif
1078
    if (dca_subsubframe(s))
1079
        return -1;
1080

    
1081
    /* Update state */
1082
    s->current_subsubframe++;
1083
    if (s->current_subsubframe >= s->subsubframes) {
1084
        s->current_subsubframe = 0;
1085
        s->current_subframe++;
1086
    }
1087
    if (s->current_subframe >= s->subframes) {
1088
#ifdef TRACE
1089
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1090
#endif
1091
        /* Read subframe footer */
1092
        if (dca_subframe_footer(s))
1093
            return -1;
1094
    }
1095

    
1096
    return 0;
1097
}
1098

    
1099
/**
1100
 * Convert bitstream to one representation based on sync marker
1101
 */
1102
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1103
                          int max_size)
1104
{
1105
    uint32_t mrk;
1106
    int i, tmp;
1107
    const uint16_t *ssrc = (const uint16_t *) src;
1108
    uint16_t *sdst = (uint16_t *) dst;
1109
    PutBitContext pb;
1110

    
1111
    if((unsigned)src_size > (unsigned)max_size) {
1112
        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1113
        return -1;
1114
    }
1115

    
1116
    mrk = AV_RB32(src);
1117
    switch (mrk) {
1118
    case DCA_MARKER_RAW_BE:
1119
        memcpy(dst, src, FFMIN(src_size, max_size));
1120
        return FFMIN(src_size, max_size);
1121
    case DCA_MARKER_RAW_LE:
1122
        for (i = 0; i < (FFMIN(src_size, max_size) + 1) >> 1; i++)
1123
            *sdst++ = bswap_16(*ssrc++);
1124
        return FFMIN(src_size, max_size);
1125
    case DCA_MARKER_14B_BE:
1126
    case DCA_MARKER_14B_LE:
1127
        init_put_bits(&pb, dst, max_size);
1128
        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1129
            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1130
            put_bits(&pb, 14, tmp);
1131
        }
1132
        flush_put_bits(&pb);
1133
        return (put_bits_count(&pb) + 7) >> 3;
1134
    default:
1135
        return -1;
1136
    }
1137
}
1138

    
1139
/**
1140
 * Main frame decoding function
1141
 * FIXME add arguments
1142
 */
1143
static int dca_decode_frame(AVCodecContext * avctx,
1144
                            void *data, int *data_size,
1145
                            const uint8_t * buf, int buf_size)
1146
{
1147

    
1148
    int i, j, k;
1149
    int16_t *samples = data;
1150
    DCAContext *s = avctx->priv_data;
1151
    int channels;
1152

    
1153

    
1154
    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1155
    if (s->dca_buffer_size == -1) {
1156
        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1157
        return -1;
1158
    }
1159

    
1160
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1161
    if (dca_parse_frame_header(s) < 0) {
1162
        //seems like the frame is corrupt, try with the next one
1163
        *data_size=0;
1164
        return buf_size;
1165
    }
1166
    //set AVCodec values with parsed data
1167
    avctx->sample_rate = s->sample_rate;
1168
    avctx->bit_rate = s->bit_rate;
1169

    
1170
    channels = s->prim_channels + !!s->lfe;
1171
    if(avctx->request_channels == 2 && s->prim_channels > 2) {
1172
        channels = 2;
1173
        s->output = DCA_STEREO;
1174
    }
1175

    
1176
    /* There is nothing that prevents a dts frame to change channel configuration
1177
       but FFmpeg doesn't support that so only set the channels if it is previously
1178
       unset. Ideally during the first probe for channels the crc should be checked
1179
       and only set avctx->channels when the crc is ok. Right now the decoder could
1180
       set the channels based on a broken first frame.*/
1181
    if (!avctx->channels)
1182
        avctx->channels = channels;
1183

    
1184
    if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1185
        return -1;
1186
    *data_size = 0;
1187
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1188
        dca_decode_block(s);
1189
        s->dsp.float_to_int16(s->tsamples, s->samples, 256 * channels);
1190
        /* interleave samples */
1191
        for (j = 0; j < 256; j++) {
1192
            for (k = 0; k < channels; k++)
1193
                samples[k] = s->tsamples[j + k * 256];
1194
            samples += channels;
1195
        }
1196
        *data_size += 256 * sizeof(int16_t) * channels;
1197
    }
1198

    
1199
    return buf_size;
1200
}
1201

    
1202

    
1203

    
1204
/**
1205
 * Build the cosine modulation tables for the QMF
1206
 *
1207
 * @param s     pointer to the DCAContext
1208
 */
1209

    
1210
static av_cold void pre_calc_cosmod(DCAContext * s)
1211
{
1212
    int i, j, k;
1213
    static int cosmod_initialized = 0;
1214

    
1215
    if(cosmod_initialized) return;
1216
    for (j = 0, k = 0; k < 16; k++)
1217
        for (i = 0; i < 16; i++)
1218
            cos_mod[j++] = cos((2 * i + 1) * (2 * k + 1) * M_PI / 64);
1219

    
1220
    for (k = 0; k < 16; k++)
1221
        for (i = 0; i < 16; i++)
1222
            cos_mod[j++] = cos((i) * (2 * k + 1) * M_PI / 32);
1223

    
1224
    for (k = 0; k < 16; k++)
1225
        cos_mod[j++] = 0.25 / (2 * cos((2 * k + 1) * M_PI / 128));
1226

    
1227
    for (k = 0; k < 16; k++)
1228
        cos_mod[j++] = -0.25 / (2.0 * sin((2 * k + 1) * M_PI / 128));
1229

    
1230
    cosmod_initialized = 1;
1231
}
1232

    
1233

    
1234
/**
1235
 * DCA initialization
1236
 *
1237
 * @param avctx     pointer to the AVCodecContext
1238
 */
1239

    
1240
static av_cold int dca_decode_init(AVCodecContext * avctx)
1241
{
1242
    DCAContext *s = avctx->priv_data;
1243

    
1244
    s->avctx = avctx;
1245
    dca_init_vlcs();
1246
    pre_calc_cosmod(s);
1247

    
1248
    dsputil_init(&s->dsp, avctx);
1249

    
1250
    /* allow downmixing to stereo */
1251
    if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1252
            avctx->request_channels == 2) {
1253
        avctx->channels = avctx->request_channels;
1254
    }
1255

    
1256
    return 0;
1257
}
1258

    
1259

    
1260
AVCodec dca_decoder = {
1261
    .name = "dca",
1262
    .type = CODEC_TYPE_AUDIO,
1263
    .id = CODEC_ID_DTS,
1264
    .priv_data_size = sizeof(DCAContext),
1265
    .init = dca_decode_init,
1266
    .decode = dca_decode_frame,
1267
};