Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ 9d9b9d32

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

    
72
static const int64_t dca_core_channel_layout[] = {
73
    CH_FRONT_CENTER,                                               ///< 1, A
74
    CH_LAYOUT_STEREO,                                              ///< 2, A + B (dual mono)
75
    CH_LAYOUT_STEREO,                                              ///< 2, L + R (stereo)
76
    CH_LAYOUT_STEREO,                                              ///< 2, (L+R) + (L-R) (sum-difference)
77
    CH_LAYOUT_STEREO,                                              ///< 2, LT +RT (left and right total)
78
    CH_LAYOUT_STEREO|CH_FRONT_CENTER,                         ///< 3, C+L+R
79
    CH_LAYOUT_STEREO|CH_BACK_CENTER,                          ///< 3, L+R+S
80
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,     ///< 4, C + L + R+ S
81
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT,         ///< 4, L + R+ SL+SR
82
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT,                                       ///< 5, C + L + R+ SL+SR
83
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
84
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,                   ///< 6, C + L + R+ LR + RR + OV
85
    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
86
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
87
    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
88
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_CENTER|CH_BACK_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
89

    
90
    /* The following entries adds the LFE layouts, this way we can reuse the table for the AVCodec channel_layouts member*/
91
    CH_FRONT_CENTER|CH_LOW_FREQUENCY,
92
    CH_LAYOUT_STEREO|CH_LOW_FREQUENCY,
93
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_LOW_FREQUENCY,
94
    CH_LAYOUT_STEREO|CH_BACK_CENTER|CH_LOW_FREQUENCY,
95
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER|CH_LOW_FREQUENCY,
96
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_LOW_FREQUENCY,
97
    CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT|CH_LOW_FREQUENCY,
98
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LOW_FREQUENCY,
99
    CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER|CH_LOW_FREQUENCY,
100
    CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT|CH_LOW_FREQUENCY,
101
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_LOW_FREQUENCY,
102
    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|CH_LOW_FREQUENCY,
103
    CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_CENTER|CH_BACK_RIGHT|CH_LOW_FREQUENCY,
104
    0,
105
};
106

    
107

    
108
#define DCA_DOLBY 101           /* FIXME */
109

    
110
#define DCA_CHANNEL_BITS 6
111
#define DCA_CHANNEL_MASK 0x3F
112

    
113
#define DCA_LFE 0x80
114

    
115
#define HEADER_SIZE 14
116

    
117
#define DCA_MAX_FRAME_SIZE 16384
118

    
119
/** Bit allocation */
120
typedef struct {
121
    int offset;                 ///< code values offset
122
    int maxbits[8];             ///< max bits in VLC
123
    int wrap;                   ///< wrap for get_vlc2()
124
    VLC vlc[8];                 ///< actual codes
125
} BitAlloc;
126

    
127
static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
128
static BitAlloc dca_tmode;             ///< transition mode VLCs
129
static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
130
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
131

    
132
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
133
{
134
    return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
135
}
136

    
137
typedef struct {
138
    AVCodecContext *avctx;
139
    /* Frame header */
140
    int frame_type;             ///< type of the current frame
141
    int samples_deficit;        ///< deficit sample count
142
    int crc_present;            ///< crc is present in the bitstream
143
    int sample_blocks;          ///< number of PCM sample blocks
144
    int frame_size;             ///< primary frame byte size
145
    int amode;                  ///< audio channels arrangement
146
    int sample_rate;            ///< audio sampling rate
147
    int bit_rate;               ///< transmission bit rate
148
    int bit_rate_index;         ///< transmission bit rate index
149

    
150
    int downmix;                ///< embedded downmix enabled
151
    int dynrange;               ///< embedded dynamic range flag
152
    int timestamp;              ///< embedded time stamp flag
153
    int aux_data;               ///< auxiliary data flag
154
    int hdcd;                   ///< source material is mastered in HDCD
155
    int ext_descr;              ///< extension audio descriptor flag
156
    int ext_coding;             ///< extended coding flag
157
    int aspf;                   ///< audio sync word insertion flag
158
    int lfe;                    ///< low frequency effects flag
159
    int predictor_history;      ///< predictor history flag
160
    int header_crc;             ///< header crc check bytes
161
    int multirate_inter;        ///< multirate interpolator switch
162
    int version;                ///< encoder software revision
163
    int copy_history;           ///< copy history
164
    int source_pcm_res;         ///< source pcm resolution
165
    int front_sum;              ///< front sum/difference flag
166
    int surround_sum;           ///< surround sum/difference flag
167
    int dialog_norm;            ///< dialog normalisation parameter
168

    
169
    /* Primary audio coding header */
170
    int subframes;              ///< number of subframes
171
    int total_channels;         ///< number of channels including extensions
172
    int prim_channels;          ///< number of primary audio channels
173
    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
174
    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
175
    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
176
    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
177
    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
178
    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
179
    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
180
    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
181

    
182
    /* Primary audio coding side information */
183
    int subsubframes;           ///< number of subsubframes
184
    int partial_samples;        ///< partial subsubframe samples count
185
    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
186
    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
187
    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
188
    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
189
    int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
190
    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
191
    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
192
    int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
193
    int dynrange_coef;                                           ///< dynamic range coefficient
194

    
195
    int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
196

    
197
    float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
198
                   2 /*history */ ];    ///< Low frequency effect data
