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