Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dca.c @ f2401c21

History | View | Annotate | Download (55 KB)

1
/*
2
 * DCA compatible decoder
3
 * Copyright (C) 2004 Gildas Bazin
4
 * Copyright (C) 2004 Benjamin Zores
5
 * Copyright (C) 2006 Benjamin Larsson
6
 * Copyright (C) 2007 Konstantin Shishkov
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24

    
25
#include <math.h>
26
#include <stddef.h>
27
#include <stdio.h>
28

    
29
#include "libavutil/intmath.h"
30
#include "libavutil/intreadwrite.h"
31
#include "avcodec.h"
32
#include "dsputil.h"
33
#include "fft.h"
34
#include "get_bits.h"
35
#include "put_bits.h"
36
#include "dcadata.h"
37
#include "dcahuff.h"
38
#include "dca.h"
39
#include "synth_filter.h"
40
#include "dcadsp.h"
41

    
42
//#define TRACE
43

    
44
#define DCA_PRIM_CHANNELS_MAX (7)
45
#define DCA_SUBBANDS (32)
46
#define DCA_ABITS_MAX (32)      /* Should be 28 */
47
#define DCA_SUBSUBFRAMES_MAX (4)
48
#define DCA_SUBFRAMES_MAX (16)
49
#define DCA_BLOCKS_MAX (16)
50
#define DCA_LFE_MAX (3)
51

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

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

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

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

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

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

    
137
static const int8_t dca_channel_reorder_nolfe[][9] = {
138
    { 0, -1, -1, -1, -1, -1, -1, -1, -1},
139
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
140
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
141
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
142
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
143
    { 2,  0,  1, -1, -1, -1, -1, -1, -1},
144
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
145
    { 2,  0,  1,  3, -1, -1, -1, -1, -1},
146
    { 0,  1,  2,  3, -1, -1, -1, -1, -1},
147
    { 2,  0,  1,  3,  4, -1, -1, -1, -1},
148
    { 2,  3,  0,  1,  4,  5, -1, -1, -1},
149
    { 2,  0,  1,  3,  4,  5, -1, -1, -1},
150
    { 0,  5,  3,  4,  1,  2, -1, -1, -1},
151
    { 3,  2,  4,  0,  1,  5,  6, -1, -1},
152
    { 4,  5,  0,  1,  6,  2,  7,  3, -1},
153
    { 3,  2,  4,  0,  1,  5,  7,  6, -1},
154
};
155

    
156
static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
157
    { 0,  1, -1, -1, -1, -1, -1, -1, -1},
158
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
159
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
160
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
161
    { 0,  1,  2, -1, -1, -1, -1, -1, -1},
162
    { 2,  0,  1,  3, -1, -1, -1, -1, -1},
163
    { 0,  1,  2,  3, -1, -1, -1, -1, -1},
164
    { 2,  0,  1,  3,  4, -1, -1, -1, -1},
165
    { 0,  1,  3,  4,  2, -1, -1, -1, -1},
166
    { 2,  0,  1,  4,  5,  3, -1, -1, -1},
167
    { 2,  3,  0,  1,  5,  6,  4, -1, -1},
168
    { 2,  0,  1,  3,  4,  5,  6, -1, -1},
169
    { 0,  5,  3,  4,  1,  2,  6, -1, -1},
170
    { 3,  2,  4,  0,  1,  6,  7,  5, -1},
171
    { 4,  5,  0,  1,  7,  2,  8,  3,  6},
172
    { 3,  2,  4,  0,  1,  5,  8,  7,  6},
173
};
174

    
175
#define DCA_DOLBY 101           /* FIXME */
176

    
177
#define DCA_CHANNEL_BITS 6
178
#define DCA_CHANNEL_MASK 0x3F
179

    
180
#define DCA_LFE 0x80
181

    
182
#define HEADER_SIZE 14
183

    
184
#define DCA_MAX_FRAME_SIZE 16384
185

    
186
/** Bit allocation */
187
typedef struct {
188
    int offset;                 ///< code values offset
189
    int maxbits[8];             ///< max bits in VLC
190
    int wrap;                   ///< wrap for get_vlc2()
191
    VLC vlc[8];                 ///< actual codes
192
} BitAlloc;
193

    
194
static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
195
static BitAlloc dca_tmode;             ///< transition mode VLCs
196
static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
197
static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
198

    
199
static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
200
{
201
    return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
202
}
203

    
204
typedef struct {
205
    AVCodecContext *avctx;
206
    /* Frame header */
207
    int frame_type;             ///< type of the current frame
208
    int samples_deficit;        ///< deficit sample count
209
    int crc_present;            ///< crc is present in the bitstream
210
    int sample_blocks;          ///< number of PCM sample blocks
211
    int frame_size;             ///< primary frame byte size
212
    int amode;                  ///< audio channels arrangement
213
    int sample_rate;            ///< audio sampling rate
214
    int bit_rate;               ///< transmission bit rate
215
    int bit_rate_index;         ///< transmission bit rate index
216

    
217
    int downmix;                ///< embedded downmix enabled
218
    int dynrange;               ///< embedded dynamic range flag
219
    int timestamp;              ///< embedded time stamp flag
220
    int aux_data;               ///< auxiliary data flag
221
    int hdcd;                   ///< source material is mastered in HDCD
222
    int ext_descr;              ///< extension audio descriptor flag
223
    int ext_coding;             ///< extended coding flag
224
    int aspf;                   ///< audio sync word insertion flag
225
    int lfe;                    ///< low frequency effects flag
226
    int predictor_history;      ///< predictor history flag
227
    int header_crc;             ///< header crc check bytes
228
    int multirate_inter;        ///< multirate interpolator switch
229
    int version;                ///< encoder software revision
230
    int copy_history;           ///< copy history
231
    int source_pcm_res;         ///< source pcm resolution
232
    int front_sum;              ///< front sum/difference flag
233
    int surround_sum;           ///< surround sum/difference flag
234
    int dialog_norm;            ///< dialog normalisation parameter
235

    
236
    /* Primary audio coding header */
237
    int subframes;              ///< number of subframes
238
    int total_channels;         ///< number of channels including extensions
239
    int prim_channels;          ///< number of primary audio channels
240
    int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
241
    int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
242
    int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
243
    int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
244
    int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
245
    int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
246
    int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
247
    float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
248

    
249
    /* Primary audio coding side information */
250
    int subsubframes[DCA_SUBFRAMES_MAX];           ///< number of subsubframes
251
    int partial_samples[DCA_SUBFRAMES_MAX];        ///< partial subsubframe samples count
252
    int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
253
    int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
254
    int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
255
    int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
256
    int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
257
    int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
258
    int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
259
    int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
260
    int dynrange_coef;                                           ///< dynamic range coefficient
261

    
262
    int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
263

    
264
    float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data
265
    int lfe_scale_factor;
266

    
267
    /* Subband samples history (for ADPCM) */
268
    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
269
    DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
270
    DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
271
    int hist_index[DCA_PRIM_CHANNELS_MAX];
272
    DECLARE_ALIGNED(16, float, raXin)[32];
273

    
274
    int output;                 ///< type of output
275
    float add_bias;             ///< output bias
276
    float scale_bias;           ///< output scale
277

    
278
    DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
279
    DECLARE_ALIGNED(16, float, samples)[(DCA_PRIM_CHANNELS_MAX+1)*256];
280
    const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX+1];