199
    int lfe_scale_factor;
200

    
201
    /* Subband samples history (for ADPCM) */
202
    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
203
    DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]);
204
    float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];
205
    int hist_index[DCA_PRIM_CHANNELS_MAX];
206

    
207
    int output;                 ///< type of output
208
    float add_bias;             ///< output bias
209
    float scale_bias;           ///< output scale
210

    
211
    DECLARE_ALIGNED_16(float, samples[1536]);  /* 6 * 256 = 1536, might only need 5 */
212
    const float *samples_chanptr[6];
213

    
214
    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
215
    int dca_buffer_size;        ///< how much data is in the dca_buffer
216

    
217
    GetBitContext gb;
218
    /* Current position in DCA frame */
219
    int current_subframe;
220
    int current_subsubframe;
221

    
222
    int debug_flag;             ///< used for suppressing repeated error messages output
223
    DSPContext dsp;
224
    MDCTContext imdct;
225
} DCAContext;
226

    
227
static av_cold void dca_init_vlcs(void)
228
{
229
    static int vlcs_initialized = 0;
230
    int i, j;
231

    
232
    if (vlcs_initialized)
233
        return;
234

    
235
    dca_bitalloc_index.offset = 1;
236
    dca_bitalloc_index.wrap = 2;
237
    for (i = 0; i < 5; i++)
238
        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
239
                 bitalloc_12_bits[i], 1, 1,
240
                 bitalloc_12_codes[i], 2, 2, 1);
241
    dca_scalefactor.offset = -64;
242
    dca_scalefactor.wrap = 2;
243
    for (i = 0; i < 5; i++)
244
        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
245
                 scales_bits[i], 1, 1,
246
                 scales_codes[i], 2, 2, 1);
247
    dca_tmode.offset = 0;
248
    dca_tmode.wrap = 1;
249
    for (i = 0; i < 4; i++)
250
        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
251
                 tmode_bits[i], 1, 1,
252
                 tmode_codes[i], 2, 2, 1);
253

    
254
    for(i = 0; i < 10; i++)
255
        for(j = 0; j < 7; j++){
256
            if(!bitalloc_codes[i][j]) break;
257
            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
258
            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
259
            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
260
                     bitalloc_sizes[i],
261
                     bitalloc_bits[i][j], 1, 1,
262
                     bitalloc_codes[i][j], 2, 2, 1);
263
        }
264
    vlcs_initialized = 1;
265
}
266

    
267
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
268
{
269
    while(len--)
270
        *dst++ = get_bits(gb, bits);
271
}
272

    
273
static int dca_parse_frame_header(DCAContext * s)
274
{
275
    int i, j;
276
    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
277
    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
278
    static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
279

    
280
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
281

    
282
    /* Sync code */
283
    get_bits(&s->gb, 32);
284

    
285
    /* Frame header */
286
    s->frame_type        = get_bits(&s->gb, 1);
287
    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
288
    s->crc_present       = get_bits(&s->gb, 1);
289
    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
290
    s->frame_size        = get_bits(&s->gb, 14) + 1;
291
    if (s->frame_size < 95)
292
        return -1;
293
    s->amode             = get_bits(&s->gb, 6);
294
    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
295
    if (!s->sample_rate)
296
        return -1;
297
    s->bit_rate_index    = get_bits(&s->gb, 5);
298
    s->bit_rate          = dca_bit_rates[s->bit_rate_index];
299
    if (!s->bit_rate)
300
        return -1;
301

    
302
    s->downmix           = get_bits(&s->gb, 1);
303
    s->dynrange          = get_bits(&s->gb, 1);
304
    s->timestamp         = get_bits(&s->gb, 1);
305
    s->aux_data          = get_bits(&s->gb, 1);
306
    s->hdcd              = get_bits(&s->gb, 1);
307
    s->ext_descr         = get_bits(&s->gb, 3);
308
    s->ext_coding        = get_bits(&s->gb, 1);
309
    s->aspf              = get_bits(&s->gb, 1);
310
    s->lfe               = get_bits(&s->gb, 2);
311
    s->predictor_history = get_bits(&s->gb, 1);
312

    
313
    /* TODO: check CRC */
314
    if (s->crc_present)
315
        s->header_crc    = get_bits(&s->gb, 16);
316

    
317
    s->multirate_inter   = get_bits(&s->gb, 1);
318
    s->version           = get_bits(&s->gb, 4);
319
    s->copy_history      = get_bits(&s->gb, 2);
320
    s->source_pcm_res    = get_bits(&s->gb, 3);
321
    s->front_sum         = get_bits(&s->gb, 1);
322
    s->surround_sum      = get_bits(&s->gb, 1);
323
    s->dialog_norm       = get_bits(&s->gb, 4);
324

    
325
    /* FIXME: channels mixing levels */
326
    s->output = s->amode;
327
    if(s->lfe) s->output |= DCA_LFE;
328

    
329
#ifdef TRACE
330
    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
331
    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
332
    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
333
    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
334
           s->sample_blocks, s->sample_blocks * 32);
