Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ b2755007

History | View | Annotate | Download (48.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 libavcodec/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 "put_bits.h"
37
#include "dcadata.h"
38
#include "dcahuff.h"
39
#include "dca.h"
40

    
41
//#define TRACE
42

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

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

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

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

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

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

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

    
134

    
135
#define DCA_DOLBY 101           /* FIXME */
136

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

    
140
#define DCA_LFE 0x80
141

    
142
#define HEADER_SIZE 14
143

    
144
#define DCA_MAX_FRAME_SIZE 16384
145

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

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

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

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

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

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

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

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

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

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

    
234
    int output;                 ///< type of output
235
    float add_bias;             ///< output bias
236
    float scale_bias;           ///< output scale
237

    
238
    DECLARE_ALIGNED_16(float, samples[1536]);  /* 6 * 256 = 1536, might only need 5 */
239
    const float *samples_chanptr[6];
240

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

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

    
250
    int debug_flag;             ///< used for suppressing repeated error messages output
251
    DSPContext dsp;
252
    MDCTContext imdct;
253
} DCAContext;
254

    
255
static av_cold void dca_init_vlcs(void)
256
{
257
    static int vlcs_initialized = 0;
258
    int i, j;
259

    
260
    if (vlcs_initialized)
261
        return;
262

    
263
    dca_bitalloc_index.offset = 1;
264
    dca_bitalloc_index.wrap = 2;
265
    for (i = 0; i < 5; i++)
266
        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
267
                 bitalloc_12_bits[i], 1, 1,
268
                 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_STATIC);
269
    dca_scalefactor.offset = -64;
270
    dca_scalefactor.wrap = 2;
271
    for (i = 0; i < 5; i++)
272
        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
273
                 scales_bits[i], 1, 1,
274
                 scales_codes[i], 2, 2, INIT_VLC_USE_STATIC);
275
    dca_tmode.offset = 0;
276
    dca_tmode.wrap = 1;
277
    for (i = 0; i < 4; i++)
278
        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
279
                 tmode_bits[i], 1, 1,
280
                 tmode_codes[i], 2, 2, INIT_VLC_USE_STATIC);
281

    
282
    for(i = 0; i < 10; i++)
283
        for(j = 0; j < 7; j++){
284
            if(!bitalloc_codes[i][j]) break;
285
            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
286
            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
287
            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
288
                     bitalloc_sizes[i],
289
                     bitalloc_bits[i][j], 1, 1,
290
                     bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_STATIC);
291
        }
292
    vlcs_initialized = 1;
293
}
294

    
295
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
296
{
297
    while(len--)
298
        *dst++ = get_bits(gb, bits);
299
}
300

    
301
static int dca_parse_frame_header(DCAContext * s)
302
{
303
    int i, j;
304
    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
305
    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
306
    static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
307

    
308
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
309

    
310
    /* Sync code */
311
    get_bits(&s->gb, 32);
312

    
313
    /* Frame header */
314
    s->frame_type        = get_bits(&s->gb, 1);
315
    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
316
    s->crc_present       = get_bits(&s->gb, 1);
317
    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
318
    s->frame_size        = get_bits(&s->gb, 14) + 1;
319
    if (s->frame_size < 95)
320
        return -1;
321
    s->amode             = get_bits(&s->gb, 6);
322
    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
323
    if (!s->sample_rate)
324
        return -1;
325
    s->bit_rate_index    = get_bits(&s->gb, 5);
326
    s->bit_rate          = dca_bit_rates[s->bit_rate_index];
327
    if (!s->bit_rate)
328
        return -1;
329

    
330
    s->downmix           = get_bits(&s->gb, 1);
331
    s->dynrange          = get_bits(&s->gb, 1);
332
    s->timestamp         = get_bits(&s->gb, 1);
333
    s->aux_data          = get_bits(&s->gb, 1);
334
    s->hdcd              = get_bits(&s->gb, 1);
335
    s->ext_descr         = get_bits(&s->gb, 3);
336
    s->ext_coding        = get_bits(&s->gb, 1);
337
    s->aspf              = get_bits(&s->gb, 1);
338
    s->lfe               = get_bits(&s->gb, 2);
339
    s->predictor_history = get_bits(&s->gb, 1);
340

    
341
    /* TODO: check CRC */
342
    if (s->crc_present)
343
        s->header_crc    = get_bits(&s->gb, 16);
344

    
345
    s->multirate_inter   = get_bits(&s->gb, 1);
346
    s->version           = get_bits(&s->gb, 4);
347
    s->copy_history      = get_bits(&s->gb, 2);
348
    s->source_pcm_res    = get_bits(&s->gb, 3);
349
    s->front_sum         = get_bits(&s->gb, 1);
350
    s->surround_sum      = get_bits(&s->gb, 1);
351
    s->dialog_norm       = get_bits(&s->gb, 4);
352

    
353
    /* FIXME: channels mixing levels */
354
    s->output = s->amode;
355
    if(s->lfe) s->output |= DCA_LFE;
356

    
357
#ifdef TRACE
358
    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
359
    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
360
    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
361
    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
362
           s->sample_blocks, s->sample_blocks * 32);
