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