335
    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
336
    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
337
           s->amode, dca_channels[s->amode]);
338
    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
339
           s->sample_rate);
340
    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
341
           s->bit_rate);
342
    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
343
    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
344
    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
345
    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
346
    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
347
    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
348
    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
349
    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
350
    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
351
    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
352
           s->predictor_history);
353
    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
354
    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
355
           s->multirate_inter);
356
    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
357
    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
358
    av_log(s->avctx, AV_LOG_DEBUG,
359
           "source pcm resolution: %i (%i bits/sample)\n",
360
           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
361
    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
362
    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
363
    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
364
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
365
#endif
366

    
367
    /* Primary audio coding header */
368
    s->subframes         = get_bits(&s->gb, 4) + 1;
369
    s->total_channels    = get_bits(&s->gb, 3) + 1;
370
    s->prim_channels     = s->total_channels;
371
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
372
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
373

    
374

    
375
    for (i = 0; i < s->prim_channels; i++) {
376
        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
377
        if (s->subband_activity[i] > DCA_SUBBANDS)
378
            s->subband_activity[i] = DCA_SUBBANDS;
379
    }
380
    for (i = 0; i < s->prim_channels; i++) {
381
        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
382
        if (s->vq_start_subband[i] > DCA_SUBBANDS)
383
            s->vq_start_subband[i] = DCA_SUBBANDS;
384
    }
385
    get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
386
    get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
387
    get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
388
    get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
389

    
390
    /* Get codebooks quantization indexes */
391
    memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
392
    for (j = 1; j < 11; j++)
393
        for (i = 0; i < s->prim_channels; i++)
394
            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
395

    
396
    /* Get scale factor adjustment */
397
    for (j = 0; j < 11; j++)
398
        for (i = 0; i < s->prim_channels; i++)
399
            s->scalefactor_adj[i][j] = 1;
400

    
401
    for (j = 1; j < 11; j++)
402
        for (i = 0; i < s->prim_channels; i++)
403
            if (s->quant_index_huffman[i][j] < thr[j])
404
                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
405

    
406
    if (s->crc_present) {
407
        /* Audio header CRC check */
408
        get_bits(&s->gb, 16);
409
    }
410

    
411
    s->current_subframe = 0;
412
    s->current_subsubframe = 0;
413

    
414
#ifdef TRACE
415
    av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
416
    av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
417
    for(i = 0; i < s->prim_channels; i++){
418
        av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
419
        av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
420
        av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
421
        av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
422
        av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
423
        av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
424
        av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
425
        for (j = 0; j < 11; j++)
426
            av_log(s->avctx, AV_LOG_DEBUG, " %i",
427
                   s->quant_index_huffman[i][j]);
428
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
429
        av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
430
        for (j = 0; j < 11; j++)
431
            av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
432
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
433
    }
434
#endif
435

    
436
    return 0;
437
}
438

    
439

    
440
static inline int get_scale(GetBitContext *gb, int level, int value)
441
{
442
   if (level < 5) {
443
       /* huffman encoded */
444
       value += get_bitalloc(gb, &dca_scalefactor, level);
445
   } else if(level < 8)
446
       value = get_bits(gb, level + 1);
447
   return value;
448
}
449

    
450
static int dca_subframe_header(DCAContext * s)
451
{
452
    /* Primary audio coding side information */
453
    int j, k;
454

    
455
    s->subsubframes = get_bits(&s->gb, 2) + 1;
456
    s->partial_samples = get_bits(&s->gb, 3);
457
    for (j = 0; j < s->prim_channels; j++) {
458
        for (k = 0; k < s->subband_activity[j]; k++)
459
            s->prediction_mode[j][k] = get_bits(&s->gb, 1);
460
    }
461

    
462
    /* Get prediction codebook */
463
    for (j = 0; j < s->prim_channels; j++) {
464
        for (k = 0; k < s->subband_activity[j]; k++) {
465
            if (s->prediction_mode[j][k] > 0) {
466
                /* (Prediction coefficient VQ address) */
467
                s->prediction_vq[j][k] = get_bits(&s->gb, 12);
468
            }
469
        }
470
    }
471

    
472
    /* Bit allocation index */
473
    for (j = 0; j < s->prim_channels; j++) {
474
        for (k = 0; k < s->vq_start_subband[j]; k++) {
475
            if (s->bitalloc_huffman[j] == 6)
476
                s->bitalloc[j][k] = get_bits(&s->gb, 5);
477
            else if (s->bitalloc_huffman[j] == 5)
478
                s->bitalloc[j][k] = get_bits(&s->gb, 4);
479
            else if (s->bitalloc_huffman[j] == 7) {
480
                av_log(s->avctx, AV_LOG_ERROR,
481
                       "Invalid bit allocation index\n");
482
                return -1;
483
            } else {
484
                s->bitalloc[j][k] =
485
                    get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
486
            }
487

    
488
            if (s->bitalloc[j][k] > 26) {
489
//                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
490
//                          j, k, s->bitalloc[j][k]);
491
                return -1;
492
            }
493
        }
494
    }
495

    
496
    /* Transition mode */
497
    for (j = 0; j < s->prim_channels; j++) {
498
        for (k = 0; k < s->subband_activity[j]; k++) {
499
            s->transition_mode[j][k] = 0;
500
            if (s->subsubframes > 1 &&
501
                k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
502
                s->transition_mode[j][k] =
503
                    get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
504
            }
505
        }
506
    }
507

    
508
    for (j = 0; j < s->prim_channels; j++) {
509
        const uint32_t *scale_table;
510
        int scale_sum;
511

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

    
514
        if (s->scalefactor_huffman[j] == 6)
515
            scale_table = scale_factor_quant7;
516
        else
517
            scale_table = scale_factor_quant6;
518

    
519
        /* When huffman coded, only the difference is encoded */
520
        scale_sum = 0;
521

    
522
        for (k = 0; k < s->subband_activity[j]; k++) {
523
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
524
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
525
                s->scale_factor[j][k][0] = scale_table[scale_sum];
526
            }
527

    
528
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
529
                /* Get second scale factor */
530
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
531
                s->scale_factor[j][k][1] = scale_table[scale_sum];
532
            }
533
        }