363
    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
364
    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
365
           s->amode, dca_channels[s->amode]);
366
    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
367
           s->sample_rate);
368
    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
369
           s->bit_rate);
370
    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
371
    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
372
    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
373
    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
374
    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
375
    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
376
    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
377
    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
378
    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
379
    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
380
           s->predictor_history);
381
    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
382
    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
383
           s->multirate_inter);
384
    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
385
    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
386
    av_log(s->avctx, AV_LOG_DEBUG,
387
           "source pcm resolution: %i (%i bits/sample)\n",
388
           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
389
    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
390
    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
391
    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
392
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
393
#endif
394

    
395
    /* Primary audio coding header */
396
    s->subframes         = get_bits(&s->gb, 4) + 1;
397
    s->total_channels    = get_bits(&s->gb, 3) + 1;
398
    s->prim_channels     = s->total_channels;
399
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
400
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
401

    
402

    
403
    for (i = 0; i < s->prim_channels; i++) {
404
        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
405
        if (s->subband_activity[i] > DCA_SUBBANDS)
406
            s->subband_activity[i] = DCA_SUBBANDS;
407
    }
408
    for (i = 0; i < s->prim_channels; i++) {
409
        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
410
        if (s->vq_start_subband[i] > DCA_SUBBANDS)
411
            s->vq_start_subband[i] = DCA_SUBBANDS;
412
    }
413
    get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
414
    get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
415
    get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
416
    get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
417

    
418
    /* Get codebooks quantization indexes */
419
    memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
420
    for (j = 1; j < 11; j++)
421
        for (i = 0; i < s->prim_channels; i++)
422
            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
423

    
424
    /* Get scale factor adjustment */
425
    for (j = 0; j < 11; j++)
426
        for (i = 0; i < s->prim_channels; i++)
427
            s->scalefactor_adj[i][j] = 1;
428

    
429
    for (j = 1; j < 11; j++)
430
        for (i = 0; i < s->prim_channels; i++)
431
            if (s->quant_index_huffman[i][j] < thr[j])
432
                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
433

    
434
    if (s->crc_present) {
435
        /* Audio header CRC check */
436
        get_bits(&s->gb, 16);
437
    }
438

    
439
    s->current_subframe = 0;
440
    s->current_subsubframe = 0;
441

    
442
#ifdef TRACE
443
    av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
444
    av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
445
    for(i = 0; i < s->prim_channels; i++){
446
        av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
447
        av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
448
        av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
449
        av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
450
        av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
451
        av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
452
        av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
453
        for (j = 0; j < 11; j++)
454
            av_log(s->avctx, AV_LOG_DEBUG, " %i",
455
                   s->quant_index_huffman[i][j]);
456
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
457
        av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
458
        for (j = 0; j < 11; j++)
459
            av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
460
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
461
    }
462
#endif
463

    
464
    return 0;
465
}
466

    
467

    
468
static inline int get_scale(GetBitContext *gb, int level, int value)
469
{
470
   if (level < 5) {
471
       /* huffman encoded */
472
       value += get_bitalloc(gb, &dca_scalefactor, level);
473
   } else if(level < 8)
474
       value = get_bits(gb, level + 1);
475
   return value;
476
}
477

    
478
static int dca_subframe_header(DCAContext * s)
479
{
480
    /* Primary audio coding side information */
481
    int j, k;
482

    
483
    s->subsubframes = get_bits(&s->gb, 2) + 1;
484
    s->partial_samples = get_bits(&s->gb, 3);
485
    for (j = 0; j < s->prim_channels; j++) {
486
        for (k = 0; k < s->subband_activity[j]; k++)
487
            s->prediction_mode[j][k] = get_bits(&s->gb, 1);
488
    }
489

    
490
    /* Get prediction codebook */
491
    for (j = 0; j < s->prim_channels; j++) {
492
        for (k = 0; k < s->subband_activity[j]; k++) {
493
            if (s->prediction_mode[j][k] > 0) {
494
                /* (Prediction coefficient VQ address) */
495
                s->prediction_vq[j][k] = get_bits(&s->gb, 12);
496
            }
497
        }
498
    }
499

    
500
    /* Bit allocation index */
501
    for (j = 0; j < s->prim_channels; j++) {
502
        for (k = 0; k < s->vq_start_subband[j]; k++) {
503
            if (s->bitalloc_huffman[j] == 6)
504
                s->bitalloc[j][k] = get_bits(&s->gb, 5);
505
            else if (s->bitalloc_huffman[j] == 5)
506
                s->bitalloc[j][k] = get_bits(&s->gb, 4);
507
            else if (s->bitalloc_huffman[j] == 7) {
508
                av_log(s->avctx, AV_LOG_ERROR,
509
                       "Invalid bit allocation index\n");
510
                return -1;
511
            } else {
512
                s->bitalloc[j][k] =
513
                    get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
514
            }
515

    
516
            if (s->bitalloc[j][k] > 26) {
517
//                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
518
//                          j, k, s->bitalloc[j][k]);
519
                return -1;
520
            }
521
        }
522
    }
523

    
524
    /* Transition mode */
525
    for (j = 0; j < s->prim_channels; j++) {
526
        for (k = 0; k < s->subband_activity[j]; k++) {
527
            s->transition_mode[j][k] = 0;
528
            if (s->subsubframes > 1 &&
529
                k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
530
                s->transition_mode[j][k] =
531
                    get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
532
            }
533
        }
534
    }
535

    
536
    for (j = 0; j < s->prim_channels; j++) {
537
        const uint32_t *scale_table;
538
        int scale_sum;
539

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

    
542
        if (s->scalefactor_huffman[j] == 6)
543
            scale_table = scale_factor_quant7;
544
        else
545
            scale_table = scale_factor_quant6;
546

    
547
        /* When huffman coded, only the difference is encoded */
548
        scale_sum = 0;
549

    
550
        for (k = 0; k < s->subband_activity[j]; k++) {
551
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
552
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
553
                s->scale_factor[j][k][0] = scale_table[scale_sum];
554
            }
555

    
556
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
557
                /* Get second scale factor */
558
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
559
                s->scale_factor[j][k][1] = scale_table[scale_sum];
560
            }
561
        }