281

    
282
    uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
283
    int dca_buffer_size;        ///< how much data is in the dca_buffer
284

    
285
    const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
286
    GetBitContext gb;
287
    /* Current position in DCA frame */
288
    int current_subframe;
289
    int current_subsubframe;
290

    
291
    /* XCh extension information */
292
    int xch_present;
293
    int xch_base_channel;       ///< index of first (only) channel containing XCH data
294

    
295
    int debug_flag;             ///< used for suppressing repeated error messages output
296
    DSPContext dsp;
297
    FFTContext imdct;
298
    SynthFilterContext synth;
299
    DCADSPContext dcadsp;
300
} DCAContext;
301

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

    
311
static av_cold void dca_init_vlcs(void)
312
{
313
    static int vlcs_initialized = 0;
314
    int i, j, c = 14;
315
    static VLC_TYPE dca_table[23622][2];
316

    
317
    if (vlcs_initialized)
318
        return;
319

    
320
    dca_bitalloc_index.offset = 1;
321
    dca_bitalloc_index.wrap = 2;
322
    for (i = 0; i < 5; i++) {
323
        dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
324
        dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
325
        init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
326
                 bitalloc_12_bits[i], 1, 1,
327
                 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
328
    }
329
    dca_scalefactor.offset = -64;
330
    dca_scalefactor.wrap = 2;
331
    for (i = 0; i < 5; i++) {
332
        dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
333
        dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
334
        init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
335
                 scales_bits[i], 1, 1,
336
                 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
337
    }
338
    dca_tmode.offset = 0;
339
    dca_tmode.wrap = 1;
340
    for (i = 0; i < 4; i++) {
341
        dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
342
        dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
343
        init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
344
                 tmode_bits[i], 1, 1,
345
                 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
346
    }
347

    
348
    for (i = 0; i < 10; i++)
349
        for (j = 0; j < 7; j++){
350
            if (!bitalloc_codes[i][j]) break;
351
            dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
352
            dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
353
            dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
354
            dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
355
            init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
356
                     bitalloc_sizes[i],
357
                     bitalloc_bits[i][j], 1, 1,
358
                     bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
359
            c++;
360
        }
361
    vlcs_initialized = 1;
362
}
363

    
364
static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
365
{
366
    while(len--)
367
        *dst++ = get_bits(gb, bits);
368
}
369

    
370
static int dca_parse_audio_coding_header(DCAContext * s, int base_channel)
371
{
372
    int i, j;
373
    static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
374
    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
375
    static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
376

    
377
    s->total_channels    = get_bits(&s->gb, 3) + 1 + base_channel;
378
    s->prim_channels     = s->total_channels;
379

    
380
    if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
381
        s->prim_channels = DCA_PRIM_CHANNELS_MAX;
382

    
383

    
384
    for (i = base_channel; i < s->prim_channels; i++) {
385
        s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
386
        if (s->subband_activity[i] > DCA_SUBBANDS)
387
            s->subband_activity[i] = DCA_SUBBANDS;
388
    }
389
    for (i = base_channel; i < s->prim_channels; i++) {
390
        s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
391
        if (s->vq_start_subband[i] > DCA_SUBBANDS)
392
            s->vq_start_subband[i] = DCA_SUBBANDS;
393
    }
394
    get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
395
    get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
396
    get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
397
    get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
398

    
399
    /* Get codebooks quantization indexes */
400
    if (!base_channel)
401
        memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
402
    for (j = 1; j < 11; j++)
403
        for (i = base_channel; i < s->prim_channels; i++)
404
            s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
405

    
406
    /* Get scale factor adjustment */
407
    for (j = 0; j < 11; j++)
408
        for (i = base_channel; i < s->prim_channels; i++)
409
            s->scalefactor_adj[i][j] = 1;
410

    
411
    for (j = 1; j < 11; j++)
412
        for (i = base_channel; i < s->prim_channels; i++)
413
            if (s->quant_index_huffman[i][j] < thr[j])
414
                s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
415

    
416
    if (s->crc_present) {
417
        /* Audio header CRC check */
418
        get_bits(&s->gb, 16);
419
    }
420

    
421
    s->current_subframe = 0;
422
    s->current_subsubframe = 0;
423

    
424
#ifdef TRACE
425
    av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
426
    av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
427
    for (i = base_channel; i < s->prim_channels; i++){
428
        av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
429
        av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
430
        av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
431
        av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
432
        av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
433
        av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
434
        av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
435
        for (j = 0; j < 11; j++)
436
            av_log(s->avctx, AV_LOG_DEBUG, " %i",
437
                   s->quant_index_huffman[i][j]);
438
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
439
        av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
440
        for (j = 0; j < 11; j++)
441
            av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
442
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
443
    }
444
#endif
445

    
446
  return 0;
447
}
448

    
449
static int dca_parse_frame_header(DCAContext * s)
450
{
451
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
452

    
453
    /* Sync code */
454
    get_bits(&s->gb, 32);
455

    
456
    /* Frame header */
457
    s->frame_type        = get_bits(&s->gb, 1);
458
    s->samples_deficit   = get_bits(&s->gb, 5) + 1;
459
    s->crc_present       = get_bits(&s->gb, 1);
460
    s->sample_blocks     = get_bits(&s->gb, 7) + 1;
461
    s->frame_size        = get_bits(&s->gb, 14) + 1;
462
    if (s->frame_size < 95)
463
        return -1;
464
    s->amode             = get_bits(&s->gb, 6);
465
    s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
466
    if (!s->sample_rate)
467
        return -1;
468
    s->bit_rate_index    = get_bits(&s->gb, 5);
469
    s->bit_rate          = dca_bit_rates[s->bit_rate_index];
470
    if (!s->bit_rate)
471
        return -1;
472

    
473
    s->downmix           = get_bits(&s->gb, 1);
474
    s->dynrange          = get_bits(&s->gb, 1);
475
    s->timestamp         = get_bits(&s->gb, 1);
476
    s->aux_data          = get_bits(&s->gb, 1);
477
    s->hdcd              = get_bits(&s->gb, 1);
478
    s->ext_descr         = get_bits(&s->gb, 3);
479
    s->ext_coding        = get_bits(&s->gb, 1);
480
    s->aspf              = get_bits(&s->gb, 1);
481
    s->lfe               = get_bits(&s->gb, 2);
482
    s->predictor_history = get_bits(&s->gb, 1);
483

    
484
    /* TODO: check CRC */
485
    if (s->crc_present)
486
        s->header_crc    = get_bits(&s->gb, 16);
487

    
488
    s->multirate_inter   = get_bits(&s->gb, 1);
489
    s->version           = get_bits(&s->gb, 4);
490
    s->copy_history      = get_bits(&s->gb, 2);
491
    s->source_pcm_res    = get_bits(&s->gb, 3);
492
    s->front_sum         = get_bits(&s->gb, 1);
493
    s->surround_sum      = get_bits(&s->gb, 1);
494
    s->dialog_norm       = get_bits(&s->gb, 4);
495

    
496
    /* FIXME: channels mixing levels */
497
    s->output = s->amode;
498
    if (s->lfe) s->output |= DCA_LFE;
499

    
500
#ifdef TRACE
501
    av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
502
    av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
503
    av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
504
    av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
505
           s->sample_blocks, s->sample_blocks * 32);
