DCA: break out lfe_interpolation_fir() inner loops to a function
[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/intmath.h"
34 #include "libavutil/intreadwrite.h"
35 #include "avcodec.h"
36 #include "dsputil.h"
37 #include "fft.h"
38 #include "get_bits.h"
39 #include "put_bits.h"
40 #include "dcadata.h"
41 #include "dcahuff.h"
42 #include "dca.h"
43 #include "synth_filter.h"
44 #include "dcadsp.h"
45
46 //#define TRACE
47
48 #define DCA_PRIM_CHANNELS_MAX (5)
49 #define DCA_SUBBANDS (32)
50 #define DCA_ABITS_MAX (32)      /* Should be 28 */
51 #define DCA_SUBSUBFAMES_MAX (4)
52 #define DCA_LFE_MAX (3)
53
54 enum DCAMode {
55     DCA_MONO = 0,
56     DCA_CHANNEL,
57     DCA_STEREO,
58     DCA_STEREO_SUMDIFF,
59     DCA_STEREO_TOTAL,
60     DCA_3F,
61     DCA_2F1R,
62     DCA_3F1R,
63     DCA_2F2R,
64     DCA_3F2R,
65     DCA_4F2R
66 };
67
68 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
69  * Some compromises have been made for special configurations. Most configurations
70  * are never used so complete accuracy is not needed.
71  *
72  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
73  * S  -> side, when both rear and back are configured move one of them to the side channel
74  * OV -> center back
75  * All 2 channel configurations -> CH_LAYOUT_STEREO
76  */
77
78 static const int64_t dca_core_channel_layout[] = {
79     CH_FRONT_CENTER,                                               ///< 1, A
80     CH_LAYOUT_STEREO,                                              ///< 2, A + B (dual mono)
81     CH_LAYOUT_STEREO,                                              ///< 2, L + R (stereo)
82     CH_LAYOUT_STEREO,                                              ///< 2, (L+R) + (L-R) (sum-difference)
83     CH_LAYOUT_STEREO,                                              ///< 2, LT +RT (left and right total)
84     CH_LAYOUT_STEREO|CH_FRONT_CENTER,                              ///< 3, C+L+R
85     CH_LAYOUT_STEREO|CH_BACK_CENTER,                               ///< 3, L+R+S
86     CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,               ///< 4, C + L + R+ S
87     CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,                   ///< 4, L + R +SL+ SR
88     CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT,   ///< 5, C + L + R+ SL+SR
89     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
90     CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,                                   ///< 6, C + L + R+ LR + RR + OV
91     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
92     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
93     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
94     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
95 };
96
97 static const int8_t dca_lfe_index[] = {
98     1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
99 };
100
101 static const int8_t dca_channel_reorder_lfe[][8] = {
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     { 0,  1, -1, -1, -1, -1, -1, -1},
106     { 0,  1, -1, -1, -1, -1, -1, -1},
107     { 2,  0,  1, -1, -1, -1, -1, -1},
108     { 0,  1,  3, -1, -1, -1, -1, -1},
109     { 2,  0,  1,  4, -1, -1, -1, -1},
110     { 0,  1,  3,  4, -1, -1, -1, -1},
111     { 2,  0,  1,  4,  5, -1, -1, -1},
112     { 3,  4,  0,  1,  5,  6, -1, -1},
113     { 2,  0,  1,  4,  5,  6, -1, -1},
114     { 0,  6,  4,  5,  2,  3, -1, -1},
115     { 4,  2,  5,  0,  1,  6,  7, -1},
116     { 5,  6,  0,  1,  7,  3,  8,  4},
117     { 4,  2,  5,  0,  1,  6,  8,  7},
118 };
119
120 static const int8_t dca_channel_reorder_nolfe[][8] = {
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     { 0,  1, -1, -1, -1, -1, -1, -1},
125     { 0,  1, -1, -1, -1, -1, -1, -1},
126     { 2,  0,  1, -1, -1, -1, -1, -1},
127     { 0,  1,  2, -1, -1, -1, -1, -1},
128     { 2,  0,  1,  3, -1, -1, -1, -1},
129     { 0,  1,  2,  3, -1, -1, -1, -1},
130     { 2,  0,  1,  3,  4, -1, -1, -1},
131     { 2,  3,  0,  1,  4,  5, -1, -1},
132     { 2,  0,  1,  3,  4,  5, -1, -1},
133     { 0,  5,  3,  4,  1,  2, -1, -1},
134     { 3,  2,  4,  0,  1,  5,  6, -1},
135     { 4,  5,  0,  1,  6,  2,  7,  3},
136     { 3,  2,  4,  0,  1,  5,  7,  6},
137 };
138
139
140 #define DCA_DOLBY 101           /* FIXME */
141
142 #define DCA_CHANNEL_BITS 6
143 #define DCA_CHANNEL_MASK 0x3F
144
145 #define DCA_LFE 0x80
146
147 #define HEADER_SIZE 14
148
149 #define DCA_MAX_FRAME_SIZE 16384
150
151 /** Bit allocation */
152 typedef struct {
153     int offset;                 ///< code values offset
154     int maxbits[8];             ///< max bits in VLC
155     int wrap;                   ///< wrap for get_vlc2()
156     VLC vlc[8];                 ///< actual codes
157 } BitAlloc;
158
159 static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select
160 static BitAlloc dca_tmode;             ///< transition mode VLCs
161 static BitAlloc dca_scalefactor;       ///< scalefactor VLCs
162 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
163
164 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
165 {
166     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
167 }
168
169 typedef struct {
170     AVCodecContext *avctx;
171     /* Frame header */
172     int frame_type;             ///< type of the current frame
173     int samples_deficit;        ///< deficit sample count
174     int crc_present;            ///< crc is present in the bitstream
175     int sample_blocks;          ///< number of PCM sample blocks
176     int frame_size;             ///< primary frame byte size
177     int amode;                  ///< audio channels arrangement
178     int sample_rate;            ///< audio sampling rate
179     int bit_rate;               ///< transmission bit rate
180     int bit_rate_index;         ///< transmission bit rate index
181
182     int downmix;                ///< embedded downmix enabled
183     int dynrange;               ///< embedded dynamic range flag
184     int timestamp;              ///< embedded time stamp flag
185     int aux_data;               ///< auxiliary data flag
186     int hdcd;                   ///< source material is mastered in HDCD
187     int ext_descr;              ///< extension audio descriptor flag
188     int ext_coding;             ///< extended coding flag
189     int aspf;                   ///< audio sync word insertion flag
190     int lfe;                    ///< low frequency effects flag
191     int predictor_history;      ///< predictor history flag
192     int header_crc;             ///< header crc check bytes
193     int multirate_inter;        ///< multirate interpolator switch
194     int version;                ///< encoder software revision
195     int copy_history;           ///< copy history
196     int source_pcm_res;         ///< source pcm resolution
197     int front_sum;              ///< front sum/difference flag
198     int surround_sum;           ///< surround sum/difference flag
199     int dialog_norm;            ///< dialog normalisation parameter
200
201     /* Primary audio coding header */
202     int subframes;              ///< number of subframes
203     int total_channels;         ///< number of channels including extensions
204     int prim_channels;          ///< number of primary audio channels
205     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count
206     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband
207     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index
208     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book
209     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
210     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select
211     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
212     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment
213
214     /* Primary audio coding side information */
215     int subsubframes;           ///< number of subsubframes
216     int partial_samples;        ///< partial subsubframe samples count
217     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)
218     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs
219     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index
220     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)
221     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)
222     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook
223     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
224     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients
225     int dynrange_coef;                                           ///< dynamic range coefficient
226
227     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands
228
229     float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
230                    2 /*history */ ];    ///< Low frequency effect data
231     int lfe_scale_factor;
232
233     /* Subband samples history (for ADPCM) */
234     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
235     DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
236     DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
237     int hist_index[DCA_PRIM_CHANNELS_MAX];
238     DECLARE_ALIGNED(16, float, raXin)[32];
239
240     int output;                 ///< type of output
241     float add_bias;             ///< output bias
242     float scale_bias;           ///< output scale
243
244     DECLARE_ALIGNED(16, float, samples)[1536];  /* 6 * 256 = 1536, might only need 5 */
245     const float *samples_chanptr[6];
246
247     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
248     int dca_buffer_size;        ///< how much data is in the dca_buffer
249
250     const int8_t* channel_order_tab;                             ///< channel reordering table, lfe and non lfe
251     GetBitContext gb;
252     /* Current position in DCA frame */
253     int current_subframe;
254     int current_subsubframe;
255
256     int debug_flag;             ///< used for suppressing repeated error messages output
257     DSPContext dsp;
258     FFTContext imdct;
259     SynthFilterContext synth;
260     DCADSPContext dcadsp;
261 } DCAContext;
262
263 static const uint16_t dca_vlc_offs[] = {
264         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
265      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
266      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
267      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
268     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
269     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
270 };
271
272 static av_cold void dca_init_vlcs(void)
273 {
274     static int vlcs_initialized = 0;
275     int i, j, c = 14;
276     static VLC_TYPE dca_table[23622][2];
277
278     if (vlcs_initialized)
279         return;
280
281     dca_bitalloc_index.offset = 1;
282     dca_bitalloc_index.wrap = 2;
283     for (i = 0; i < 5; i++) {
284         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
285         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
286         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
287                  bitalloc_12_bits[i], 1, 1,
288                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
289     }
290     dca_scalefactor.offset = -64;
291     dca_scalefactor.wrap = 2;
292     for (i = 0; i < 5; i++) {
293         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
294         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
295         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
296                  scales_bits[i], 1, 1,
297                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
298     }
299     dca_tmode.offset = 0;
300     dca_tmode.wrap = 1;
301     for (i = 0; i < 4; i++) {
302         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
303         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
304         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
305                  tmode_bits[i], 1, 1,
306                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
307     }
308
309     for(i = 0; i < 10; i++)
310         for(j = 0; j < 7; j++){
311             if(!bitalloc_codes[i][j]) break;
312             dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
313             dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
314             dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
315             dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
316             init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
317                      bitalloc_sizes[i],
318                      bitalloc_bits[i][j], 1, 1,
319                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
320             c++;
321         }
322     vlcs_initialized = 1;
323 }
324
325 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
326 {
327     while(len--)
328         *dst++ = get_bits(gb, bits);
329 }
330
331 static int dca_parse_frame_header(DCAContext * s)
332 {
333     int i, j;
334     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
335     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
336     static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
337
338     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
339
340     /* Sync code */
341     get_bits(&s->gb, 32);
342
343     /* Frame header */
344     s->frame_type        = get_bits(&s->gb, 1);
345     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
346     s->crc_present       = get_bits(&s->gb, 1);
347     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
348     s->frame_size        = get_bits(&s->gb, 14) + 1;
349     if (s->frame_size < 95)
350         return -1;
351     s->amode             = get_bits(&s->gb, 6);
352     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
353     if (!s->sample_rate)
354         return -1;
355     s->bit_rate_index    = get_bits(&s->gb, 5);
356     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
357     if (!s->bit_rate)
358         return -1;
359
360     s->downmix           = get_bits(&s->gb, 1);
361     s->dynrange          = get_bits(&s->gb, 1);
362     s->timestamp         = get_bits(&s->gb, 1);
363     s->aux_data          = get_bits(&s->gb, 1);
364     s->hdcd              = get_bits(&s->gb, 1);
365     s->ext_descr         = get_bits(&s->gb, 3);
366     s->ext_coding        = get_bits(&s->gb, 1);
367     s->aspf              = get_bits(&s->gb, 1);
368     s->lfe               = get_bits(&s->gb, 2);
369     s->predictor_history = get_bits(&s->gb, 1);
370
371     /* TODO: check CRC */
372     if (s->crc_present)
373         s->header_crc    = get_bits(&s->gb, 16);
374
375     s->multirate_inter   = get_bits(&s->gb, 1);
376     s->version           = get_bits(&s->gb, 4);
377     s->copy_history      = get_bits(&s->gb, 2);
378     s->source_pcm_res    = get_bits(&s->gb, 3);
379     s->front_sum         = get_bits(&s->gb, 1);
380     s->surround_sum      = get_bits(&s->gb, 1);
381     s->dialog_norm       = get_bits(&s->gb, 4);
382
383     /* FIXME: channels mixing levels */
384     s->output = s->amode;
385     if(s->lfe) s->output |= DCA_LFE;
386
387 #ifdef TRACE
388     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
389     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
390     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
391     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
392            s->sample_blocks, s->sample_blocks * 32);
393     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
394     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
395            s->amode, dca_channels[s->amode]);
396     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
397            s->sample_rate);
398     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
399            s->bit_rate);
400     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
401     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
402     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
403     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
404     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
405     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
406     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
407     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
408     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
409     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
410            s->predictor_history);
411     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
412     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
413            s->multirate_inter);
414     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
415     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
416     av_log(s->avctx, AV_LOG_DEBUG,
417            "source pcm resolution: %i (%i bits/sample)\n",
418            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
419     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
420     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
421     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
422     av_log(s->avctx, AV_LOG_DEBUG, "\n");
423 #endif
424
425     /* Primary audio coding header */
426     s->subframes         = get_bits(&s->gb, 4) + 1;
427     s->total_channels    = get_bits(&s->gb, 3) + 1;
428     s->prim_channels     = s->total_channels;
429     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
430         s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */
431
432
433     for (i = 0; i < s->prim_channels; i++) {
434         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
435         if (s->subband_activity[i] > DCA_SUBBANDS)
436             s->subband_activity[i] = DCA_SUBBANDS;
437     }
438     for (i = 0; i < s->prim_channels; i++) {
439         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
440         if (s->vq_start_subband[i] > DCA_SUBBANDS)
441             s->vq_start_subband[i] = DCA_SUBBANDS;
442     }
443     get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);
444     get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);
445     get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
446     get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);
447
448     /* Get codebooks quantization indexes */
449     memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
450     for (j = 1; j < 11; j++)
451         for (i = 0; i < s->prim_channels; i++)
452             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
453
454     /* Get scale factor adjustment */
455     for (j = 0; j < 11; j++)
456         for (i = 0; i < s->prim_channels; i++)
457             s->scalefactor_adj[i][j] = 1;
458
459     for (j = 1; j < 11; j++)
460         for (i = 0; i < s->prim_channels; i++)
461             if (s->quant_index_huffman[i][j] < thr[j])
462                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
463
464     if (s->crc_present) {
465         /* Audio header CRC check */
466         get_bits(&s->gb, 16);
467     }
468
469     s->current_subframe = 0;
470     s->current_subsubframe = 0;
471
472 #ifdef TRACE
473     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
474     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
475     for(i = 0; i < s->prim_channels; i++){
476         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
477         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
478         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
479         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
480         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
481         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
482         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
483         for (j = 0; j < 11; j++)
484             av_log(s->avctx, AV_LOG_DEBUG, " %i",
485                    s->quant_index_huffman[i][j]);
486         av_log(s->avctx, AV_LOG_DEBUG, "\n");
487         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
488         for (j = 0; j < 11; j++)
489             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
490         av_log(s->avctx, AV_LOG_DEBUG, "\n");
491     }
492 #endif
493
494     return 0;
495 }
496
497
498 static inline int get_scale(GetBitContext *gb, int level, int value)
499 {
500    if (level < 5) {
501        /* huffman encoded */
502        value += get_bitalloc(gb, &dca_scalefactor, level);
503    } else if(level < 8)
504        value = get_bits(gb, level + 1);
505    return value;
506 }
507
508 static int dca_subframe_header(DCAContext * s)
509 {
510     /* Primary audio coding side information */
511     int j, k;
512
513     s->subsubframes = get_bits(&s->gb, 2) + 1;
514     s->partial_samples = get_bits(&s->gb, 3);
515     for (j = 0; j < s->prim_channels; j++) {
516         for (k = 0; k < s->subband_activity[j]; k++)
517             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
518     }
519
520     /* Get prediction codebook */
521     for (j = 0; j < s->prim_channels; j++) {
522         for (k = 0; k < s->subband_activity[j]; k++) {
523             if (s->prediction_mode[j][k] > 0) {
524                 /* (Prediction coefficient VQ address) */
525                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
526             }
527         }
528     }
529
530     /* Bit allocation index */
531     for (j = 0; j < s->prim_channels; j++) {
532         for (k = 0; k < s->vq_start_subband[j]; k++) {
533             if (s->bitalloc_huffman[j] == 6)
534                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
535             else if (s->bitalloc_huffman[j] == 5)
536                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
537             else if (s->bitalloc_huffman[j] == 7) {
538                 av_log(s->avctx, AV_LOG_ERROR,
539                        "Invalid bit allocation index\n");
540                 return -1;
541             } else {
542                 s->bitalloc[j][k] =
543                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
544             }
545
546             if (s->bitalloc[j][k] > 26) {
547 //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
548 //                          j, k, s->bitalloc[j][k]);
549                 return -1;
550             }
551         }
552     }
553
554     /* Transition mode */
555     for (j = 0; j < s->prim_channels; j++) {
556         for (k = 0; k < s->subband_activity[j]; k++) {
557             s->transition_mode[j][k] = 0;
558             if (s->subsubframes > 1 &&
559                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
560                 s->transition_mode[j][k] =
561                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
562             }
563         }
564     }
565
566     for (j = 0; j < s->prim_channels; j++) {
567         const uint32_t *scale_table;
568         int scale_sum;
569
570         memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
571
572         if (s->scalefactor_huffman[j] == 6)
573             scale_table = scale_factor_quant7;
574         else
575             scale_table = scale_factor_quant6;
576
577         /* When huffman coded, only the difference is encoded */
578         scale_sum = 0;
579
580         for (k = 0; k < s->subband_activity[j]; k++) {
581             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
582                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
583                 s->scale_factor[j][k][0] = scale_table[scale_sum];
584             }
585
586             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
587                 /* Get second scale factor */
588                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
589                 s->scale_factor[j][k][1] = scale_table[scale_sum];
590             }
591         }
592     }
593
594     /* Joint subband scale factor codebook select */
595     for (j = 0; j < s->prim_channels; j++) {
596         /* Transmitted only if joint subband coding enabled */
597         if (s->joint_intensity[j] > 0)
598             s->joint_huff[j] = get_bits(&s->gb, 3);
599     }
600
601     /* Scale factors for joint subband coding */
602     for (j = 0; j < s->prim_channels; j++) {
603         int source_channel;
604
605         /* Transmitted only if joint subband coding enabled */
606         if (s->joint_intensity[j] > 0) {
607             int scale = 0;
608             source_channel = s->joint_intensity[j] - 1;
609
610             /* When huffman coded, only the difference is encoded
611              * (is this valid as well for joint scales ???) */
612
613             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
614                 scale = get_scale(&s->gb, s->joint_huff[j], 0);
615                 scale += 64;    /* bias */
616                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
617             }
618
619             if (!(s->debug_flag & 0x02)) {
620                 av_log(s->avctx, AV_LOG_DEBUG,
621                        "Joint stereo coding not supported\n");
622                 s->debug_flag |= 0x02;
623             }
624         }
625     }
626
627     /* Stereo downmix coefficients */
628     if (s->prim_channels > 2) {
629         if(s->downmix) {
630             for (j = 0; j < s->prim_channels; j++) {
631                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
632                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
633             }
634         } else {
635             int am = s->amode & DCA_CHANNEL_MASK;
636             for (j = 0; j < s->prim_channels; j++) {
637                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
638                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
639             }
640         }
641     }
642
643     /* Dynamic range coefficient */
644     if (s->dynrange)
645         s->dynrange_coef = get_bits(&s->gb, 8);
646
647     /* Side information CRC check word */
648     if (s->crc_present) {
649         get_bits(&s->gb, 16);
650     }
651
652     /*
653      * Primary audio data arrays
654      */
655
656     /* VQ encoded high frequency subbands */
657     for (j = 0; j < s->prim_channels; j++)
658         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
659             /* 1 vector -> 32 samples */
660             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
661
662     /* Low frequency effect data */
663     if (s->lfe) {
664         /* LFE samples */
665         int lfe_samples = 2 * s->lfe * s->subsubframes;
666         float lfe_scale;
667
668         for (j = lfe_samples; j < lfe_samples * 2; j++) {
669             /* Signed 8 bits int */
670             s->lfe_data[j] = get_sbits(&s->gb, 8);
671         }
672
673         /* Scale factor index */
674         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
675
676         /* Quantization step size * scale factor */
677         lfe_scale = 0.035 * s->lfe_scale_factor;
678
679         for (j = lfe_samples; j < lfe_samples * 2; j++)
680             s->lfe_data[j] *= lfe_scale;
681     }
682
683 #ifdef TRACE
684     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
685     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
686            s->partial_samples);
687     for (j = 0; j < s->prim_channels; j++) {
688         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
689         for (k = 0; k < s->subband_activity[j]; k++)
690             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
691         av_log(s->avctx, AV_LOG_DEBUG, "\n");
692     }
693     for (j = 0; j < s->prim_channels; j++) {
694         for (k = 0; k < s->subband_activity[j]; k++)
695                 av_log(s->avctx, AV_LOG_DEBUG,
696                        "prediction coefs: %f, %f, %f, %f\n",
697                        (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
698                        (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
699                        (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
700                        (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
701     }
702     for (j = 0; j < s->prim_channels; j++) {
703         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
704         for (k = 0; k < s->vq_start_subband[j]; k++)
705             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
706         av_log(s->avctx, AV_LOG_DEBUG, "\n");
707     }
708     for (j = 0; j < s->prim_channels; j++) {
709         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
710         for (k = 0; k < s->subband_activity[j]; k++)
711             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
712         av_log(s->avctx, AV_LOG_DEBUG, "\n");
713     }
714     for (j = 0; j < s->prim_channels; j++) {
715         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
716         for (k = 0; k < s->subband_activity[j]; k++) {
717             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
718                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
719             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
720                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
721         }
722         av_log(s->avctx, AV_LOG_DEBUG, "\n");
723     }
724     for (j = 0; j < s->prim_channels; j++) {
725         if (s->joint_intensity[j] > 0) {
726             int source_channel = s->joint_intensity[j] - 1;
727             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
728             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
729                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
730             av_log(s->avctx, AV_LOG_DEBUG, "\n");
731         }
732     }
733     if (s->prim_channels > 2 && s->downmix) {
734         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
735         for (j = 0; j < s->prim_channels; j++) {
736             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
737             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
738         }
739         av_log(s->avctx, AV_LOG_DEBUG, "\n");
740     }
741     for (j = 0; j < s->prim_channels; j++)
742         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
743             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
744     if(s->lfe){
745         int lfe_samples = 2 * s->lfe * s->subsubframes;
746         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
747         for (j = lfe_samples; j < lfe_samples * 2; j++)
748             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
749         av_log(s->avctx, AV_LOG_DEBUG, "\n");
750     }
751 #endif
752
753     return 0;
754 }
755
756 static void qmf_32_subbands(DCAContext * s, int chans,
757                             float samples_in[32][8], float *samples_out,
758                             float scale, float bias)
759 {
760     const float *prCoeff;
761     int i;
762
763     int sb_act = s->subband_activity[chans];
764     int subindex;
765
766     scale *= sqrt(1/8.0);
767
768     /* Select filter */
769     if (!s->multirate_inter)    /* Non-perfect reconstruction */
770         prCoeff = fir_32bands_nonperfect;
771     else                        /* Perfect reconstruction */
772         prCoeff = fir_32bands_perfect;
773
774     /* Reconstructed channel sample index */
775     for (subindex = 0; subindex < 8; subindex++) {
776         /* Load in one sample from each subband and clear inactive subbands */
777         for (i = 0; i < sb_act; i++){
778             uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
779             AV_WN32A(&s->raXin[i], v);
780         }
781         for (; i < 32; i++)
782             s->raXin[i] = 0.0;
783
784         s->synth.synth_filter_float(&s->imdct,
785                               s->subband_fir_hist[chans], &s->hist_index[chans],
786                               s->subband_fir_noidea[chans], prCoeff,
787                               samples_out, s->raXin, scale, bias);
788         samples_out+= 32;
789
790     }
791 }
792
793 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
794                                   int num_deci_sample, float *samples_in,
795                                   float *samples_out, float scale,
796                                   float bias)
797 {
798     /* samples_in: An array holding decimated samples.
799      *   Samples in current subframe starts from samples_in[0],
800      *   while samples_in[-1], samples_in[-2], ..., stores samples
801      *   from last subframe as history.
802      *
803      * samples_out: An array holding interpolated samples
804      */
805
806     int decifactor;
807     const float *prCoeff;
808     int deciindex;
809
810     /* Select decimation filter */
811     if (decimation_select == 1) {
812         decifactor = 64;
813         prCoeff = lfe_fir_128;
814     } else {
815         decifactor = 32;
816         prCoeff = lfe_fir_64;
817     }
818     /* Interpolation */
819     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
820         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
821                           scale, bias);
822         samples_in++;
823         samples_out += 2 * decifactor;
824     }
825 }
826
827 /* downmixing routines */
828 #define MIX_REAR1(samples, si1, rs, coef) \
829      samples[i]     += samples[si1] * coef[rs][0]; \
830      samples[i+256] += samples[si1] * coef[rs][1];
831
832 #define MIX_REAR2(samples, si1, si2, rs, coef) \
833      samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
834      samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
835
836 #define MIX_FRONT3(samples, coef) \
837     t = samples[i]; \
838     samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
839     samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
840
841 #define DOWNMIX_TO_STEREO(op1, op2) \
842     for(i = 0; i < 256; i++){ \
843         op1 \
844         op2 \
845     }
846
847 static void dca_downmix(float *samples, int srcfmt,
848                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
849 {
850     int i;
851     float t;
852     float coef[DCA_PRIM_CHANNELS_MAX][2];
853
854     for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
855         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
856         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
857     }
858
859     switch (srcfmt) {
860     case DCA_MONO:
861     case DCA_CHANNEL:
862     case DCA_STEREO_TOTAL:
863     case DCA_STEREO_SUMDIFF:
864     case DCA_4F2R:
865         av_log(NULL, 0, "Not implemented!\n");
866         break;
867     case DCA_STEREO:
868         break;
869     case DCA_3F:
870         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
871         break;
872     case DCA_2F1R:
873         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
874         break;
875     case DCA_3F1R:
876         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
877                           MIX_REAR1(samples, i + 768, 3, coef));
878         break;
879     case DCA_2F2R:
880         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
881         break;
882     case DCA_3F2R:
883         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
884                           MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
885         break;
886     }
887 }
888
889
890 /* Very compact version of the block code decoder that does not use table
891  * look-up but is slightly slower */
892 static int decode_blockcode(int code, int levels, int *values)
893 {
894     int i;
895     int offset = (levels - 1) >> 1;
896
897     for (i = 0; i < 4; i++) {
898         int div = FASTDIV(code, levels);
899         values[i] = code - offset - div*levels;
900         code = div;
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, 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     ff_dcadsp_init(&s->dcadsp);
1304
1305     for(i = 0; i < 6; i++)
1306         s->samples_chanptr[i] = s->samples + i * 256;
1307     avctx->sample_fmt = SAMPLE_FMT_S16;
1308
1309     if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1310         s->add_bias = 385.0f;
1311         s->scale_bias = 1.0 / 32768.0;
1312     } else {
1313         s->add_bias = 0.0f;
1314         s->scale_bias = 1.0;
1315
1316         /* allow downmixing to stereo */
1317         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1318                 avctx->request_channels == 2) {
1319             avctx->channels = avctx->request_channels;
1320         }
1321     }
1322
1323
1324     return 0;
1325 }
1326
1327 static av_cold int dca_decode_end(AVCodecContext * avctx)
1328 {
1329     DCAContext *s = avctx->priv_data;
1330     ff_mdct_end(&s->imdct);
1331     return 0;
1332 }
1333
1334 AVCodec dca_decoder = {
1335     .name = "dca",
1336     .type = AVMEDIA_TYPE_AUDIO,
1337     .id = CODEC_ID_DTS,
1338     .priv_data_size = sizeof(DCAContext),
1339     .init = dca_decode_init,
1340     .decode = dca_decode_frame,
1341     .close = dca_decode_end,
1342     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1343 };