534
    }
535

    
536
    /* Joint subband scale factor codebook select */
537
    for (j = 0; j < s->prim_channels; j++) {
538
        /* Transmitted only if joint subband coding enabled */
539
        if (s->joint_intensity[j] > 0)
540
            s->joint_huff[j] = get_bits(&s->gb, 3);
541
    }
542

    
543
    /* Scale factors for joint subband coding */
544
    for (j = 0; j < s->prim_channels; j++) {
545
        int source_channel;
546

    
547
        /* Transmitted only if joint subband coding enabled */
548
        if (s->joint_intensity[j] > 0) {
549
            int scale = 0;
550
            source_channel = s->joint_intensity[j] - 1;
551

    
552
            /* When huffman coded, only the difference is encoded
553
             * (is this valid as well for joint scales ???) */
554

    
555
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
556
                scale = get_scale(&s->gb, s->joint_huff[j], 0);
557
                scale += 64;    /* bias */
558
                s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
559
            }
560

    
561
            if (!s->debug_flag & 0x02) {
562
                av_log(s->avctx, AV_LOG_DEBUG,
563
                       "Joint stereo coding not supported\n");
564
                s->debug_flag |= 0x02;
565
            }
566
        }
567
    }
568

    
569
    /* Stereo downmix coefficients */
570
    if (s->prim_channels > 2) {
571
        if(s->downmix) {
572
            for (j = 0; j < s->prim_channels; j++) {
573
                s->downmix_coef[j][0] = get_bits(&s->gb, 7);
574
                s->downmix_coef[j][1] = get_bits(&s->gb, 7);
575
            }
576
        } else {
577
            int am = s->amode & DCA_CHANNEL_MASK;
578
            for (j = 0; j < s->prim_channels; j++) {
579
                s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
580
                s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
581
            }
582
        }
583
    }
584

    
585
    /* Dynamic range coefficient */
586
    if (s->dynrange)
587
        s->dynrange_coef = get_bits(&s->gb, 8);
588

    
589
    /* Side information CRC check word */
590
    if (s->crc_present) {
591
        get_bits(&s->gb, 16);
592
    }
593

    
594
    /*
595
     * Primary audio data arrays
596
     */
597

    
598
    /* VQ encoded high frequency subbands */
599
    for (j = 0; j < s->prim_channels; j++)
600
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
601
            /* 1 vector -> 32 samples */
602
            s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
603

    
604
    /* Low frequency effect data */
605
    if (s->lfe) {
606
        /* LFE samples */
607
        int lfe_samples = 2 * s->lfe * s->subsubframes;
608
        float lfe_scale;
609

    
610
        for (j = lfe_samples; j < lfe_samples * 2; j++) {
611
            /* Signed 8 bits int */
612
            s->lfe_data[j] = get_sbits(&s->gb, 8);
613
        }
614

    
615
        /* Scale factor index */
616
        s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
617

    
618
        /* Quantization step size * scale factor */
619
        lfe_scale = 0.035 * s->lfe_scale_factor;
620

    
621
        for (j = lfe_samples; j < lfe_samples * 2; j++)
622
            s->lfe_data[j] *= lfe_scale;
623
    }
624

    
625
#ifdef TRACE
626
    av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
627
    av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
628
           s->partial_samples);
629
    for (j = 0; j < s->prim_channels; j++) {
630
        av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
631
        for (k = 0; k < s->subband_activity[j]; k++)
632
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
633
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
634
    }