562
    }
563

    
564
    /* Joint subband scale factor codebook select */
565
    for (j = 0; j < s->prim_channels; j++) {
566
        /* Transmitted only if joint subband coding enabled */
567
        if (s->joint_intensity[j] > 0)
568
            s->joint_huff[j] = get_bits(&s->gb, 3);
569
    }
570

    
571
    /* Scale factors for joint subband coding */
572
    for (j = 0; j < s->prim_channels; j++) {
573
        int source_channel;
574

    
575
        /* Transmitted only if joint subband coding enabled */
576
        if (s->joint_intensity[j] > 0) {
577
            int scale = 0;
578
            source_channel = s->joint_intensity[j] - 1;
579

    
580
            /* When huffman coded, only the difference is encoded
581
             * (is this valid as well for joint scales ???) */
582

    
583
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
584
                scale = get_scale(&s->gb, s->joint_huff[j], 0);
585
                scale += 64;    /* bias */
586
                s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
587
            }
588

    
589
            if (!s->debug_flag & 0x02) {
590
                av_log(s->avctx, AV_LOG_DEBUG,
591
                       "Joint stereo coding not supported\n");
592
                s->debug_flag |= 0x02;
593
            }
594
        }
595
    }
596

    
597
    /* Stereo downmix coefficients */
598
    if (s->prim_channels > 2) {
599
        if(s->downmix) {
600
            for (j = 0; j < s->prim_channels; j++) {
601
                s->downmix_coef[j][0] = get_bits(&s->gb, 7);
602
                s->downmix_coef[j][1] = get_bits(&s->gb, 7);
603
            }
604
        } else {
605
            int am = s->amode & DCA_CHANNEL_MASK;
606
            for (j = 0; j < s->prim_channels; j++) {
607
                s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
608
                s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
609
            }
610
        }
611
    }