506
    av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
507
    av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
508
           s->amode, dca_channels[s->amode]);
509
    av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
510
           s->sample_rate);
511
    av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
512
           s->bit_rate);
513
    av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
514
    av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
515
    av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
516
    av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
517
    av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
518
    av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
519
    av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
520
    av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
521
    av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
522
    av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
523
           s->predictor_history);
524
    av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
525
    av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
526
           s->multirate_inter);
527
    av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
528
    av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
529
    av_log(s->avctx, AV_LOG_DEBUG,
530
           "source pcm resolution: %i (%i bits/sample)\n",
531
           s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
532
    av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
533
    av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
534
    av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
535
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
536
#endif
537

    
538
    /* Primary audio coding header */
539
    s->subframes         = get_bits(&s->gb, 4) + 1;
540

    
541
    return dca_parse_audio_coding_header(s, 0);
542
}
543

    
544

    
545
static inline int get_scale(GetBitContext *gb, int level, int value)
546
{
547
   if (level < 5) {
548
       /* huffman encoded */
549
       value += get_bitalloc(gb, &dca_scalefactor, level);
550
   } else if (level < 8)
551
       value = get_bits(gb, level + 1);
552
   return value;
553
}
554

    
555
static int dca_subframe_header(DCAContext * s, int base_channel, int block_index)
556
{
557
    /* Primary audio coding side information */
558
    int j, k;
559

    
560
    if (!base_channel) {
561
        s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
562
        s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
563
    }
564

    
565
    for (j = base_channel; j < s->prim_channels; j++) {
566
        for (k = 0; k < s->subband_activity[j]; k++)
567
            s->prediction_mode[j][k] = get_bits(&s->gb, 1);
568
    }
569

    
570
    /* Get prediction codebook */
571
    for (j = base_channel; j < s->prim_channels; j++) {
572
        for (k = 0; k < s->subband_activity[j]; k++) {
573
            if (s->prediction_mode[j][k] > 0) {
574
                /* (Prediction coefficient VQ address) */
575
                s->prediction_vq[j][k] = get_bits(&s->gb, 12);
576
            }
577
        }
578
    }
579

    
580
    /* Bit allocation index */
581
    for (j = base_channel; j < s->prim_channels; j++) {
582
        for (k = 0; k < s->vq_start_subband[j]; k++) {
583
            if (s->bitalloc_huffman[j] == 6)
584
                s->bitalloc[j][k] = get_bits(&s->gb, 5);
585
            else if (s->bitalloc_huffman[j] == 5)
586
                s->bitalloc[j][k] = get_bits(&s->gb, 4);
587
            else if (s->bitalloc_huffman[j] == 7) {
588
                av_log(s->avctx, AV_LOG_ERROR,
589
                       "Invalid bit allocation index\n");
590
                return -1;
591
            } else {
592
                s->bitalloc[j][k] =
593
                    get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
594
            }
595

    
596
            if (s->bitalloc[j][k] > 26) {
597
//                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
598
//                          j, k, s->bitalloc[j][k]);
599
                return -1;
600
            }
601
        }
602
    }
603

    
604
    /* Transition mode */
605
    for (j = base_channel; j < s->prim_channels; j++) {
606
        for (k = 0; k < s->subband_activity[j]; k++) {
607
            s->transition_mode[j][k] = 0;
608
            if (s->subsubframes[s->current_subframe] > 1 &&
609
                k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
610
                s->transition_mode[j][k] =
611
                    get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
612
            }
613
        }
614
    }
615

    
616
    for (j = base_channel; j < s->prim_channels; j++) {
617
        const uint32_t *scale_table;
618
        int scale_sum;
619

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

    
622
        if (s->scalefactor_huffman[j] == 6)
623
            scale_table = scale_factor_quant7;
624
        else
625
            scale_table = scale_factor_quant6;
626

    
627
        /* When huffman coded, only the difference is encoded */
628
        scale_sum = 0;
629

    
630
        for (k = 0; k < s->subband_activity[j]; k++) {
631
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
632
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
633
                s->scale_factor[j][k][0] = scale_table[scale_sum];
634
            }
635

    
636
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
637
                /* Get second scale factor */
638
                scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
639
                s->scale_factor[j][k][1] = scale_table[scale_sum];
640
            }
641
        }
