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