635
    for (j = 0; j < s->prim_channels; j++) {
636
        for (k = 0; k < s->subband_activity[j]; k++)
637
                av_log(s->avctx, AV_LOG_DEBUG,
638
                       "prediction coefs: %f, %f, %f, %f\n",
639
                       (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
640
                       (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
641
                       (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
642
                       (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
643
    }
644
    for (j = 0; j < s->prim_channels; j++) {
645
        av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
646
        for (k = 0; k < s->vq_start_subband[j]; k++)
647
            av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
648
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
649
    }
650
    for (j = 0; j < s->prim_channels; j++) {
651
        av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
652
        for (k = 0; k < s->subband_activity[j]; k++)
653
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
654
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
655
    }
656
    for (j = 0; j < s->prim_channels; j++) {
657
        av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
658
        for (k = 0; k < s->subband_activity[j]; k++) {
659
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
660
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
661
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
662
                av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
663
        }
664
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
665
    }
666
    for (j = 0; j < s->prim_channels; j++) {
667
        if (s->joint_intensity[j] > 0) {
668
            int source_channel = s->joint_intensity[j] - 1;
669
            av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
670
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
671
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
672
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
673
        }
674
    }
675
    if (s->prim_channels > 2 && s->downmix) {
676
        av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
677
        for (j = 0; j < s->prim_channels; j++) {
678
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
679
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
680
        }
681
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
682
    }
683
    for (j = 0; j < s->prim_channels; j++)
684
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
685
            av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
686
    if(s->lfe){
687
        int lfe_samples = 2 * s->lfe * s->subsubframes;
688
        av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
689
        for (j = lfe_samples; j < lfe_samples * 2; j++)
690
            av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
691
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
692
    }
693
#endif
694

    
695
    return 0;
696
}
697

    
698
static void qmf_32_subbands(DCAContext * s, int chans,
699
                            float samples_in[32][8], float *samples_out,
700
                            float scale, float bias)
701
{
702
    const float *prCoeff;
703
    int i, j;
704
    DECLARE_ALIGNED_16(float, raXin[32]);
705

    
706
    int hist_index= s->hist_index[chans];
707
    float *subband_fir_hist2 = s->subband_fir_noidea[chans];
708

    
709
    int subindex;
710

    
711
    scale *= sqrt(1/8.0);
712

    
713
    /* Select filter */
714
    if (!s->multirate_inter)    /* Non-perfect reconstruction */
715
        prCoeff = fir_32bands_nonperfect;
716
    else                        /* Perfect reconstruction */
717
        prCoeff = fir_32bands_perfect;
718

    
719
    /* Reconstructed channel sample index */
720
    for (subindex = 0; subindex < 8; subindex++) {
721
        float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
722
        /* Load in one sample from each subband and clear inactive subbands */
723
        for (i = 0; i < s->subband_activity[chans]; i++){
724
            if((i-1)&2) raXin[i] = -samples_in[i][subindex];
725
            else        raXin[i] =  samples_in[i][subindex];
726
        }
727
        for (; i < 32; i++)
728
            raXin[i] = 0.0;
729

    
730
        ff_imdct_half(&s->imdct, subband_fir_hist, raXin);
731

    
732
        /* Multiply by filter coefficients */
733
        for (i = 0; i < 16; i++){
734
            float a= subband_fir_hist2[i   ];
735
            float b= subband_fir_hist2[i+16];
736
            float c= 0;
737
            float d= 0;
738
            for (j = 0; j < 512-hist_index; j += 64){
739
                a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j]);
740
                b += prCoeff[i+j+16]*( subband_fir_hist[   i+j]);
741
                c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
742
                d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
743
            }
744
            for (     ; j < 512; j += 64){
745
                a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j-512]);
746
                b += prCoeff[i+j+16]*( subband_fir_hist[   i+j-512]);
747
                c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
748
                d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
749
            }
750
            samples_out[i   ] = a * scale + bias;
751
            samples_out[i+16] = b * scale + bias;
752
            subband_fir_hist2[i   ] = c;
753
            subband_fir_hist2[i+16] = d;
754
        }
755
        samples_out+= 32;
756

    
757
        hist_index = (hist_index-32)&511;
758
    }
759
    s->hist_index[chans]= hist_index;
760
}
761

    
762
static void lfe_interpolation_fir(int decimation_select,
763
                                  int num_deci_sample, float *samples_in,
764
                                  float *samples_out, float scale,
765
                                  float bias)
766
{
767
    /* samples_in: An array holding decimated samples.
768
     *   Samples in current subframe starts from samples_in[0],
769
     *   while samples_in[-1], samples_in[-2], ..., stores samples
770
     *   from last subframe as history.
771
     *
772
     * samples_out: An array holding interpolated samples
773
     */
774

    
775
    int decifactor, k, j;
776
    const float *prCoeff;
777

    
778
    int interp_index = 0;       /* Index to the interpolated samples */
779
    int deciindex;
780

    
781
    /* Select decimation filter */
782
    if (decimation_select == 1) {
783
        decifactor = 128;
784
        prCoeff = lfe_fir_128;
785
    } else {
786
        decifactor = 64;
787
        prCoeff = lfe_fir_64;
788
    }
789
    /* Interpolation */
790
    for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
791
        /* One decimated sample generates decifactor interpolated ones */
792
        for (k = 0; k < decifactor; k++) {
793
            float rTmp = 0.0;
794
            //FIXME the coeffs are symetric, fix that
795
            for (j = 0; j < 512 / decifactor; j++)
796
                rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
797
            samples_out[interp_index++] = (rTmp * scale) + bias;
798
        }
799
    }
800
}
801

    
802
/* downmixing routines */
803
#define MIX_REAR1(samples, si1, rs, coef) \
804
     samples[i]     += samples[si1] * coef[rs][0]; \
805
     samples[i+256] += samples[si1] * coef[rs][1];