642
    }
643

    
644
    /* Joint subband scale factor codebook select */
645
    for (j = base_channel; j < s->prim_channels; j++) {
646
        /* Transmitted only if joint subband coding enabled */
647
        if (s->joint_intensity[j] > 0)
648
            s->joint_huff[j] = get_bits(&s->gb, 3);
649
    }
650

    
651
    /* Scale factors for joint subband coding */
652
    for (j = base_channel; j < s->prim_channels; j++) {
653
        int source_channel;
654

    
655
        /* Transmitted only if joint subband coding enabled */
656
        if (s->joint_intensity[j] > 0) {
657
            int scale = 0;
658
            source_channel = s->joint_intensity[j] - 1;
659

    
660
            /* When huffman coded, only the difference is encoded
661
             * (is this valid as well for joint scales ???) */
662

    
663
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
664
                scale = get_scale(&s->gb, s->joint_huff[j], 0);
665
                scale += 64;    /* bias */
666
                s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
667
            }
668

    
669
            if (!(s->debug_flag & 0x02)) {
670
                av_log(s->avctx, AV_LOG_DEBUG,
671
                       "Joint stereo coding not supported\n");
672
                s->debug_flag |= 0x02;
673
            }
674
        }
675
    }
676

    
677
    /* Stereo downmix coefficients */
678
    if (!base_channel && s->prim_channels > 2) {
679
        if (s->downmix) {
680
            for (j = base_channel; j < s->prim_channels; j++) {
681
                s->downmix_coef[j][0] = get_bits(&s->gb, 7);
682
                s->downmix_coef[j][1] = get_bits(&s->gb, 7);
683
            }
684
        } else {
685
            int am = s->amode & DCA_CHANNEL_MASK;
686
            for (j = base_channel; j < s->prim_channels; j++) {
687
                s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
688
                s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
689
            }
690
        }
691
    }
692

    
693
    /* Dynamic range coefficient */
694
    if (s->dynrange)
695
        s->dynrange_coef = get_bits(&s->gb, 8);
696

    
697
    /* Side information CRC check word */
698
    if (s->crc_present) {
699
        get_bits(&s->gb, 16);
700
    }
701

    
702
    /*
703
     * Primary audio data arrays
704
     */
705

    
706
    /* VQ encoded high frequency subbands */
707
    for (j = base_channel; j < s->prim_channels; j++)
708
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
709
            /* 1 vector -> 32 samples */
710
            s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
711

    
712
    /* Low frequency effect data */
713
    if (!base_channel && s->lfe) {
714
        /* LFE samples */
715
        int lfe_samples = 2 * s->lfe * (4 + block_index);
716
        int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
717
        float lfe_scale;
718

    
719
        for (j = lfe_samples; j < lfe_end_sample; j++) {
720
            /* Signed 8 bits int */
721
            s->lfe_data[j] = get_sbits(&s->gb, 8);
722
        }
723

    
724
        /* Scale factor index */
725
        s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
726

    
727
        /* Quantization step size * scale factor */
728
        lfe_scale = 0.035 * s->lfe_scale_factor;
729

    
730
        for (j = lfe_samples; j < lfe_end_sample; j++)
731
            s->lfe_data[j] *= lfe_scale;
732
    }
733

    
734
#ifdef TRACE
735
    av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes[s->current_subframe]);
736
    av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
737
           s->partial_samples[s->current_subframe]);
738
    for (j = base_channel; j < s->prim_channels; j++) {
739
        av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
740
        for (k = 0; k < s->subband_activity[j]; k++)
741
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
742
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
743
    }