612

    
613
    /* Dynamic range coefficient */
614
    if (s->dynrange)
615
        s->dynrange_coef = get_bits(&s->gb, 8);
616

    
617
    /* Side information CRC check word */
618
    if (s->crc_present) {
619
        get_bits(&s->gb, 16);
620
    }
621

    
622
    /*
623
     * Primary audio data arrays
624
     */
625

    
626
    /* VQ encoded high frequency subbands */
627
    for (j = 0; j < s->prim_channels; j++)
628
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
629
            /* 1 vector -> 32 samples */
630
            s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
631

    
632
    /* Low frequency effect data */
633
    if (s->lfe) {
634
        /* LFE samples */
635
        int lfe_samples = 2 * s->lfe * s->subsubframes;
636
        float lfe_scale;
637

    
638
        for (j = lfe_samples; j < lfe_samples * 2; j++) {
639
            /* Signed 8 bits int */
640
            s->lfe_data[j] = get_sbits(&s->gb, 8);
641
        }
642

    
643
        /* Scale factor index */
644
        s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
645

    
646
        /* Quantization step size * scale factor */
647
        lfe_scale = 0.035 * s->lfe_scale_factor;
648

    
649
        for (j = lfe_samples; j < lfe_samples * 2; j++)
650
            s->lfe_data[j] *= lfe_scale;
651
    }
652

    
653
#ifdef TRACE
654
    av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
655
    av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
656
           s->partial_samples);
657
    for (j = 0; j < s->prim_channels; j++) {
658
        av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
659
        for (k = 0; k < s->subband_activity[j]; k++)
660
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
661
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
662
    }
663
    for (j = 0; j < s->prim_channels; j++) {
664
        for (k = 0; k < s->subband_activity[j]; k++)
665
                av_log(s->avctx, AV_LOG_DEBUG,
666
                       "prediction coefs: %f, %f, %f, %f\n",
667
                       (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
668
                       (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
669
                       (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
670
                       (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
671
    }
672
    for (j = 0; j < s->prim_channels; j++) {
673
        av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
674
        for (k = 0; k < s->vq_start_subband[j]; k++)
675
            av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
676
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
677
    }
678
    for (j = 0; j < s->prim_channels; j++) {
679
        av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
680
        for (k = 0; k < s->subband_activity[j]; k++)
681
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
682
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
683
    }
684
    for (j = 0; j < s->prim_channels; j++) {
685
        av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
686
        for (k = 0; k < s->subband_activity[j]; k++) {
687
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
688
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
689
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
690
                av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
691
        }
692
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
693
    }
694
    for (j = 0; j < s->prim_channels; j++) {
695
        if (s->joint_intensity[j] > 0) {
696
            int source_channel = s->joint_intensity[j] - 1;
697
            av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
698
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
699
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
700
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
701
        }
702
    }
703
    if (s->prim_channels > 2 && s->downmix) {
704
        av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
705
        for (j = 0; j < s->prim_channels; j++) {
706
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
707
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
708
        }
709
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
710
    }
711
    for (j = 0; j < s->prim_channels; j++)
712
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
713
            av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
714
    if(s->lfe){
715
        int lfe_samples = 2 * s->lfe * s->subsubframes;
716
        av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
717
        for (j = lfe_samples; j < lfe_samples * 2; j++)
718
            av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
719
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
720
    }
721
#endif
722

    
723
    return 0;
724
}
725

    
726
static void qmf_32_subbands(DCAContext * s, int chans,
727
                            float samples_in[32][8], float *samples_out,
728
                            float scale, float bias)
729
{
730
    const float *prCoeff;
731
    int i, j;
732
    DECLARE_ALIGNED_16(float, raXin[32]);
733

    
734
    int hist_index= s->hist_index[chans];
735
    float *subband_fir_hist2 = s->subband_fir_noidea[chans];
736

    
737
    int subindex;
738

    
739
    scale *= sqrt(1/8.0);
740

    
741
    /* Select filter */
742
    if (!s->multirate_inter)    /* Non-perfect reconstruction */
743
        prCoeff = fir_32bands_nonperfect;
744
    else                        /* Perfect reconstruction */
745
        prCoeff = fir_32bands_perfect;
746

    
747
    /* Reconstructed channel sample index */
748
    for (subindex = 0; subindex < 8; subindex++) {
749
        float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
750
        /* Load in one sample from each subband and clear inactive subbands */
751
        for (i = 0; i < s->subband_activity[chans]; i++){
752
            if((i-1)&2) raXin[i] = -samples_in[i][subindex];
753
            else        raXin[i] =  samples_in[i][subindex];
754
        }
755
        for (; i < 32; i++)
756
            raXin[i] = 0.0;
757

    
758
        ff_imdct_half(&s->imdct, subband_fir_hist, raXin);
759

    
760
        /* Multiply by filter coefficients */
761
        for (i = 0; i < 16; i++){
762
            float a= subband_fir_hist2[i   ];
763
            float b= subband_fir_hist2[i+16];
764
            float c= 0;
765
            float d= 0;
766
            for (j = 0; j < 512-hist_index; j += 64){
767
                a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j]);
768
                b += prCoeff[i+j+16]*( subband_fir_hist[   i+j]);
769
                c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
770
                d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
771
            }
772
            for (     ; j < 512; j += 64){
773
                a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j-512]);
774
                b += prCoeff[i+j+16]*( subband_fir_hist[   i+j-512]);
775
                c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
776
                d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
777
            }
778
            samples_out[i   ] = a * scale + bias;
779
            samples_out[i+16] = b * scale + bias;
780
            subband_fir_hist2[i   ] = c;
781
            subband_fir_hist2[i+16] = d;
782
        }
783
        samples_out+= 32;
784

    
785
        hist_index = (hist_index-32)&511;
786
    }
787
    s->hist_index[chans]= hist_index;
788
}
789

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

    
803
    int decifactor, k, j;