806

    
807
#define MIX_REAR2(samples, si1, si2, rs, coef) \
808
     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
809
     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
810

    
811
#define MIX_FRONT3(samples, coef) \
812
    t = samples[i]; \
813
    samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
814
    samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
815

    
816
#define DOWNMIX_TO_STEREO(op1, op2) \
817
    for(i = 0; i < 256; i++){ \
818
        op1 \
819
        op2 \
820
    }
821

    
822
static void dca_downmix(float *samples, int srcfmt,
823
                        int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
824
{
825
    int i;
826
    float t;
827
    float coef[DCA_PRIM_CHANNELS_MAX][2];
828

    
829
    for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
830
        coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
831
        coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
832
    }
833

    
834
    switch (srcfmt) {
835
    case DCA_MONO:
836
    case DCA_CHANNEL:
837
    case DCA_STEREO_TOTAL:
838
    case DCA_STEREO_SUMDIFF:
839
    case DCA_4F2R:
840
        av_log(NULL, 0, "Not implemented!\n");
841
        break;
842
    case DCA_STEREO:
843
        break;
844
    case DCA_3F:
845
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
846
        break;
847
    case DCA_2F1R:
848
        DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
849
        break;
850
    case DCA_3F1R:
851
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
852
                          MIX_REAR1(samples, i + 768, 3, coef));
853
        break;
854
    case DCA_2F2R:
855
        DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
856
        break;
857
    case DCA_3F2R:
858
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
859
                          MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
860
        break;
861
    }
862
}
863

    
864

    
865
/* Very compact version of the block code decoder that does not use table
866
 * look-up but is slightly slower */
867
static int decode_blockcode(int code, int levels, int *values)
868
{
869
    int i;
870
    int offset = (levels - 1) >> 1;
871

    
872
    for (i = 0; i < 4; i++) {
873
        values[i] = (code % levels) - offset;
874
        code /= levels;
875
    }
876

    
877
    if (code == 0)
878
        return 0;
879
    else {
880
        av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
881
        return -1;
882
    }
883
}
884

    
885
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
886
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
887

    
888
static int dca_subsubframe(DCAContext * s)
889
{
890
    int k, l;
891
    int subsubframe = s->current_subsubframe;
892

    
893
    const float *quant_step_table;
894

    
895
    /* FIXME */
896
    float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
897

    
898
    /*
899
     * Audio data
900
     */
901

    
902
    /* Select quantization step size table */
903
    if (s->bit_rate_index == 0x1f)
904
        quant_step_table = lossless_quant_d;
905
    else
906
        quant_step_table = lossy_quant_d;
907

    
908
    for (k = 0; k < s->prim_channels; k++) {
909
        for (l = 0; l < s->vq_start_subband[k]; l++) {
910
            int m;
911

    
912
            /* Select the mid-tread linear quantizer */
913
            int abits = s->bitalloc[k][l];
914

    
915
            float quant_step_size = quant_step_table[abits];
916
            float rscale;
917

    
918
            /*
919
             * Determine quantization index code book and its type
920
             */
921

    
922
            /* Select quantization index code book */
923
            int sel = s->quant_index_huffman[k][abits];
924

    
925
            /*
926
             * Extract bits from the bit stream
927
             */
928
            if(!abits){
929
                memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
930
            }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
931
                if(abits <= 7){
932
                    /* Block code */
933
                    int block_code1, block_code2, size, levels;
934
                    int block[8];
935

    
936
                    size = abits_sizes[abits-1];
937
                    levels = abits_levels[abits-1];
938

    
939
                    block_code1 = get_bits(&s->gb, size);
940
                    /* FIXME Should test return value */
941
                    decode_blockcode(block_code1, levels, block);
942
                    block_code2 = get_bits(&s->gb, size);
943
                    decode_blockcode(block_code2, levels, &block[4]);
944
                    for (m = 0; m < 8; m++)
945
                        subband_samples[k][l][m] = block[m];
946
                }else{
947
                    /* no coding */
948
                    for (m = 0; m < 8; m++)
949
                        subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
950
                }
951
            }else{
952
                /* Huffman coded */
953
                for (m = 0; m < 8; m++)
954
                    subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
955
            }
956

    
957
            /* Deal with transients */
958
            if (s->transition_mode[k][l] &&
959
                subsubframe >= s->transition_mode[k][l])
960
                rscale = quant_step_size * s->scale_factor[k][l][1];
961
            else
962
                rscale = quant_step_size * s->scale_factor[k][l][0];
963

    
964
            rscale *= s->scalefactor_adj[k][sel];
965

    
966
            for (m = 0; m < 8; m++)
967
                subband_samples[k][l][m] *= rscale;
968

    
969
            /*
970
             * Inverse ADPCM if in prediction mode
971
             */
972
            if (s->prediction_mode[k][l]) {
973
                int n;
974
                for (m = 0; m < 8; m++) {
975
                    for (n = 1; n <= 4; n++)
976
                        if (m >= n)
977
                            subband_samples[k][l][m] +=
978
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
979
                                 subband_samples[k][l][m - n] / 8192);
980
                        else if (s->predictor_history)
981
                            subband_samples[k][l][m] +=
982
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
983
                                 s->subband_samples_hist[k][l][m - n +
984
                                                               4] / 8192);
985
                }
986
            }
