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