804
    const float *prCoeff;
805

    
806
    int interp_index = 0;       /* Index to the interpolated samples */
807
    int deciindex;
808

    
809
    /* Select decimation filter */
810
    if (decimation_select == 1) {
811
        decifactor = 128;
812
        prCoeff = lfe_fir_128;
813
    } else {
814
        decifactor = 64;
815
        prCoeff = lfe_fir_64;
816
    }
817
    /* Interpolation */
818
    for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
819
        /* One decimated sample generates decifactor interpolated ones */
820
        for (k = 0; k < decifactor; k++) {
821
            float rTmp = 0.0;
822
            //FIXME the coeffs are symetric, fix that
823
            for (j = 0; j < 512 / decifactor; j++)
824
                rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
825
            samples_out[interp_index++] = (rTmp * scale) + bias;
826
        }
827
    }
828
}
829

    
830
/* downmixing routines */
831
#define MIX_REAR1(samples, si1, rs, coef) \
832
     samples[i]     += samples[si1] * coef[rs][0]; \
833
     samples[i+256] += samples[si1] * coef[rs][1];
834

    
835
#define MIX_REAR2(samples, si1, si2, rs, coef) \
836
     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
837
     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
838

    
839
#define MIX_FRONT3(samples, coef) \
840
    t = samples[i]; \
841
    samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
842
    samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
843

    
844
#define DOWNMIX_TO_STEREO(op1, op2) \
845
    for(i = 0; i < 256; i++){ \
846
        op1 \
847
        op2 \
848
    }