987
        }
988

    
989
        /*
990
         * Decode VQ encoded high frequencies
991
         */
992
        for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
993
            /* 1 vector -> 32 samples but we only need the 8 samples
994
             * for this subsubframe. */
995
            int m;
996

    
997
            if (!s->debug_flag & 0x01) {
998
                av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
999
                s->debug_flag |= 0x01;
1000
            }
1001

    
1002
            for (m = 0; m < 8; m++) {
1003
                subband_samples[k][l][m] =
1004
                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1005
                                                        m]
1006
                    * (float) s->scale_factor[k][l][0] / 16.0;
1007
            }
1008
        }
1009
    }
1010

    
1011
    /* Check for DSYNC after subsubframe */
1012
    if (s->aspf || subsubframe == s->subsubframes - 1) {
1013
        if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1014
#ifdef TRACE
1015
            av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1016
#endif
1017
        } else {
1018
            av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1019
        }
1020
    }
1021

    
1022
    /* Backup predictor history for adpcm */
1023
    for (k = 0; k < s->prim_channels; k++)
1024
        for (l = 0; l < s->vq_start_subband[k]; l++)
1025
            memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1026
                        4 * sizeof(subband_samples[0][0][0]));
1027

    
1028
    /* 32 subbands QMF */
1029
    for (k = 0; k < s->prim_channels; k++) {
1030
/*        static float pcm_to_double[8] =
1031
            {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1032
         qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * k],
1033
                            M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1034
                            s->add_bias );
1035
    }
1036

    
1037
    /* Down mixing */
1038

    
1039
    if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1040
        dca_downmix(s->samples, s->amode, s->downmix_coef);
1041
    }
1042

    
1043
    /* Generate LFE samples for this subsubframe FIXME!!! */
1044
    if (s->output & DCA_LFE) {
1045
        int lfe_samples = 2 * s->lfe * s->subsubframes;
1046
        int i_channels = dca_channels[s->output & DCA_CHANNEL_MASK];
1047

    
1048
        lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1049
                              s->lfe_data + lfe_samples +
1050
                              2 * s->lfe * subsubframe,
1051
                              &s->samples[256 * i_channels],
1052
                              (1.0/256.0)*s->scale_bias,  s->add_bias);
1053
        /* Outputs 20bits pcm samples */
1054
    }
1055

    
1056
    return 0;
1057
}
1058

    
1059

    
1060
static int dca_subframe_footer(DCAContext * s)
1061
{
1062
    int aux_data_count = 0, i;
1063
    int lfe_samples;
1064

    
1065
    /*
1066
     * Unpack optional information
1067
     */
1068

    
1069
    if (s->timestamp)
1070
        get_bits(&s->gb, 32);
1071

    
1072
    if (s->aux_data)
1073
        aux_data_count = get_bits(&s->gb, 6);
1074

    
1075
    for (i = 0; i < aux_data_count; i++)
1076
        get_bits(&s->gb, 8);
1077

    
1078
    if (s->crc_present && (s->downmix || s->dynrange))
1079
        get_bits(&s->gb, 16);
1080

    
1081
    lfe_samples = 2 * s->lfe * s->subsubframes;
1082
    for (i = 0; i < lfe_samples; i++) {
1083
        s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1084
    }
1085

    
1086
    return 0;
1087
}
1088

    
1089
/**
1090
 * Decode a dca frame block
1091
 *
1092
 * @param s     pointer to the DCAContext
1093
 */
1094

    
1095
static int dca_decode_block(DCAContext * s)
1096
{
1097

    
1098
    /* Sanity check */
1099
    if (s->current_subframe >= s->subframes) {
1100
        av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1101
               s->current_subframe, s->subframes);
1102
        return -1;
1103
    }
1104

    
1105
    if (!s->current_subsubframe) {
1106
#ifdef TRACE
1107
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1108
#endif
1109
        /* Read subframe header */
1110
        if (dca_subframe_header(s))
1111
            return -1;
1112
    }
1113

    
1114
    /* Read subsubframe */
1115
#ifdef TRACE
1116
    av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1117
#endif
1118
    if (dca_subsubframe(s))
1119
        return -1;
1120

    
1121
    /* Update state */
1122
    s->current_subsubframe++;
1123
    if (s->current_subsubframe >= s->subsubframes) {
1124
        s->current_subsubframe = 0;
1125
        s->current_subframe++;
1126
    }
1127
    if (s->current_subframe >= s->subframes) {
1128
#ifdef TRACE
1129
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1130
#endif
1131
        /* Read subframe footer */
1132
        if (dca_subframe_footer(s))
1133
            return -1;
1134
    }
1135

    
1136
    return 0;
1137
}
1138

    
1139
/**
1140
 * Convert bitstream to one representation based on sync marker
1141
 */
1142
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1143
                          int max_size)