744
    for (j = base_channel; j < s->prim_channels; j++) {
745
        for (k = 0; k < s->subband_activity[j]; k++)
746
                av_log(s->avctx, AV_LOG_DEBUG,
747
                       "prediction coefs: %f, %f, %f, %f\n",
748
                       (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
749
                       (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
750
                       (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
751
                       (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
752
    }
753
    for (j = base_channel; j < s->prim_channels; j++) {
754
        av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
755
        for (k = 0; k < s->vq_start_subband[j]; k++)
756
            av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
757
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
758
    }
759
    for (j = base_channel; j < s->prim_channels; j++) {
760
        av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
761
        for (k = 0; k < s->subband_activity[j]; k++)
762
            av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
763
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
764
    }
765
    for (j = base_channel; j < s->prim_channels; j++) {
766
        av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
767
        for (k = 0; k < s->subband_activity[j]; k++) {
768
            if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
769
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
770
            if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
771
                av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
772
        }
773
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
774
    }
775
    for (j = base_channel; j < s->prim_channels; j++) {
776
        if (s->joint_intensity[j] > 0) {
777
            int source_channel = s->joint_intensity[j] - 1;
778
            av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
779
            for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
780
                av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
781
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
782
        }
783
    }
784
    if (!base_channel && s->prim_channels > 2 && s->downmix) {
785
        av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
786
        for (j = 0; j < s->prim_channels; j++) {
787
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
788
            av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
789
        }
790
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
791
    }
792
    for (j = base_channel; j < s->prim_channels; j++)
793
        for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
794
            av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
795
    if (!base_channel && s->lfe) {
796
        int lfe_samples = 2 * s->lfe * (4 + block_index);
797
        int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
798

    
799
        av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
800
        for (j = lfe_samples; j < lfe_end_sample; j++)
801
            av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
802
        av_log(s->avctx, AV_LOG_DEBUG, "\n");
803
    }
804
#endif
805

    
806
    return 0;
807
}
808

    
809
static void qmf_32_subbands(DCAContext * s, int chans,
810
                            float samples_in[32][8], float *samples_out,
811
                            float scale, float bias)
812
{
813
    const float *prCoeff;
814
    int i;
815

    
816
    int sb_act = s->subband_activity[chans];
817
    int subindex;
818

    
819
    scale *= sqrt(1/8.0);
820

    
821
    /* Select filter */
822
    if (!s->multirate_inter)    /* Non-perfect reconstruction */
823
        prCoeff = fir_32bands_nonperfect;
824
    else                        /* Perfect reconstruction */
825
        prCoeff = fir_32bands_perfect;
826

    
827
    /* Reconstructed channel sample index */
828
    for (subindex = 0; subindex < 8; subindex++) {
829
        /* Load in one sample from each subband and clear inactive subbands */
830
        for (i = 0; i < sb_act; i++){
831
            uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
832
            AV_WN32A(&s->raXin[i], v);
833
        }
834
        for (; i < 32; i++)
835
            s->raXin[i] = 0.0;
836

    
837
        s->synth.synth_filter_float(&s->imdct,
838
                              s->subband_fir_hist[chans], &s->hist_index[chans],
839
                              s->subband_fir_noidea[chans], prCoeff,
840
                              samples_out, s->raXin, scale, bias);
841
        samples_out+= 32;
842

    
843
    }
844
}
845

    
846
static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
847
                                  int num_deci_sample, float *samples_in,
848
                                  float *samples_out, float scale,
849
                                  float bias)
850
{
851
    /* samples_in: An array holding decimated samples.
852
     *   Samples in current subframe starts from samples_in[0],
853
     *   while samples_in[-1], samples_in[-2], ..., stores samples
854
     *   from last subframe as history.
855
     *
856
     * samples_out: An array holding interpolated samples
857
     */
858

    
859
    int decifactor;
860
    const float *prCoeff;
861
    int deciindex;
862

    
863
    /* Select decimation filter */
864
    if (decimation_select == 1) {
865
        decifactor = 64;
866
        prCoeff = lfe_fir_128;
867
    } else {
868
        decifactor = 32;
869
        prCoeff = lfe_fir_64;
870
    }
871
    /* Interpolation */
872
    for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
873
        s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
874
                          scale, bias);
875
        samples_in++;
876
        samples_out += 2 * decifactor;
877
    }
878
}
879

    
880
/* downmixing routines */
881
#define MIX_REAR1(samples, si1, rs, coef) \
882
     samples[i]     += samples[si1] * coef[rs][0]; \
883
     samples[i+256] += samples[si1] * coef[rs][1];
884

    
885
#define MIX_REAR2(samples, si1, si2, rs, coef) \
886
     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
887
     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
888

    
889
#define MIX_FRONT3(samples, coef) \
890
    t = samples[i]; \
891
    samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
892
    samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
893

    
894
#define DOWNMIX_TO_STEREO(op1, op2) \
895
    for (i = 0; i < 256; i++){ \
896
        op1 \
897
        op2 \
898
    }
899

    
900
static void dca_downmix(float *samples, int srcfmt,
901
                        int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
902
{
903
    int i;
904
    float t;
905
    float coef[DCA_PRIM_CHANNELS_MAX][2];
906

    
907
    for (i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
908
        coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
909
        coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
910
    }
911

    
912
    switch (srcfmt) {
913
    case DCA_MONO:
914
    case DCA_CHANNEL:
915
    case DCA_STEREO_TOTAL:
916
    case DCA_STEREO_SUMDIFF:
917
    case DCA_4F2R:
918
        av_log(NULL, 0, "Not implemented!\n");
919
        break;
920
    case DCA_STEREO:
921
        break;
922
    case DCA_3F:
923
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
924
        break;
925
    case DCA_2F1R:
926
        DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
927
        break;
928
    case DCA_3F1R:
929
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
930
                          MIX_REAR1(samples, i + 768, 3, coef));
931
        break;
932
    case DCA_2F2R:
933
        DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
934
        break;
935
    case DCA_3F2R:
936
        DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
937
                          MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
938
        break;
939
    }
940
}
941

    
942

    
943
/* Very compact version of the block code decoder that does not use table
944
 * look-up but is slightly slower */
945
static int decode_blockcode(int code, int levels, int *values)
946
{
947
    int i;
948
    int offset = (levels - 1) >> 1;
949

    
950
    for (i = 0; i < 4; i++) {
951
        int div = FASTDIV(code, levels);
952
        values[i] = code - offset - div*levels;
953
        code = div;
954
    }
955

    
956
    if (code == 0)
957
        return 0;
958
    else {
959
        av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
960
        return -1;
961
    }
962
}
963

    
964
static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
965
static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
966

    
967
static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
968
{
969
    int k, l;
970
    int subsubframe = s->current_subsubframe;
971

    
972
    const float *quant_step_table;
973

    
974
    /* FIXME */
975
    float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
976
    LOCAL_ALIGNED_16(int, block, [8]);
977

    
978
    /*
979
     * Audio data
980
     */
981

    
982
    /* Select quantization step size table */
983
    if (s->bit_rate_index == 0x1f)
984
        quant_step_table = lossless_quant_d;
985
    else
986
        quant_step_table = lossy_quant_d;
987

    
988
    for (k = base_channel; k < s->prim_channels; k++) {
989
        for (l = 0; l < s->vq_start_subband[k]; l++) {
990
            int m;
991

    
992
            /* Select the mid-tread linear quantizer */
993
            int abits = s->bitalloc[k][l];
994

    
995
            float quant_step_size = quant_step_table[abits];
996

    
997
            /*
998
             * Determine quantization index code book and its type
999
             */
1000

    
1001
            /* Select quantization index code book */
1002
            int sel = s->quant_index_huffman[k][abits];
1003

    
1004
            /*
1005
             * Extract bits from the bit stream
1006
             */
1007
            if (!abits){
1008
                memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
1009
            } else {
1010
                /* Deal with transients */
1011
                int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
1012
                float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
1013

    
1014
                if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
1015
                    if (abits <= 7){
1016
                        /* Block code */
1017
                        int block_code1, block_code2, size, levels;
1018

    
1019
                        size = abits_sizes[abits-1];
1020
                        levels = abits_levels[abits-1];
1021

    
1022
                        block_code1 = get_bits(&s->gb, size);
1023
                        /* FIXME Should test return value */
1024
                        decode_blockcode(block_code1, levels, block);
1025
                        block_code2 = get_bits(&s->gb, size);
1026
                        decode_blockcode(block_code2, levels, &block[4]);
1027
                    }else{
1028
                        /* no coding */
1029
                        for (m = 0; m < 8; m++)
1030
                            block[m] = get_sbits(&s->gb, abits - 3);
1031
                    }
1032
                }else{
1033
                    /* Huffman coded */
1034
                    for (m = 0; m < 8; m++)
1035
                        block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1036
                }
1037

    
1038
                s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
1039
                                                  block, rscale, 8);
1040
            }
1041

    
1042
            /*
1043
             * Inverse ADPCM if in prediction mode
1044
             */
1045
            if (s->prediction_mode[k][l]) {
1046
                int n;
1047
                for (m = 0; m < 8; m++) {
1048
                    for (n = 1; n <= 4; n++)
1049
                        if (m >= n)
1050
                            subband_samples[k][l][m] +=
1051
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1052
                                 subband_samples[k][l][m - n] / 8192);
1053
                        else if (s->predictor_history)
1054
                            subband_samples[k][l][m] +=
1055
                                (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1056
                                 s->subband_samples_hist[k][l][m - n +
1057
                                                               4] / 8192);
1058
                }
1059
            }
1060
        }