849

    
850
static void dca_downmix(float *samples, int srcfmt,
851
                        int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
852
{
853
    int i;
854
    float t;
855
    float coef[DCA_PRIM_CHANNELS_MAX][2];
856

    
857
    for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
858
        coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
859
        coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
860
    }
861

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

    
892

    
893
/* Very compact version of the block code decoder that does not use table
894
 * look-up but is slightly slower */
895
static int decode_blockcode(int code, int levels, int *values)
896
{
897
    int i;
898
    int offset = (levels - 1) >> 1;
899

    
900
    for (i = 0; i < 4; i++) {
901
        values[i] = (code % levels) - offset;
902
        code /= levels;
903
    }
904

    
905
    if (code == 0)
906
        return 0;
907
    else {
908
        av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
909
        return -1;
910
    }
911
}
912

    
913
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
914
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
915

    
916
static int dca_subsubframe(DCAContext * s)
917
{
918
    int k, l;
919
    int subsubframe = s->current_subsubframe;
920

    
921
    const float *quant_step_table;
922

    
923
    /* FIXME */
924
    float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
925

    
926
    /*
927
     * Audio data
928
     */
929

    
930
    /* Select quantization step size table */
931
    if (s->bit_rate_index == 0x1f)
932
        quant_step_table = lossless_quant_d;
933
    else
934
        quant_step_table = lossy_quant_d;
935

    
936
    for (k = 0; k < s->prim_channels; k++) {
937
        for (l = 0; l < s->vq_start_subband[k]; l++) {
938
            int m;
939

    
940
            /* Select the mid-tread linear quantizer */
941
            int abits = s->bitalloc[k][l];
942

    
943
            float quant_step_size = quant_step_table[abits];
944
            float rscale;
945

    
946
            /*
947
             * Determine quantization index code book and its type
948
             */
949

    
950
            /* Select quantization index code book */
951
            int sel = s->quant_index_huffman[k][abits];
952

    
953
            /*
954
             * Extract bits from the bit stream
955
             */
956
            if(!abits){
957
                memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
958
            }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
959
                if(abits <= 7){
960
                    /* Block code */
961
                    int block_code1, block_code2, size, levels;
962
                    int block[8];
963

    
964
                    size = abits_sizes[abits-1];
965
                    levels = abits_levels[abits-1];
966

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

    
985
            /* Deal with transients */
986
            if (s->transition_mode[k][l] &&
987
                subsubframe >= s->transition_mode[k][l])
988
                rscale = quant_step_size * s->scale_factor[k][l][1];
989
            else
990
                rscale = quant_step_size * s->scale_factor[k][l][0];
991

    
992
            rscale *= s->scalefactor_adj[k][sel];
993

    
994
            for (m = 0; m < 8; m++)
995
                subband_samples[k][l][m] *= rscale;
996

    
997
            /*
998
             * Inverse ADPCM if in prediction mode
999
             */
1000
            if (s->prediction_mode[k][l]) {
1001
                int n;
1002
                for (m = 0; m < 8; m++) {
1003
                    for (n = 1; n <= 4; n++)
1004
                        if (m >= n)
1005
                            subband_samples[k][l][m] +=
1006
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1007
                                 subband_samples[k][l][m - n] / 8192);
1008
                        else if (s->predictor_history)
1009
                            subband_samples[k][l][m] +=
1010
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1011
                                 s->subband_samples_hist[k][l][m - n +
1012
                                                               4] / 8192);
1013
                }
1014
            }
1015
        }
1016

    
1017
        /*
1018
         * Decode VQ encoded high frequencies
1019
         */
1020
        for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1021
            /* 1 vector -> 32 samples but we only need the 8 samples
1022
             * for this subsubframe. */
1023
            int m;
1024

    
1025
            if (!s->debug_flag & 0x01) {
1026
                av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1027
                s->debug_flag |= 0x01;
1028
            }
1029

    
1030
            for (m = 0; m < 8; m++) {
1031
                subband_samples[k][l][m] =
1032
                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1033
                                                        m]
1034
                    * (float) s->scale_factor[k][l][0] / 16.0;
1035
            }
1036
        }
1037
    }
1038

    
1039
    /* Check for DSYNC after subsubframe */
1040
    if (s->aspf || subsubframe == s->subsubframes - 1) {
1041
        if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1042
#ifdef TRACE
1043
            av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1044
#endif
1045
        } else {
1046
            av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1047
        }
1048
    }
1049

    
1050
    /* Backup predictor history for adpcm */
1051
    for (k = 0; k < s->prim_channels; k++)
1052
        for (l = 0; l < s->vq_start_subband[k]; l++)
1053
            memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1054
                        4 * sizeof(subband_samples[0][0][0]));
1055

    
1056
    /* 32 subbands QMF */
1057
    for (k = 0; k < s->prim_channels; k++) {
1058
/*        static float pcm_to_double[8] =
1059
            {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1060
         qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1061
                            M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1062
                            s->add_bias );
1063
    }
1064

    
1065
    /* Down mixing */
1066

    
1067
    if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1068
        dca_downmix(s->samples, s->amode, s->downmix_coef);
1069
    }
1070

    
1071
    /* Generate LFE samples for this subsubframe FIXME!!! */