1144
{
1145
    uint32_t mrk;
1146
    int i, tmp;
1147
    const uint16_t *ssrc = (const uint16_t *) src;
1148
    uint16_t *sdst = (uint16_t *) dst;
1149
    PutBitContext pb;
1150

    
1151
    if((unsigned)src_size > (unsigned)max_size) {
1152
        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1153
        return -1;
1154
    }
1155

    
1156
    mrk = AV_RB32(src);
1157
    switch (mrk) {
1158
    case DCA_MARKER_RAW_BE:
1159
        memcpy(dst, src, src_size);
1160
        return src_size;
1161
    case DCA_MARKER_RAW_LE:
1162
        for (i = 0; i < (src_size + 1) >> 1; i++)
1163
            *sdst++ = bswap_16(*ssrc++);
1164
        return src_size;
1165
    case DCA_MARKER_14B_BE:
1166
    case DCA_MARKER_14B_LE:
1167
        init_put_bits(&pb, dst, max_size);
1168
        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1169
            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1170
            put_bits(&pb, 14, tmp);
1171
        }
1172
        flush_put_bits(&pb);
1173
        return (put_bits_count(&pb) + 7) >> 3;
1174
    default:
1175
        return -1;
1176
    }
1177
}
1178

    
1179
/**
1180
 * Main frame decoding function
1181
 * FIXME add arguments
1182
 */
1183
static int dca_decode_frame(AVCodecContext * avctx,
1184
                            void *data, int *data_size,
1185
                            const uint8_t * buf, int buf_size)
1186
{
1187

    
1188
    int i;
1189
    int16_t *samples = data;
1190
    DCAContext *s = avctx->priv_data;
1191
    int channels;
1192

    
1193

    
1194
    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1195
    if (s->dca_buffer_size == -1) {
1196
        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1197
        return -1;
1198
    }
1199

    
1200
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1201
    if (dca_parse_frame_header(s) < 0) {
1202
        //seems like the frame is corrupt, try with the next one
1203
        *data_size=0;
1204
        return buf_size;
1205
    }
1206
    //set AVCodec values with parsed data
1207
    avctx->sample_rate = s->sample_rate;
1208
    avctx->bit_rate = s->bit_rate;
1209

    
1210
    channels = s->prim_channels + !!s->lfe;
1211
    if(avctx->request_channels == 2 && s->prim_channels > 2) {
1212
        channels = 2;
1213
        s->output = DCA_STEREO;
1214
        avctx->channel_layout = CH_LAYOUT_STEREO;
1215
    }
1216
    if (s->amode<16)
1217
        avctx->channel_layout = dca_core_channel_layout[s->amode];
1218

    
1219
    if (s->lfe) avctx->channel_layout |= CH_LOW_FREQUENCY;
1220

    
1221
    /* There is nothing that prevents a dts frame to change channel configuration
1222
       but FFmpeg doesn't support that so only set the channels if it is previously
1223
       unset. Ideally during the first probe for channels the crc should be checked
1224
       and only set avctx->channels when the crc is ok. Right now the decoder could
1225
       set the channels based on a broken first frame.*/
1226
    if (!avctx->channels)
1227
        avctx->channels = channels;
1228

    
1229
    if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1230
        return -1;
1231
    *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1232
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1233
        dca_decode_block(s);
1234
        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1235
        samples += 256 * channels;
1236
    }
1237

    
1238
    return buf_size;
1239
}
1240

    
1241

    
1242

    
1243
/**
1244
 * DCA initialization
1245
 *
1246
 * @param avctx     pointer to the AVCodecContext
1247
 */
1248

    
1249
static av_cold int dca_decode_init(AVCodecContext * avctx)
1250
{
1251
    DCAContext *s = avctx->priv_data;
1252
    int i;
1253

    
1254
    s->avctx = avctx;
1255
    dca_init_vlcs();
1256

    
1257
    dsputil_init(&s->dsp, avctx);
1258
    ff_mdct_init(&s->imdct, 6, 1);
1259

    
1260
    for(i = 0; i < 6; i++)
1261
        s->samples_chanptr[i] = s->samples + i * 256;
1262
    avctx->sample_fmt = SAMPLE_FMT_S16;
1263

    
1264
    if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1265
        s->add_bias = 385.0f;
1266
        s->scale_bias = 1.0 / 32768.0;
1267
    } else {
1268
        s->add_bias = 0.0f;
1269
        s->scale_bias = 1.0;
1270

    
1271
        /* allow downmixing to stereo */
1272
        if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1273
                avctx->request_channels == 2) {
1274
            avctx->channels = avctx->request_channels;
1275
        }
1276
    }
1277

    
1278

    
1279
    return 0;
1280
}
1281

    
1282
static av_cold int dca_decode_end(AVCodecContext * avctx)
1283
{
1284
    DCAContext *s = avctx->priv_data;
1285
    ff_mdct_end(&s->imdct);
1286
    return 0;
1287
}
1288

    
1289
AVCodec dca_decoder = {
1290
    .name = "dca",
1291
    .type = CODEC_TYPE_AUDIO,
1292
    .id = CODEC_ID_DTS,
1293
    .priv_data_size = sizeof(DCAContext),
1294
    .init = dca_decode_init,
1295
    .decode = dca_decode_frame,
1296
    .close = dca_decode_end,
1297
    .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1298
    .channel_layouts = dca_core_channel_layout,
1299
};