1061

    
1062
        /*
1063
         * Decode VQ encoded high frequencies
1064
         */
1065
        for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1066
            /* 1 vector -> 32 samples but we only need the 8 samples
1067
             * for this subsubframe. */
1068
            int m;
1069

    
1070
            if (!s->debug_flag & 0x01) {
1071
                av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1072
                s->debug_flag |= 0x01;
1073
            }
1074

    
1075
            for (m = 0; m < 8; m++) {
1076
                subband_samples[k][l][m] =
1077
                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1078
                                                        m]
1079
                    * (float) s->scale_factor[k][l][0] / 16.0;
1080
            }
1081
        }
1082
    }
1083

    
1084
    /* Check for DSYNC after subsubframe */
1085
    if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
1086
        if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1087
#ifdef TRACE
1088
            av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1089
#endif
1090
        } else {
1091
            av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1092
        }
1093
    }
1094

    
1095
    /* Backup predictor history for adpcm */
1096
    for (k = base_channel; k < s->prim_channels; k++)
1097
        for (l = 0; l < s->vq_start_subband[k]; l++)
1098
            memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1099
                        4 * sizeof(subband_samples[0][0][0]));
1100

    
1101
    return 0;
1102
}
1103

    
1104
static int dca_filter_channels(DCAContext * s, int block_index)
1105
{
1106
    float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
1107
    int k;
1108

    
1109
    /* 32 subbands QMF */
1110
    for (k = 0; k < s->prim_channels; k++) {
1111
/*        static float pcm_to_double[8] =
1112
            {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1113
         qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1114
                            M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1115
                            s->add_bias );
1116
    }
1117

    
1118
    /* Down mixing */
1119
    if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
1120
        dca_downmix(s->samples, s->amode, s->downmix_coef);
1121
    }
1122

    
1123
    /* Generate LFE samples for this subsubframe FIXME!!! */
1124
    if (s->output & DCA_LFE) {
1125
        lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
1126
                              s->lfe_data + 2 * s->lfe * (block_index + 4),
1127
                              &s->samples[256 * dca_lfe_index[s->amode]],
1128
                              (1.0/256.0)*s->scale_bias,  s->add_bias);
1129
        /* Outputs 20bits pcm samples */
1130
    }
1131

    
1132
    return 0;