1072
    if (s->output & DCA_LFE) {
1073
        int lfe_samples = 2 * s->lfe * s->subsubframes;
1074

    
1075
        lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1076
                              s->lfe_data + lfe_samples +
1077
                              2 * s->lfe * subsubframe,
1078
                              &s->samples[256 * dca_lfe_index[s->amode]],
1079
                              (1.0/256.0)*s->scale_bias,  s->add_bias);
1080
        /* Outputs 20bits pcm samples */
1081
    }
1082

    
1083
    return 0;
1084
}
1085

    
1086

    
1087
static int dca_subframe_footer(DCAContext * s)
1088
{
1089
    int aux_data_count = 0, i;
1090
    int lfe_samples;
1091

    
1092
    /*
1093
     * Unpack optional information
1094
     */
1095

    
1096
    if (s->timestamp)
1097
        get_bits(&s->gb, 32);
1098

    
1099
    if (s->aux_data)
1100
        aux_data_count = get_bits(&s->gb, 6);
1101

    
1102
    for (i = 0; i < aux_data_count; i++)
1103
        get_bits(&s->gb, 8);
1104

    
1105
    if (s->crc_present && (s->downmix || s->dynrange))
1106
        get_bits(&s->gb, 16);
1107

    
1108
    lfe_samples = 2 * s->lfe * s->subsubframes;
1109
    for (i = 0; i < lfe_samples; i++) {
1110
        s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1111
    }
1112

    
1113
    return 0;
1114
}
1115

    
1116
/**
1117
 * Decode a dca frame block
1118
 *
1119
 * @param s     pointer to the DCAContext
1120
 */
1121

    
1122
static int dca_decode_block(DCAContext * s)
1123
{
1124

    
1125
    /* Sanity check */
1126
    if (s->current_subframe >= s->subframes) {
1127
        av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1128
               s->current_subframe, s->subframes);
1129
        return -1;
1130
    }
1131

    
1132
    if (!s->current_subsubframe) {
1133
#ifdef TRACE
1134
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1135
#endif
1136
        /* Read subframe header */
1137
        if (dca_subframe_header(s))
1138
            return -1;
1139
    }
1140

    
1141
    /* Read subsubframe */
1142
#ifdef TRACE
1143
    av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1144
#endif
1145
    if (dca_subsubframe(s))
1146
        return -1;
1147

    
1148
    /* Update state */
1149
    s->current_subsubframe++;
1150
    if (s->current_subsubframe >= s->subsubframes) {
1151
        s->current_subsubframe = 0;
1152
        s->current_subframe++;
1153
    }
1154
    if (s->current_subframe >= s->subframes) {
1155
#ifdef TRACE
1156
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1157
#endif
1158
        /* Read subframe footer */
1159
        if (dca_subframe_footer(s))
1160
            return -1;
1161
    }
1162

    
1163
    return 0;
1164
}
1165

    
1166
/**
1167
 * Convert bitstream to one representation based on sync marker
1168
 */
1169
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1170
                          int max_size)
1171
{
1172
    uint32_t mrk;
1173
    int i, tmp;
1174
    const uint16_t *ssrc = (const uint16_t *) src;
1175
    uint16_t *sdst = (uint16_t *) dst;
1176
    PutBitContext pb;
1177

    
1178
    if((unsigned)src_size > (unsigned)max_size) {
1179
//        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1180
//        return -1;
1181
        src_size = max_size;
1182
    }
1183

    
1184
    mrk = AV_RB32(src);
1185
    switch (mrk) {
1186
    case DCA_MARKER_RAW_BE:
1187
        memcpy(dst, src, src_size);
1188
        return src_size;
1189
    case DCA_MARKER_RAW_LE:
1190
        for (i = 0; i < (src_size + 1) >> 1; i++)
1191
            *sdst++ = bswap_16(*ssrc++);
1192
        return src_size;
1193
    case DCA_MARKER_14B_BE:
1194
    case DCA_MARKER_14B_LE:
1195
        init_put_bits(&pb, dst, max_size);
1196
        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1197
            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1198
            put_bits(&pb, 14, tmp);
1199
        }
1200
        flush_put_bits(&pb);
1201
        return (put_bits_count(&pb) + 7) >> 3;
1202
    default:
1203
        return -1;
1204
    }
