DCA: move an aligned array from stack to context
[ffmpeg.git] / libavcodec / dca.c
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 "get_bits.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     DECLARE_ALIGNED_16(float, raXin[32]);
234
235     int output;                 ///< type of output
236     float add_bias;             ///< output bias
237     float scale_bias;           ///< output scale
238
239     DECLARE_ALIGNED_16(float, samples[1536]);  /* 6 * 256 = 1536, might only need 5 */
240     const float *samples_chanptr[6];
241
242     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
243     int dca_buffer_size;        ///< how much data is in the dca_buffer
244
245     const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
246     GetBitContext gb;
247     /* Current position in DCA frame */
248     int current_subframe;
249     int current_subsubframe;
250
251     int debug_flag;             ///< used for suppressing repeated error messages output
252     DSPContext dsp;
253     MDCTContext imdct;
254 } DCAContext;
255
256 static const uint16_t dca_vlc_offs[] = {
257         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
258      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
259      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
260      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
261     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
262     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
263 };
264
265 static av_cold void dca_init_vlcs(void)
266 {
267     static int vlcs_initialized = 0;
268     int i, j, c = 14;
269     static VLC_TYPE dca_table[23622][2];
270
271     if (vlcs_initialized)
272         return;
273
274     dca_bitalloc_index.offset = 1;
275     dca_bitalloc_index.wrap = 2;
276     for (i = 0; i < 5; i++) {
277         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
278         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
279         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
280                  bitalloc_12_bits[i], 1, 1,
281                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
282     }
283     dca_scalefactor.offset = -64;
284     dca_scalefactor.wrap = 2;
285     for (i = 0; i < 5; i++) {
286         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
287         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
288         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
289                  scales_bits[i], 1, 1,
290                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
291     }
292     dca_tmode.offset = 0;
293     dca_tmode.wrap = 1;
294     for (i = 0; i < 4; i++) {
295         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
296         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
297         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
298                  tmode_bits[i], 1, 1,
299                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
300     }
301
302     for(i = 0; i < 10; i++)
303         for(j = 0; j < 7; j++){
304             if(!bitalloc_codes[i][j]) break;
305             dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
306             dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
307             dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
308             dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
309             init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
310                      bitalloc_sizes[i],
311                      bitalloc_bits[i][j], 1, 1,
312                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
313             c++;
314         }
315     vlcs_initialized = 1;
316 }
317
318 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
319 {
320     while(len--)
321         *dst++ = get_bits(gb, bits);
322 }
323
324 static int dca_parse_frame_header(DCAContext * s)
325 {
326     int i, j;
327     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
328     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
329     static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
330
331     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
332
333     /* Sync code */
334     get_bits(&s->gb, 32);
335
336     /* Frame header */
337     s->frame_type        = get_bits(&s->gb, 1);
338     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
339     s->crc_present       = get_bits(&s->gb, 1);
340     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
341     s->frame_size        = get_bits(&s->gb, 14) + 1;
342     if (s->frame_size < 95)
343         return -1;
344     s->amode             = get_bits(&s->gb, 6);
345     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
346     if (!s->sample_rate)
347         return -1;
348     s->bit_rate_index    = get_bits(&s->gb, 5);
349     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
350     if (!s->bit_rate)
351         return -1;
352
353     s->downmix           = get_bits(&s->gb, 1);
354     s->dynrange          = get_bits(&s->gb, 1);
355     s->timestamp         = get_bits(&s->gb, 1);
356     s->aux_data          = get_bits(&s->gb, 1);
357     s->hdcd              = get_bits(&s->gb, 1);
358     s->ext_descr         = get_bits(&s->gb, 3);
359     s->ext_coding        = get_bits(&s->gb, 1);
360     s->aspf              = get_bits(&s->gb, 1);
361     s->lfe               = get_bits(&s->gb, 2);
362     s->predictor_history = get_bits(&s->gb, 1);
363
364     /* TODO: check CRC */
365     if (s->crc_present)
366         s->header_crc    = get_bits(&s->gb, 16);
367
368     s->multirate_inter   = get_bits(&s->gb, 1);
369     s->version           = get_bits(&s->gb, 4);
370     s->copy_history      = get_bits(&s->gb, 2);
371     s->source_pcm_res    = get_bits(&s->gb, 3);
372     s->front_sum         = get_bits(&s->gb, 1);
373     s->surround_sum      = get_bits(&s->gb, 1);
374     s->dialog_norm       = get_bits(&s->gb, 4);
375
376     /* FIXME: channels mixing levels */
377     s->output = s->amode;
378     if(s->lfe) s->output |= DCA_LFE;
379
380 #ifdef TRACE
381     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
382     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
383     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
384     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
385            s->sample_blocks, s->sample_blocks * 32);
386     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
387     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
388            s->amode, dca_channels[s->amode]);
389     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
390            s->sample_rate);
391     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
392            s->bit_rate);
393     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
394     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
395     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
396     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
397     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
398     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
399     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
400     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
401     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
402     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
403            s->predictor_history);
404     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
405     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
406            s->multirate_inter);
407     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
408     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
409     av_log(s->avctx, AV_LOG_DEBUG,
410            "source pcm resolution: %i (%i bits/sample)\n",
411            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
412     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
413     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
414     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
415     av_log(s->avctx, AV_LOG_DEBUG, "\n");
416 #endif
417
418     /* Primary audio coding header */
419     s->subframes         = get_bits(&s->gb, 4) + 1;
420     s->total_channels    = get_bits(&s->gb, 3) + 1;
421     s->prim_channels     = s->total_channels;
422     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
423         s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
424
425
426     for (i = 0; i < s->prim_channels; i++) {
427         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
428         if (s->subband_activity[i] > DCA_SUBBANDS)
429             s->subband_activity[i] = DCA_SUBBANDS;
430     }
431     for (i = 0; i < s->prim_channels; i++) {
432         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
433         if (s->vq_start_subband[i] > DCA_SUBBANDS)
434             s->vq_start_subband[i] = DCA_SUBBANDS;
435     }
436     get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
437     get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
438     get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
439     get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
440
441     /* Get codebooks quantization indexes */
442     memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
443     for (j = 1; j < 11; j++)
444         for (i = 0; i < s->prim_channels; i++)
445             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
446
447     /* Get scale factor adjustment */
448     for (j = 0; j < 11; j++)
449         for (i = 0; i < s->prim_channels; i++)
450             s->scalefactor_adj[i][j] = 1;
451
452     for (j = 1; j < 11; j++)
453         for (i = 0; i < s->prim_channels; i++)
454             if (s->quant_index_huffman[i][j] < thr[j])
455                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
456
457     if (s->crc_present) {
458         /* Audio header CRC check */
459         get_bits(&s->gb, 16);
460     }
461
462     s->current_subframe = 0;
463     s->current_subsubframe = 0;
464
465 #ifdef TRACE
466     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
467     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
468     for(i = 0; i < s->prim_channels; i++){
469         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
470         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
471         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
472         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
473         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
474         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
475         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
476         for (j = 0; j < 11; j++)
477             av_log(s->avctx, AV_LOG_DEBUG, " %i",
478                    s->quant_index_huffman[i][j]);
479         av_log(s->avctx, AV_LOG_DEBUG, "\n");
480         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
481         for (j = 0; j < 11; j++)
482             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
483         av_log(s->avctx, AV_LOG_DEBUG, "\n");
484     }
485 #endif
486
487     return 0;
488 }
489
490
491 static inline int get_scale(GetBitContext *gb, int level, int value)
492 {
493    if (level < 5) {
494        /* huffman encoded */
495        value += get_bitalloc(gb, &dca_scalefactor, level);
496    } else if(level < 8)
497        value = get_bits(gb, level + 1);
498    return value;
499 }
500
501 static int dca_subframe_header(DCAContext * s)
502 {
503     /* Primary audio coding side information */
504     int j, k;
505
506     s->subsubframes = get_bits(&s->gb, 2) + 1;
507     s->partial_samples = get_bits(&s->gb, 3);
508     for (j = 0; j < s->prim_channels; j++) {
509         for (k = 0; k < s->subband_activity[j]; k++)
510             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
511     }
512
513     /* Get prediction codebook */
514     for (j = 0; j < s->prim_channels; j++) {
515         for (k = 0; k < s->subband_activity[j]; k++) {
516             if (s->prediction_mode[j][k] > 0) {
517                 /* (Prediction coefficient VQ address) */
518                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
519             }
520         }
521     }
522
523     /* Bit allocation index */
524     for (j = 0; j < s->prim_channels; j++) {
525         for (k = 0; k < s->vq_start_subband[j]; k++) {
526             if (s->bitalloc_huffman[j] == 6)
527                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
528             else if (s->bitalloc_huffman[j] == 5)
529                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
530             else if (s->bitalloc_huffman[j] == 7) {
531                 av_log(s->avctx, AV_LOG_ERROR,
532                        "Invalid bit allocation index\n");
533                 return -1;
534             } else {
535                 s->bitalloc[j][k] =
536                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
537             }
538
539             if (s->bitalloc[j][k] > 26) {
540 //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
541 //                          j, k, s->bitalloc[j][k]);
542                 return -1;
543             }
544         }
545     }
546
547     /* Transition mode */
548     for (j = 0; j < s->prim_channels; j++) {
549         for (k = 0; k < s->subband_activity[j]; k++) {
550             s->transition_mode[j][k] = 0;
551             if (s->subsubframes > 1 &&
552                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
553                 s->transition_mode[j][k] =
554                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
555             }
556         }
557     }
558
559     for (j = 0; j < s->prim_channels; j++) {
560         const uint32_t *scale_table;
561         int scale_sum;
562
563         memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
564
565         if (s->scalefactor_huffman[j] == 6)
566             scale_table = scale_factor_quant7;
567         else
568             scale_table = scale_factor_quant6;
569
570         /* When huffman coded, only the difference is encoded */
571         scale_sum = 0;
572
573         for (k = 0; k < s->subband_activity[j]; k++) {
574             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
575                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
576                 s->scale_factor[j][k][0] = scale_table[scale_sum];
577             }
578
579             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
580                 /* Get second scale factor */
581                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
582                 s->scale_factor[j][k][1] = scale_table[scale_sum];
583             }
584         }
585     }
586
587     /* Joint subband scale factor codebook select */
588     for (j = 0; j < s->prim_channels; j++) {
589         /* Transmitted only if joint subband coding enabled */
590         if (s->joint_intensity[j] > 0)
591             s->joint_huff[j] = get_bits(&s->gb, 3);
592     }
593
594     /* Scale factors for joint subband coding */
595     for (j = 0; j < s->prim_channels; j++) {
596         int source_channel;
597
598         /* Transmitted only if joint subband coding enabled */
599         if (s->joint_intensity[j] > 0) {
600             int scale = 0;
601             source_channel = s->joint_intensity[j] - 1;
602
603             /* When huffman coded, only the difference is encoded
604              * (is this valid as well for joint scales ???) */
605
606             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
607                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
608                 scale += 64;    /* bias */
609                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
610             }
611
612             if (!s->debug_flag & 0x02) {
613                 av_log(s->avctx, AV_LOG_DEBUG,
614                        "Joint stereo coding not supported\n");
615                 s->debug_flag |= 0x02;
616             }
617         }
618     }
619
620     /* Stereo downmix coefficients */
621     if (s->prim_channels > 2) {
622         if(s->downmix) {
623             for (j = 0; j < s->prim_channels; j++) {
624                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
625                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
626             }
627         } else {
628             int am = s->amode & DCA_CHANNEL_MASK;
629             for (j = 0; j < s->prim_channels; j++) {
630                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
631                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
632             }
633         }
634     }
635
636     /* Dynamic range coefficient */
637     if (s->dynrange)
638         s->dynrange_coef = get_bits(&s->gb, 8);
639
640     /* Side information CRC check word */
641     if (s->crc_present) {
642         get_bits(&s->gb, 16);
643     }
644
645     /*
646      * Primary audio data arrays
647      */
648
649     /* VQ encoded high frequency subbands */
650     for (j = 0; j < s->prim_channels; j++)
651         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
652             /* 1 vector -> 32 samples */
653             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
654
655     /* Low frequency effect data */
656     if (s->lfe) {
657         /* LFE samples */
658         int lfe_samples = 2 * s->lfe * s->subsubframes;
659         float lfe_scale;
660
661         for (j = lfe_samples; j < lfe_samples * 2; j++) {
662             /* Signed 8 bits int */
663             s->lfe_data[j] = get_sbits(&s->gb, 8);
664         }
665
666         /* Scale factor index */
667         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
668
669         /* Quantization step size * scale factor */
670         lfe_scale = 0.035 * s->lfe_scale_factor;
671
672         for (j = lfe_samples; j < lfe_samples * 2; j++)
673             s->lfe_data[j] *= lfe_scale;
674     }
675
676 #ifdef TRACE
677     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
678     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
679            s->partial_samples);
680     for (j = 0; j < s->prim_channels; j++) {
681         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
682         for (k = 0; k < s->subband_activity[j]; k++)
683             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
684         av_log(s->avctx, AV_LOG_DEBUG, "\n");
685     }
686     for (j = 0; j < s->prim_channels; j++) {
687         for (k = 0; k < s->subband_activity[j]; k++)
688                 av_log(s->avctx, AV_LOG_DEBUG,
689                        "prediction coefs: %f, %f, %f, %f\n",
690                        (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
691                        (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
692                        (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
693                        (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
694     }
695     for (j = 0; j < s->prim_channels; j++) {
696         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
697         for (k = 0; k < s->vq_start_subband[j]; k++)
698             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
699         av_log(s->avctx, AV_LOG_DEBUG, "\n");
700     }
701     for (j = 0; j < s->prim_channels; j++) {
702         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
703         for (k = 0; k < s->subband_activity[j]; k++)
704             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
705         av_log(s->avctx, AV_LOG_DEBUG, "\n");
706     }
707     for (j = 0; j < s->prim_channels; j++) {
708         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
709         for (k = 0; k < s->subband_activity[j]; k++) {
710             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
711                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
712             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
713                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
714         }
715         av_log(s->avctx, AV_LOG_DEBUG, "\n");
716     }
717     for (j = 0; j < s->prim_channels; j++) {
718         if (s->joint_intensity[j] > 0) {
719             int source_channel = s->joint_intensity[j] - 1;
720             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
721             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
722                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
723             av_log(s->avctx, AV_LOG_DEBUG, "\n");
724         }
725     }
726     if (s->prim_channels > 2 && s->downmix) {
727         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
728         for (j = 0; j < s->prim_channels; j++) {
729             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
730             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
731         }
732         av_log(s->avctx, AV_LOG_DEBUG, "\n");
733     }
734     for (j = 0; j < s->prim_channels; j++)
735         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
736             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
737     if(s->lfe){
738         int lfe_samples = 2 * s->lfe * s->subsubframes;
739         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
740         for (j = lfe_samples; j < lfe_samples * 2; j++)
741             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
742         av_log(s->avctx, AV_LOG_DEBUG, "\n");
743     }
744 #endif
745
746     return 0;
747 }
748
749 static void qmf_32_subbands(DCAContext * s, int chans,
750                             float samples_in[32][8], float *samples_out,
751                             float scale, float bias)
752 {
753     const float *prCoeff;
754     int i, j;
755
756     int hist_index= s->hist_index[chans];
757     float *subband_fir_hist2 = s->subband_fir_noidea[chans];
758
759     int subindex;
760
761     scale *= sqrt(1/8.0);
762
763     /* Select filter */
764     if (!s->multirate_inter)    /* Non-perfect reconstruction */
765         prCoeff = fir_32bands_nonperfect;
766     else                        /* Perfect reconstruction */
767         prCoeff = fir_32bands_perfect;
768
769     /* Reconstructed channel sample index */
770     for (subindex = 0; subindex < 8; subindex++) {
771         float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
772         /* Load in one sample from each subband and clear inactive subbands */
773         for (i = 0; i < s->subband_activity[chans]; i++){
774             if((i-1)&2) s->raXin[i] = -samples_in[i][subindex];
775             else        s->raXin[i] =  samples_in[i][subindex];
776         }
777         for (; i < 32; i++)
778             s->raXin[i] = 0.0;
779
780         ff_imdct_half(&s->imdct, subband_fir_hist, s->raXin);
781
782         /* Multiply by filter coefficients */
783         for (i = 0; i < 16; i++){
784             float a= subband_fir_hist2[i   ];
785             float b= subband_fir_hist2[i+16];
786             float c= 0;
787             float d= 0;
788             for (j = 0; j < 512-hist_index; j += 64){
789                 a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j]);
790                 b += prCoeff[i+j+16]*( subband_fir_hist[   i+j]);
791                 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
792                 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
793             }
794             for (     ; j < 512; j += 64){
795                 a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j-512]);
796                 b += prCoeff[i+j+16]*( subband_fir_hist[   i+j-512]);
797                 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
798                 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
799             }
800             samples_out[i   ] = a * scale + bias;
801             samples_out[i+16] = b * scale + bias;
802             subband_fir_hist2[i   ] = c;
803             subband_fir_hist2[i+16] = d;
804         }
805         samples_out+= 32;
806
807         hist_index = (hist_index-32)&511;
808     }
809     s->hist_index[chans]= hist_index;
810 }
811
812 static void lfe_interpolation_fir(int decimation_select,
813                                   int num_deci_sample, float *samples_in,
814                                   float *samples_out, float scale,
815                                   float bias)
816 {
817     /* samples_in: An array holding decimated samples.
818      *   Samples in current subframe starts from samples_in[0],
819      *   while samples_in[-1], samples_in[-2], ..., stores samples
820      *   from last subframe as history.
821      *
822      * samples_out: An array holding interpolated samples
823      */
824
825     int decifactor, k, j;
826     const float *prCoeff;
827
828     int interp_index = 0;       /* Index to the interpolated samples */
829     int deciindex;
830
831     /* Select decimation filter */
832     if (decimation_select == 1) {
833         decifactor = 128;
834         prCoeff = lfe_fir_128;
835     } else {
836         decifactor = 64;
837         prCoeff = lfe_fir_64;
838     }
839     /* Interpolation */
840     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
841         /* One decimated sample generates decifactor interpolated ones */
842         for (k = 0; k < decifactor; k++) {
843             float rTmp = 0.0;
844             //FIXME the coeffs are symetric, fix that
845             for (j = 0; j < 512 / decifactor; j++)
846                 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
847             samples_out[interp_index++] = (rTmp * scale) + bias;
848         }
849     }
850 }
851
852 /* downmixing routines */
853 #define MIX_REAR1(samples, si1, rs, coef) \
854      samples[i]     += samples[si1] * coef[rs][0]; \
855      samples[i+256] += samples[si1] * coef[rs][1];
856
857 #define MIX_REAR2(samples, si1, si2, rs, coef) \
858      samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
859      samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
860
861 #define MIX_FRONT3(samples, coef) \
862     t = samples[i]; \
863     samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
864     samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
865
866 #define DOWNMIX_TO_STEREO(op1, op2) \
867     for(i = 0; i < 256; i++){ \
868         op1 \
869         op2 \
870     }
871
872 static void dca_downmix(float *samples, int srcfmt,
873                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
874 {
875     int i;
876     float t;
877     float coef[DCA_PRIM_CHANNELS_MAX][2];
878
879     for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
880         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
881         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
882     }
883
884     switch (srcfmt) {
885     case DCA_MONO:
886     case DCA_CHANNEL:
887     case DCA_STEREO_TOTAL:
888     case DCA_STEREO_SUMDIFF:
889     case DCA_4F2R:
890         av_log(NULL, 0, "Not implemented!\n");
891         break;
892     case DCA_STEREO:
893         break;
894     case DCA_3F:
895         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
896         break;
897     case DCA_2F1R:
898         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
899         break;
900     case DCA_3F1R:
901         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
902                           MIX_REAR1(samples, i + 768, 3, coef));
903         break;
904     case DCA_2F2R:
905         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
906         break;
907     case DCA_3F2R:
908         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
909                           MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
910         break;
911     }
912 }
913
914
915 /* Very compact version of the block code decoder that does not use table
916  * look-up but is slightly slower */
917 static int decode_blockcode(int code, int levels, int *values)
918 {
919     int i;
920     int offset = (levels - 1) >> 1;
921
922     for (i = 0; i < 4; i++) {
923         values[i] = (code % levels) - offset;
924         code /= levels;
925     }
926
927     if (code == 0)
928         return 0;
929     else {
930         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
931         return -1;
932     }
933 }
934
935 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
936 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
937
938 static int dca_subsubframe(DCAContext * s)
939 {
940     int k, l;
941     int subsubframe = s->current_subsubframe;
942
943     const float *quant_step_table;
944
945     /* FIXME */
946     float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
947
948     /*
949      * Audio data
950      */
951
952     /* Select quantization step size table */
953     if (s->bit_rate_index == 0x1f)
954         quant_step_table = lossless_quant_d;
955     else
956         quant_step_table = lossy_quant_d;
957
958     for (k = 0; k < s->prim_channels; k++) {
959         for (l = 0; l < s->vq_start_subband[k]; l++) {
960             int m;
961
962             /* Select the mid-tread linear quantizer */
963             int abits = s->bitalloc[k][l];
964
965             float quant_step_size = quant_step_table[abits];
966             float rscale;
967
968             /*
969              * Determine quantization index code book and its type
970              */
971
972             /* Select quantization index code book */
973             int sel = s->quant_index_huffman[k][abits];
974
975             /*
976              * Extract bits from the bit stream
977              */
978             if(!abits){
979                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
980             }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
981                 if(abits <= 7){
982                     /* Block code */
983                     int block_code1, block_code2, size, levels;
984                     int block[8];
985
986                     size = abits_sizes[abits-1];
987                     levels = abits_levels[abits-1];
988
989                     block_code1 = get_bits(&s->gb, size);
990                     /* FIXME Should test return value */
991                     decode_blockcode(block_code1, levels, block);
992                     block_code2 = get_bits(&s->gb, size);
993                     decode_blockcode(block_code2, levels, &block[4]);
994                     for (m = 0; m < 8; m++)
995                         subband_samples[k][l][m] = block[m];
996                 }else{
997                     /* no coding */
998                     for (m = 0; m < 8; m++)
999                         subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
1000                 }
1001             }else{
1002                 /* Huffman coded */
1003                 for (m = 0; m < 8; m++)
1004                     subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
1005             }
1006
1007             /* Deal with transients */
1008             if (s->transition_mode[k][l] &&
1009                 subsubframe >= s->transition_mode[k][l])
1010                 rscale = quant_step_size * s->scale_factor[k][l][1];
1011             else
1012                 rscale = quant_step_size * s->scale_factor[k][l][0];
1013
1014             rscale *= s->scalefactor_adj[k][sel];
1015
1016             for (m = 0; m < 8; m++)
1017                 subband_samples[k][l][m] *= rscale;
1018
1019             /*
1020              * Inverse ADPCM if in prediction mode
1021              */
1022             if (s->prediction_mode[k][l]) {
1023                 int n;
1024                 for (m = 0; m < 8; m++) {
1025                     for (n = 1; n <= 4; n++)
1026                         if (m >= n)
1027                             subband_samples[k][l][m] +=
1028                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1029                                  subband_samples[k][l][m - n] / 8192);
1030                         else if (s->predictor_history)
1031                             subband_samples[k][l][m] +=
1032                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1033                                  s->subband_samples_hist[k][l][m - n +
1034                                                                4] / 8192);
1035                 }
1036             }
1037         }
1038
1039         /*
1040          * Decode VQ encoded high frequencies
1041          */
1042         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1043             /* 1 vector -> 32 samples but we only need the 8 samples
1044              * for this subsubframe. */
1045             int m;
1046
1047             if (!s->debug_flag & 0x01) {
1048                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1049                 s->debug_flag |= 0x01;
1050             }
1051
1052             for (m = 0; m < 8; m++) {
1053                 subband_samples[k][l][m] =
1054                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1055                                                         m]
1056                     * (float) s->scale_factor[k][l][0] / 16.0;
1057             }
1058         }
1059     }
1060
1061     /* Check for DSYNC after subsubframe */
1062     if (s->aspf || subsubframe == s->subsubframes - 1) {
1063         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
1064 #ifdef TRACE
1065             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1066 #endif
1067         } else {
1068             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1069         }
1070     }
1071
1072     /* Backup predictor history for adpcm */
1073     for (k = 0; k < s->prim_channels; k++)
1074         for (l = 0; l < s->vq_start_subband[k]; l++)
1075             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1076                         4 * sizeof(subband_samples[0][0][0]));
1077
1078     /* 32 subbands QMF */
1079     for (k = 0; k < s->prim_channels; k++) {
1080 /*        static float pcm_to_double[8] =
1081             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1082          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1083                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1084                             s->add_bias );
1085     }
1086
1087     /* Down mixing */
1088
1089     if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1090         dca_downmix(s->samples, s->amode, s->downmix_coef);
1091     }
1092
1093     /* Generate LFE samples for this subsubframe FIXME!!! */
1094     if (s->output & DCA_LFE) {
1095         int lfe_samples = 2 * s->lfe * s->subsubframes;
1096
1097         lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1098                               s->lfe_data + lfe_samples +
1099                               2 * s->lfe * subsubframe,
1100                               &s->samples[256 * dca_lfe_index[s->amode]],
1101                               (1.0/256.0)*s->scale_bias,  s->add_bias);
1102         /* Outputs 20bits pcm samples */
1103     }
1104
1105     return 0;
1106 }
1107
1108
1109 static int dca_subframe_footer(DCAContext * s)
1110 {
1111     int aux_data_count = 0, i;
1112     int lfe_samples;
1113
1114     /*
1115      * Unpack optional information
1116      */
1117
1118     if (s->timestamp)
1119         get_bits(&s->gb, 32);
1120
1121     if (s->aux_data)
1122         aux_data_count = get_bits(&s->gb, 6);
1123
1124     for (i = 0; i < aux_data_count; i++)
1125         get_bits(&s->gb, 8);
1126
1127     if (s->crc_present && (s->downmix || s->dynrange))
1128         get_bits(&s->gb, 16);
1129
1130     lfe_samples = 2 * s->lfe * s->subsubframes;
1131     for (i = 0; i < lfe_samples; i++) {
1132         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1133     }
1134
1135     return 0;
1136 }
1137
1138 /**
1139  * Decode a dca frame block
1140  *
1141  * @param s     pointer to the DCAContext
1142  */
1143
1144 static int dca_decode_block(DCAContext * s)
1145 {
1146
1147     /* Sanity check */
1148     if (s->current_subframe >= s->subframes) {
1149         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1150                s->current_subframe, s->subframes);
1151         return -1;
1152     }
1153
1154     if (!s->current_subsubframe) {
1155 #ifdef TRACE
1156         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1157 #endif
1158         /* Read subframe header */
1159         if (dca_subframe_header(s))
1160             return -1;
1161     }
1162
1163     /* Read subsubframe */
1164 #ifdef TRACE
1165     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1166 #endif
1167     if (dca_subsubframe(s))
1168         return -1;
1169
1170     /* Update state */
1171     s->current_subsubframe++;
1172     if (s->current_subsubframe >= s->subsubframes) {
1173         s->current_subsubframe = 0;
1174         s->current_subframe++;
1175     }
1176     if (s->current_subframe >= s->subframes) {
1177 #ifdef TRACE
1178         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1179 #endif
1180         /* Read subframe footer */
1181         if (dca_subframe_footer(s))
1182             return -1;
1183     }
1184
1185     return 0;
1186 }
1187
1188 /**
1189  * Convert bitstream to one representation based on sync marker
1190  */
1191 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1192                           int max_size)
1193 {
1194     uint32_t mrk;
1195     int i, tmp;
1196     const uint16_t *ssrc = (const uint16_t *) src;
1197     uint16_t *sdst = (uint16_t *) dst;
1198     PutBitContext pb;
1199
1200     if((unsigned)src_size > (unsigned)max_size) {
1201 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1202 //        return -1;
1203         src_size = max_size;
1204     }
1205
1206     mrk = AV_RB32(src);
1207     switch (mrk) {
1208     case DCA_MARKER_RAW_BE:
1209         memcpy(dst, src, src_size);
1210         return src_size;
1211     case DCA_MARKER_RAW_LE:
1212         for (i = 0; i < (src_size + 1) >> 1; i++)
1213             *sdst++ = bswap_16(*ssrc++);
1214         return src_size;
1215     case DCA_MARKER_14B_BE:
1216     case DCA_MARKER_14B_LE:
1217         init_put_bits(&pb, dst, max_size);
1218         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1219             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1220             put_bits(&pb, 14, tmp);
1221         }
1222         flush_put_bits(&pb);
1223         return (put_bits_count(&pb) + 7) >> 3;
1224     default:
1225         return -1;
1226     }
1227 }
1228
1229 /**
1230  * Main frame decoding function
1231  * FIXME add arguments
1232  */
1233 static int dca_decode_frame(AVCodecContext * avctx,
1234                             void *data, int *data_size,
1235                             AVPacket *avpkt)
1236 {
1237     const uint8_t *buf = avpkt->data;
1238     int buf_size = avpkt->size;
1239
1240     int i;
1241     int16_t *samples = data;
1242     DCAContext *s = avctx->priv_data;
1243     int channels;
1244
1245
1246     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1247     if (s->dca_buffer_size == -1) {
1248         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1249         return -1;
1250     }
1251
1252     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1253     if (dca_parse_frame_header(s) < 0) {
1254         //seems like the frame is corrupt, try with the next one
1255         *data_size=0;
1256         return buf_size;
1257     }
1258     //set AVCodec values with parsed data
1259     avctx->sample_rate = s->sample_rate;
1260     avctx->bit_rate = s->bit_rate;
1261
1262     channels = s->prim_channels + !!s->lfe;
1263
1264     if (s->amode<16) {
1265         avctx->channel_layout = dca_core_channel_layout[s->amode];
1266
1267         if (s->lfe) {
1268             avctx->channel_layout |= CH_LOW_FREQUENCY;
1269             s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1270         } else
1271             s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1272
1273         if(avctx->request_channels == 2 && s->prim_channels > 2) {
1274             channels = 2;
1275             s->output = DCA_STEREO;
1276             avctx->channel_layout = CH_LAYOUT_STEREO;
1277         }
1278     } else {
1279         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1280         return -1;
1281     }
1282
1283
1284     /* There is nothing that prevents a dts frame to change channel configuration
1285        but FFmpeg doesn't support that so only set the channels if it is previously
1286        unset. Ideally during the first probe for channels the crc should be checked
1287        and only set avctx->channels when the crc is ok. Right now the decoder could
1288        set the channels based on a broken first frame.*/
1289     if (!avctx->channels)
1290         avctx->channels = channels;
1291
1292     if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1293         return -1;
1294     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1295     for (i = 0; i < (s->sample_blocks / 8); i++) {
1296         dca_decode_block(s);
1297         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1298         samples += 256 * channels;
1299     }
1300
1301     return buf_size;
1302 }
1303
1304
1305
1306 /**
1307  * DCA initialization
1308  *
1309  * @param avctx     pointer to the AVCodecContext
1310  */
1311
1312 static av_cold int dca_decode_init(AVCodecContext * avctx)
1313 {
1314     DCAContext *s = avctx->priv_data;
1315     int i;
1316
1317     s->avctx = avctx;
1318     dca_init_vlcs();
1319
1320     dsputil_init(&s->dsp, avctx);
1321     ff_mdct_init(&s->imdct, 6, 1, 1.0);
1322
1323     for(i = 0; i < 6; i++)
1324         s->samples_chanptr[i] = s->samples + i * 256;
1325     avctx->sample_fmt = SAMPLE_FMT_S16;
1326
1327     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1328         s->add_bias = 385.0f;
1329         s->scale_bias = 1.0 / 32768.0;
1330     } else {
1331         s->add_bias = 0.0f;
1332         s->scale_bias = 1.0;
1333
1334         /* allow downmixing to stereo */
1335         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1336                 avctx->request_channels == 2) {
1337             avctx->channels = avctx->request_channels;
1338         }
1339     }
1340
1341
1342     return 0;
1343 }
1344
1345 static av_cold int dca_decode_end(AVCodecContext * avctx)
1346 {
1347     DCAContext *s = avctx->priv_data;
1348     ff_mdct_end(&s->imdct);
1349     return 0;
1350 }
1351
1352 AVCodec dca_decoder = {
1353     .name = "dca",
1354     .type = CODEC_TYPE_AUDIO,
1355     .id = CODEC_ID_DTS,
1356     .priv_data_size = sizeof(DCAContext),
1357     .init = dca_decode_init,
1358     .decode = dca_decode_frame,
1359     .close = dca_decode_end,
1360     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1361 };