1133
}
1134

    
1135

    
1136
static int dca_subframe_footer(DCAContext * s, int base_channel)
1137
{
1138
    int aux_data_count = 0, i;
1139

    
1140
    /*
1141
     * Unpack optional information
1142
     */
1143

    
1144
    /* presumably optional information only appears in the core? */
1145
    if (!base_channel) {
1146
        if (s->timestamp)
1147
            get_bits(&s->gb, 32);
1148

    
1149
        if (s->aux_data)
1150
            aux_data_count = get_bits(&s->gb, 6);
1151

    
1152
        for (i = 0; i < aux_data_count; i++)
1153
            get_bits(&s->gb, 8);
1154

    
1155
        if (s->crc_present && (s->downmix || s->dynrange))
1156
            get_bits(&s->gb, 16);
1157
    }
1158

    
1159
    return 0;
1160
}
1161

    
1162
/**
1163
 * Decode a dca frame block
1164
 *
1165
 * @param s     pointer to the DCAContext
1166
 */
1167

    
1168
static int dca_decode_block(DCAContext * s, int base_channel, int block_index)
1169
{
1170

    
1171
    /* Sanity check */
1172
    if (s->current_subframe >= s->subframes) {
1173
        av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1174
               s->current_subframe, s->subframes);
1175
        return -1;
1176
    }
1177

    
1178
    if (!s->current_subsubframe) {
1179
#ifdef TRACE
1180
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1181
#endif
1182
        /* Read subframe header */
1183
        if (dca_subframe_header(s, base_channel, block_index))
1184
            return -1;
1185
    }
1186

    
1187
    /* Read subsubframe */
1188
#ifdef TRACE
1189
    av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1190
#endif
1191
    if (dca_subsubframe(s, base_channel, block_index))
1192
        return -1;
1193

    
1194
    /* Update state */
1195
    s->current_subsubframe++;
1196
    if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
1197
        s->current_subsubframe = 0;
1198
        s->current_subframe++;
1199
    }
1200
    if (s->current_subframe >= s->subframes) {
1201
#ifdef TRACE
1202
        av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1203
#endif
1204
        /* Read subframe footer */
1205
        if (dca_subframe_footer(s, base_channel))
1206
            return -1;
1207
    }
1208

    
1209
    return 0;
1210
}
1211

    
1212
/**
1213
 * Convert bitstream to one representation based on sync marker
1214
 */
1215
static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1216
                          int max_size)
1217
{
1218
    uint32_t mrk;
1219
    int i, tmp;
1220
    const uint16_t *ssrc = (const uint16_t *) src;
1221
    uint16_t *sdst = (uint16_t *) dst;
1222
    PutBitContext pb;
1223

    
1224
    if ((unsigned)src_size > (unsigned)max_size) {
1225
//        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1226
//        return -1;
1227
        src_size = max_size;
1228
    }
1229

    
1230
    mrk = AV_RB32(src);
1231
    switch (mrk) {
1232
    case DCA_MARKER_RAW_BE:
1233
        memcpy(dst, src, src_size);
1234
        return src_size;
1235
    case DCA_MARKER_RAW_LE:
1236
        for (i = 0; i < (src_size + 1) >> 1; i++)
1237
            *sdst++ = av_bswap16(*ssrc++);
1238
        return src_size;
1239
    case DCA_MARKER_14B_BE:
1240
    case DCA_MARKER_14B_LE:
1241
        init_put_bits(&pb, dst, max_size);
1242
        for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1243
            tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1244
            put_bits(&pb, 14, tmp);
1245
        }
1246
        flush_put_bits(&pb);
1247
        return (put_bits_count(&pb) + 7) >> 3;
1248
    default:
1249
        return -1;
1250
    }
1251
}
1252

    
1253
/**
1254
 * Main frame decoding function
1255
 * FIXME add arguments
1256
 */
1257
static int dca_decode_frame(AVCodecContext * avctx,
1258
                            void *data, int *data_size,
1259
                            AVPacket *avpkt)
1260
{
1261
    const uint8_t *buf = avpkt->data;
1262
    int buf_size = avpkt->size;
1263

    
1264
    int lfe_samples;
1265
    int num_core_channels = 0;
1266
    int i;
1267
    int16_t *samples = data;
1268
    DCAContext *s = avctx->priv_data;
1269
    int channels;
1270

    
1271

    
1272
    s->xch_present = 0;
1273
    s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1274
    if (s->dca_buffer_size == -1) {
1275
        av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1276
        return -1;
1277
    }
1278

    
1279
    init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1280
    if (dca_parse_frame_header(s) < 0) {
1281
        //seems like the frame is corrupt, try with the next one
1282
        *data_size=0;
1283
        return buf_size;
1284
    }
1285
    //set AVCodec values with parsed data
1286
    avctx->sample_rate = s->sample_rate;
1287
    avctx->bit_rate = s->bit_rate;
1288

    
1289
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1290
        dca_decode_block(s, 0, i);
1291
    }
1292

    
1293
    /* record number of core channels incase less than max channels are requested */
1294
    num_core_channels = s->prim_channels;
1295

    
1296
    /* extensions start at 32-bit boundaries into bitstream */
1297
    skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1298

    