1205
}
1206

    
1207
/**
1208
 * Main frame decoding function
1209
 * FIXME add arguments
1210
 */
1211
static int dca_decode_frame(AVCodecContext * avctx,
1212
                            void *data, int *data_size,
1213
                            AVPacket *avpkt)
1214
{
1215
    const uint8_t *buf = avpkt->data;
1216
    int buf_size = avpkt->size;
1217

    
1218
    int i;
1219
    int16_t *samples = data;
1220
    DCAContext *s = avctx->priv_data;
1221
    int channels;
1222

    
1223

    
1224
    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1225
    if (s->dca_buffer_size == -1) {
1226
        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1227
        return -1;
1228
    }
1229

    
1230
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1231
    if (dca_parse_frame_header(s) < 0) {
1232
        //seems like the frame is corrupt, try with the next one
1233
        *data_size=0;
1234
        return buf_size;
1235
    }
1236
    //set AVCodec values with parsed data
1237
    avctx->sample_rate = s->sample_rate;
1238
    avctx->bit_rate = s->bit_rate;
1239

    
1240
    channels = s->prim_channels + !!s->lfe;
1241

    
1242
    if (s->amode<16) {
1243
        avctx->channel_layout = dca_core_channel_layout[s->amode];
1244

    
1245
        if (s->lfe) {
1246
            avctx->channel_layout |= CH_LOW_FREQUENCY;
1247
            s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1248
        } else
1249
            s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1250

    
1251
        if(avctx->request_channels == 2 && s->prim_channels > 2) {
1252
            channels = 2;
1253
            s->output = DCA_STEREO;
1254
            avctx->channel_layout = CH_LAYOUT_STEREO;
1255
        }
1256
    } else {
1257
        av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1258
        return -1;
1259
    }
1260

    
1261

    
1262
    /* There is nothing that prevents a dts frame to change channel configuration
1263
       but FFmpeg doesn't support that so only set the channels if it is previously
1264
       unset. Ideally during the first probe for channels the crc should be checked
1265
       and only set avctx->channels when the crc is ok. Right now the decoder could
1266
       set the channels based on a broken first frame.*/
1267
    if (!avctx->channels)
1268
        avctx->channels = channels;
1269

    
1270
    if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1271
        return -1;
1272
    *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1273
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1274
        dca_decode_block(s);
1275
        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1276
        samples += 256 * channels;
1277
    }
1278

    
1279
    return buf_size;
1280
}
1281

    
1282

    
1283

    
1284
/**
1285
 * DCA initialization
1286
 *
1287
 * @param avctx     pointer to the AVCodecContext
1288
 */
1289

    
1290
static av_cold int dca_decode_init(AVCodecContext * avctx)
1291
{
1292
    DCAContext *s = avctx->priv_data;
1293
    int i;
1294

    
1295
    s->avctx = avctx;
1296
    dca_init_vlcs();
1297

    
1298
    dsputil_init(&s->dsp, avctx);
1299
    ff_mdct_init(&s->imdct, 6, 1);
1300

    
1301
    for(i = 0; i < 6; i++)
1302
        s->samples_chanptr[i] = s->samples + i * 256;
1303
    avctx->sample_fmt = SAMPLE_FMT_S16;
1304

    
1305
    if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1306
        s->add_bias = 385.0f;
1307
        s->scale_bias = 1.0 / 32768.0;
1308
    } else {
1309
        s->add_bias = 0.0f;
1310
        s->scale_bias = 1.0;
1311

    
1312
        /* allow downmixing to stereo */
1313
        if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1314
                avctx->request_channels == 2) {
1315
            avctx->channels = avctx->request_channels;
1316
        }
1317
    }
1318

    
1319

    
1320
    return 0;
1321
}
1322

    
1323
static av_cold int dca_decode_end(AVCodecContext * avctx)
1324
{
1325
    DCAContext *s = avctx->priv_data;
1326
    ff_mdct_end(&s->imdct);
1327
    return 0;
1328
}
1329

    
1330
AVCodec dca_decoder = {
1331
    .name = "dca",
1332
    .type = CODEC_TYPE_AUDIO,
1333
    .id = CODEC_ID_DTS,
1334
    .priv_data_size = sizeof(DCAContext),
1335
    .init = dca_decode_init,
1336
    .decode = dca_decode_frame,
1337
    .close = dca_decode_end,
1338
    .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1339
};