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