1299
    while(get_bits_left(&s->gb) >= 32) {
1300
        uint32_t bits = get_bits_long(&s->gb, 32);
1301

    
1302
        switch(bits) {
1303
        case 0x5a5a5a5a: {
1304
            int ext_amode, xch_fsize;
1305

    
1306
            s->xch_base_channel = s->prim_channels;
1307

    
1308
            /* validate sync word using XCHFSIZE field */
1309
            xch_fsize = show_bits(&s->gb, 10);
1310
            if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
1311
               (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
1312
                continue;
1313

    
1314
            /* skip length-to-end-of-frame field for the moment */
1315
            skip_bits(&s->gb, 10);
1316

    
1317
            /* extension amode should == 1, number of channels in extension */
1318
            /* AFAIK XCh is not used for more channels */
1319
            if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
1320
                av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
1321
                       " supported!\n",ext_amode);
1322
                continue;
1323
            }
1324

    
1325
            /* much like core primary audio coding header */
1326
            dca_parse_audio_coding_header(s, s->xch_base_channel);
1327

    
1328
            for (i = 0; i < (s->sample_blocks / 8); i++) {
1329
                dca_decode_block(s, s->xch_base_channel, i);
1330
            }
1331

    
1332
            s->xch_present = 1;
1333
            break;
1334
        }
1335
        case 0x1d95f262:
1336
            av_log(avctx, AV_LOG_DEBUG, "Possible X96 extension found at %d bits\n", get_bits_count(&s->gb));
1337
            av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", get_bits(&s->gb, 12)+1);
1338
            av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
1339
            break;
1340
        }
1341

    
1342
        skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
1343
    }
1344

    
1345
    channels = s->prim_channels + !!s->lfe;
1346

    
1347
    if (s->amode<16) {
1348
        avctx->channel_layout = dca_core_channel_layout[s->amode];
1349

    
1350
        if (s->xch_present && (!avctx->request_channels ||
1351
                            avctx->request_channels > num_core_channels)) {
1352
            avctx->channel_layout |= CH_BACK_CENTER;
1353
            if (s->lfe) {
1354
                avctx->channel_layout |= CH_LOW_FREQUENCY;
1355
                s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
1356
            } else {
1357
                s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
1358
            }
1359
        } else {
1360
            if (s->lfe) {
1361
                avctx->channel_layout |= CH_LOW_FREQUENCY;
1362
                s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1363
            } else
1364
                s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1365
        }
1366

    
1367
        if (s->prim_channels > 0 &&
1368
            s->channel_order_tab[s->prim_channels - 1] < 0)
1369
            return -1;
1370

    
1371
        if (avctx->request_channels == 2 && s->prim_channels > 2) {
1372
            channels = 2;
1373
            s->output = DCA_STEREO;
1374
            avctx->channel_layout = CH_LAYOUT_STEREO;
1375
        }
1376
    } else {
1377
        av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1378
        return -1;
1379
    }
1380

    
1381

    
1382
    /* There is nothing that prevents a dts frame to change channel configuration
1383
       but FFmpeg doesn't support that so only set the channels if it is previously
1384
       unset. Ideally during the first probe for channels the crc should be checked
1385
       and only set avctx->channels when the crc is ok. Right now the decoder could
1386
       set the channels based on a broken first frame.*/
1387
    if (!avctx->channels)
1388
        avctx->channels = channels;
1389

    
1390
    if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1391
        return -1;
1392
    *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1393

    
1394
    /* filter to get final output */
1395
    for (i = 0; i < (s->sample_blocks / 8); i++) {
1396
        dca_filter_channels(s, i);
1397

    
1398
        /* If this was marked as a DTS-ES stream we need to subtract back- */
1399
        /* channel from SL & SR to remove matrixed back-channel signal */
1400
        if((s->source_pcm_res & 1) && s->xch_present) {
1401
            float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
1402
            float* lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
1403
            float* rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
1404
            int j;
1405
            for(j = 0; j < 256; ++j) {
1406
                lt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1407
                rt_chan[j] -= (back_chan[j] - s->add_bias) * M_SQRT1_2;
1408
            }
1409
        }
1410

    
1411
        s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1412
        samples += 256 * channels;
1413
    }
1414

    
1415
    /* update lfe history */
1416
    lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
1417
    for (i = 0; i < 2 * s->lfe * 4; i++) {
1418
        s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1419
    }
1420

    
1421
    return buf_size;
1422
}
1423

    
1424

    
1425

    
1426
/**
1427
 * DCA initialization
1428
 *
1429
 * @param avctx     pointer to the AVCodecContext
1430
 */
1431

    
1432
static av_cold int dca_decode_init(AVCodecContext * avctx)
1433
{
1434
    DCAContext *s = avctx->priv_data;
1435
    int i;
1436

    
1437
    s->avctx = avctx;
1438
    dca_init_vlcs();
1439

    
1440
    dsputil_init(&s->dsp, avctx);
1441
    ff_mdct_init(&s->imdct, 6, 1, 1.0);
1442
    ff_synth_filter_init(&s->synth);
1443
    ff_dcadsp_init(&s->dcadsp);
1444

    
1445
    for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
1446
        s->samples_chanptr[i] = s->samples + i * 256;
1447
    avctx->sample_fmt = SAMPLE_FMT_S16;
1448

    
1449
    if (s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1450
        s->add_bias = 385.0f;
1451
        s->scale_bias = 1.0 / 32768.0;
1452
    } else {
1453
        s->add_bias = 0.0f;
1454
        s->scale_bias = 1.0;
1455

    
1456
        /* allow downmixing to stereo */
1457
        if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1458
                avctx->request_channels == 2) {
1459
            avctx->channels = avctx->request_channels;
1460
        }
1461
    }
1462

    
1463

    
1464
    return 0;
1465
}
1466

    
1467
static av_cold int dca_decode_end(AVCodecContext * avctx)
1468
{
1469
    DCAContext *s = avctx->priv_data;
1470
    ff_mdct_end(&s->imdct);
1471
    return 0;
1472
}
1473

    
1474
AVCodec dca_decoder = {
1475
    .name = "dca",
1476
    .type = AVMEDIA_TYPE_AUDIO,
1477
    .id = CODEC_ID_DTS,
1478
    .priv_data_size = sizeof(DCAContext),
1479
    .init = dca_decode_init,
1480
    .decode = dca_decode_frame,
1481
    .close = dca_decode_end,
1482
    .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1483
};