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
8 * This file is part of FFmpeg.
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.
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.
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
35 #include "bitstream.h"
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)
62 #define DCA_DOLBY 101 /* FIXME */
64 #define DCA_CHANNEL_BITS 6
65 #define DCA_CHANNEL_MASK 0x3F
69 #define HEADER_SIZE 14
70 #define CONVERT_BIAS 384
72 #define DCA_MAX_FRAME_SIZE 16383
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
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
87 /** Pre-calculated cosine modulation coefs for the QMF */
88 static float cos_mod
[544];
90 static av_always_inline
int get_bitalloc(GetBitContext
*gb
, BitAlloc
*ba
, int idx
)
92 return get_vlc2(gb
, ba
->vlc
[idx
].table
, ba
->vlc
[idx
].bits
, ba
->wrap
) + ba
->offset
;
96 AVCodecContext
*avctx
;
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
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
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
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
151 int high_freq_vq
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< VQ encoded high frequency subbands
153 float lfe_data
[2 * DCA_SUBSUBFAMES_MAX
* DCA_LFE_MAX
*
154 2 /*history */ ]; ///< Low frequency effect data
155 int lfe_scale_factor
;
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];
162 int output
; ///< type of output
163 int bias
; ///< output bias
165 DECLARE_ALIGNED_16(float, samples
[1536]); /* 6 * 256 = 1536, might only need 5 */
166 DECLARE_ALIGNED_16(int16_t, tsamples
[1536]);
168 uint8_t dca_buffer
[DCA_MAX_FRAME_SIZE
];
169 int dca_buffer_size
; ///< how much data is in the dca_buffer
172 /* Current position in DCA frame */
173 int current_subframe
;
174 int current_subsubframe
;
176 int debug_flag
; ///< used for suppressing repeated error messages output
180 static void dca_init_vlcs(void)
182 static int vlcs_inited
= 0;
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;
202 for (i
= 0; i
< 4; i
++)
203 init_vlc(&dca_tmode
.vlc
[i
], tmode_vlc_bits
[i
], 4,
205 tmode_codes
[i
], 2, 2, 1);
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
],
214 bitalloc_bits
[i
][j
], 1, 1,
215 bitalloc_codes
[i
][j
], 2, 2, 1);
220 static inline void get_array(GetBitContext
*gb
, int *dst
, int len
, int bits
)
223 *dst
++ = get_bits(gb
, bits
);
226 static int dca_parse_frame_header(DCAContext
* s
)
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 };
233 s
->bias
= CONVERT_BIAS
;
235 init_get_bits(&s
->gb
, s
->dca_buffer
, s
->dca_buffer_size
* 8);
238 get_bits(&s
->gb
, 32);
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)
248 s
->amode
= get_bits(&s
->gb
, 6);
249 s
->sample_rate
= dca_sample_rates
[get_bits(&s
->gb
, 4)];
252 s
->bit_rate
= dca_bit_rates
[get_bits(&s
->gb
, 5)];
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);
267 /* TODO: check CRC */
269 s
->header_crc
= get_bits(&s
->gb
, 16);
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);
279 /* FIXME: channels mixing levels */
280 s
->output
= s
->amode
;
281 if(s
->lfe
) s
->output
|= DCA_LFE
;
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",
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");
321 /* Primary audio coding header */
322 s
->subframes
= get_bits(&s
->gb
, 4) + 1;
323 s
->prim_channels
= get_bits(&s
->gb
, 3) + 1;
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
;
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
;
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);
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
]);
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;
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)];
357 if (s
->crc_present
) {
358 /* Audio header CRC check */
359 get_bits(&s
->gb
, 16);
362 s
->current_subframe
= 0;
363 s
->current_subsubframe
= 0;
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");
391 static inline int get_scale(GetBitContext
*gb
, int level
, int value
)
394 /* huffman encoded */
395 value
+= get_bitalloc(gb
, &dca_scalefactor
, level
);
397 value
= get_bits(gb
, level
+ 1);
401 static int dca_subframe_header(DCAContext
* s
)
403 /* Primary audio coding side information */
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);
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);
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);
432 get_bitalloc(&s
->gb
, &dca_bitalloc_index
, s
->bitalloc_huffman
[j
]);
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]);
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
]);
455 for (j
= 0; j
< s
->prim_channels
; j
++) {
456 uint32_t *scale_table
;
459 memset(s
->scale_factor
[j
], 0, s
->subband_activity
[j
] * sizeof(s
->scale_factor
[0][0][0]) * 2);
461 if (s
->scalefactor_huffman
[j
] == 6)
462 scale_table
= (uint32_t *) scale_factor_quant7
;
464 scale_table
= (uint32_t *) scale_factor_quant6
;
466 /* When huffman coded, only the difference is encoded */
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
];
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
];
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);
490 /* Scale factors for joint subband coding */
491 for (j
= 0; j
< s
->prim_channels
; j
++) {
494 /* Transmitted only if joint subband coding enabled */
495 if (s
->joint_intensity
[j
] > 0) {
497 source_channel
= s
->joint_intensity
[j
] - 1;
499 /* When huffman coded, only the difference is encoded
500 * (is this valid as well for joint scales ???) */
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]; */
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;
516 /* Stereo downmix coefficients */
517 if (s
->prim_channels
> 2) {
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);
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];
532 /* Dynamic range coefficient */
534 s
->dynrange_coef
= get_bits(&s
->gb
, 8);
536 /* Side information CRC check word */
537 if (s
->crc_present
) {
538 get_bits(&s
->gb
, 16);
542 * Primary audio data arrays
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);
551 /* Low frequency effect data */
554 int lfe_samples
= 2 * s
->lfe
* s
->subsubframes
;
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);
562 /* Scale factor index */
563 s
->lfe_scale_factor
= scale_factor_quant7
[get_bits(&s
->gb
, 8)];
565 /* Quantization step size * scale factor */
566 lfe_scale
= 0.035 * s
->lfe_scale_factor
;
568 for (j
= lfe_samples
; j
< lfe_samples
* 2; j
++)
569 s
->lfe_data
[j
] *= lfe_scale
;
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",
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");
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);
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");
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");
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]);
611 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
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");
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]]);
628 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
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
]);
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");
645 static void qmf_32_subbands(DCAContext
* s
, int chans
,
646 float samples_in
[32][8], float *samples_out
,
647 float scale
, float bias
)
649 const float *prCoeff
;
651 float praXin
[33], *raXin
= &praXin
[1];
653 float *subband_fir_hist
= s
->subband_fir_hist
[chans
];
654 float *subband_fir_hist2
= s
->subband_fir_noidea
[chans
];
656 int chindex
= 0, subindex
;
661 if (!s
->multirate_inter
) /* Non-perfect reconstruction */
662 prCoeff
= fir_32bands_nonperfect
;
663 else /* Perfect reconstruction */
664 prCoeff
= fir_32bands_perfect
;
666 /* Reconstructed channel sample index */
667 for (subindex
= 0; subindex
< 8; subindex
++) {
668 float t1
, t2
, sum
[16], diff
[16];
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
];
676 /* Multiply by cosine modulation coefficients and
677 * create temporary arrays SUM and DIFF */
678 for (j
= 0, k
= 0; k
< 16; k
++) {
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];
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
];
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
]);
703 /* Create 32 PCM output samples */
704 for (i
= 0; i
< 32; i
++)
705 samples_out
[chindex
++] = subband_fir_hist2
[i
] * scale
+ bias
;
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));
714 static void lfe_interpolation_fir(int decimation_select
,
715 int num_deci_sample
, float *samples_in
,
716 float *samples_out
, float scale
,
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.
724 * samples_out: An array holding interpolated samples
727 int decifactor
, k
, j
;
728 const float *prCoeff
;
730 int interp_index
= 0; /* Index to the interpolated samples */
733 /* Select decimation filter */
734 if (decimation_select
== 1) {
736 prCoeff
= lfe_fir_128
;
739 prCoeff
= lfe_fir_64
;
742 for (deciindex
= 0; deciindex
< num_deci_sample
; deciindex
++) {
743 /* One decimated sample generates decifactor interpolated ones */
744 for (k
= 0; k
< decifactor
; k
++) {
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
;
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];
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];
763 #define MIX_FRONT3(samples, coef) \
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];
768 #define DOWNMIX_TO_STEREO(op1, op2) \
769 for(i = 0; i < 256; i++){ \
774 static void dca_downmix(float *samples
, int srcfmt
,
775 int downmix_coef
[DCA_PRIM_CHANNELS_MAX
][2])
779 float coef
[DCA_PRIM_CHANNELS_MAX
][2];
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]];
789 case DCA_STEREO_TOTAL
:
790 case DCA_STEREO_SUMDIFF
:
792 av_log(NULL
, 0, "Not implemented!\n");
797 DOWNMIX_TO_STEREO(MIX_FRONT3(samples
, coef
),);
800 DOWNMIX_TO_STEREO(MIX_REAR1(samples
, i
+ 512, 2, coef
),);
803 DOWNMIX_TO_STEREO(MIX_FRONT3(samples
, coef
),
804 MIX_REAR1(samples
, i
+ 768, 3, coef
));
807 DOWNMIX_TO_STEREO(MIX_REAR2(samples
, i
+ 512, i
+ 768, 2, coef
),);
810 DOWNMIX_TO_STEREO(MIX_FRONT3(samples
, coef
),
811 MIX_REAR2(samples
, i
+ 768, i
+ 1024, 3, coef
));
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
)
822 int offset
= (levels
- 1) >> 1;
824 for (i
= 0; i
< 4; i
++) {
825 values
[i
] = (code
% levels
) - offset
;
832 av_log(NULL
, AV_LOG_ERROR
, "ERROR: block code look-up failed\n");
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 };
840 static int dca_subsubframe(DCAContext
* s
)
843 int subsubframe
= s
->current_subsubframe
;
845 float *quant_step_table
;
848 float subband_samples
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
][8];
854 /* Select quantization step size table */
855 if (s
->bit_rate
== 0x1f)
856 quant_step_table
= (float *) lossless_quant_d
;
858 quant_step_table
= (float *) lossy_quant_d
;
860 for (k
= 0; k
< s
->prim_channels
; k
++) {
861 for (l
= 0; l
< s
->vq_start_subband
[k
]; l
++) {
864 /* Select the mid-tread linear quantizer */
865 int abits
= s
->bitalloc
[k
][l
];
867 float quant_step_size
= quant_step_table
[abits
];
871 * Determine quantization index code book and its type
874 /* Select quantization index code book */
875 int sel
= s
->quant_index_huffman
[k
][abits
];
878 * Extract bits from the bit stream
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
){
885 int block_code1
, block_code2
, size
, levels
;
888 size
= abits_sizes
[abits
-1];
889 levels
= abits_levels
[abits
-1];
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
];
900 for (m
= 0; m
< 8; m
++)
901 subband_samples
[k
][l
][m
] = get_sbits(&s
->gb
, abits
- 3);
905 for (m
= 0; m
< 8; m
++)
906 subband_samples
[k
][l
][m
] = get_bitalloc(&s
->gb
, &dca_smpl_bitalloc
[abits
], sel
);
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];
914 rscale
= quant_step_size
* s
->scale_factor
[k
][l
][0];
916 rscale
*= s
->scalefactor_adj
[k
][sel
];
918 for (m
= 0; m
< 8; m
++)
919 subband_samples
[k
][l
][m
] *= rscale
;
922 * Inverse ADPCM if in prediction mode
924 if (s
->prediction_mode
[k
][l
]) {
926 for (m
= 0; m
< 8; m
++) {
927 for (n
= 1; n
<= 4; 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
+
942 * Decode VQ encoded high frequencies
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. */
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;
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 +
958 * (float) s
->scale_factor
[k
][l
][0] / 16.0;
963 /* Check for DSYNC after subsubframe */
964 if (s
->aspf
|| subsubframe
== s
->subsubframes
- 1) {
965 if (0xFFFF == get_bits(&s
->gb
, 16)) { /* 0xFFFF */
967 av_log(s
->avctx
, AV_LOG_DEBUG
, "Got subframe DSYNC\n");
970 av_log(s
->avctx
, AV_LOG_ERROR
, "Didn't get subframe DSYNC\n");
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]));
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] */ ,
991 if (s
->prim_channels
> dca_channels
[s
->output
& DCA_CHANNEL_MASK
]) {
992 dca_downmix(s
->samples
, s
->amode
, s
->downmix_coef
);
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
];
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 */
1012 static int dca_subframe_footer(DCAContext
* s
)
1014 int aux_data_count
= 0, i
;
1018 * Unpack optional information
1022 get_bits(&s
->gb
, 32);
1025 aux_data_count
= get_bits(&s
->gb
, 6);
1027 for (i
= 0; i
< aux_data_count
; i
++)
1028 get_bits(&s
->gb
, 8);
1030 if (s
->crc_present
&& (s
->downmix
|| s
->dynrange
))
1031 get_bits(&s
->gb
, 16);
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
];
1042 * Decode a dca frame block
1044 * @param s pointer to the DCAContext
1047 static int dca_decode_block(DCAContext
* s
)
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
);
1057 if (!s
->current_subsubframe
) {
1059 av_log(s
->avctx
, AV_LOG_DEBUG
, "DSYNC dca_subframe_header\n");
1061 /* Read subframe header */
1062 if (dca_subframe_header(s
))
1066 /* Read subsubframe */
1068 av_log(s
->avctx
, AV_LOG_DEBUG
, "DSYNC dca_subsubframe\n");
1070 if (dca_subsubframe(s
))
1074 s
->current_subsubframe
++;
1075 if (s
->current_subsubframe
>= s
->subsubframes
) {
1076 s
->current_subsubframe
= 0;
1077 s
->current_subframe
++;
1079 if (s
->current_subframe
>= s
->subframes
) {
1081 av_log(s
->avctx
, AV_LOG_DEBUG
, "DSYNC dca_subframe_footer\n");
1083 /* Read subframe footer */
1084 if (dca_subframe_footer(s
))
1092 * Convert bitstream to one representation based on sync marker
1094 static int dca_convert_bitstream(uint8_t * src
, int src_size
, uint8_t * dst
,
1099 uint16_t *ssrc
= (uint16_t *) src
, *sdst
= (uint16_t *) dst
;
1102 if((unsigned)src_size
> (unsigned)max_size
) {
1103 av_log(NULL
, AV_LOG_ERROR
, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1109 case DCA_MARKER_RAW_BE
:
1110 memcpy(dst
, src
, FFMIN(src_size
, max_size
));
1111 return FFMIN(src_size
, max_size
);
1112 case DCA_MARKER_RAW_LE
:
1113 for (i
= 0; i
< (FFMIN(src_size
, max_size
) + 1) >> 1; i
++)
1114 *sdst
++ = bswap_16(*ssrc
++);
1115 return FFMIN(src_size
, max_size
);
1116 case DCA_MARKER_14B_BE
:
1117 case DCA_MARKER_14B_LE
:
1118 init_put_bits(&pb
, dst
, max_size
);
1119 for (i
= 0; i
< (src_size
+ 1) >> 1; i
++, src
+= 2) {
1120 tmp
= ((mrk
== DCA_MARKER_14B_BE
) ? AV_RB16(src
) : AV_RL16(src
)) & 0x3FFF;
1121 put_bits(&pb
, 14, tmp
);
1123 flush_put_bits(&pb
);
1124 return (put_bits_count(&pb
) + 7) >> 3;
1131 * Main frame decoding function
1132 * FIXME add arguments
1134 static int dca_decode_frame(AVCodecContext
* avctx
,
1135 void *data
, int *data_size
,
1136 uint8_t * buf
, int buf_size
)
1140 int16_t *samples
= data
;
1141 DCAContext
*s
= avctx
->priv_data
;
1145 s
->dca_buffer_size
= dca_convert_bitstream(buf
, buf_size
, s
->dca_buffer
, DCA_MAX_FRAME_SIZE
);
1146 if (s
->dca_buffer_size
== -1) {
1147 av_log(avctx
, AV_LOG_ERROR
, "Not a valid DCA frame\n");
1151 init_get_bits(&s
->gb
, s
->dca_buffer
, s
->dca_buffer_size
* 8);
1152 if (dca_parse_frame_header(s
) < 0) {
1153 //seems like the frame is corrupt, try with the next one
1157 //set AVCodec values with parsed data
1158 avctx
->sample_rate
= s
->sample_rate
;
1159 avctx
->bit_rate
= s
->bit_rate
;
1161 channels
= s
->prim_channels
+ !!s
->lfe
;
1162 if(avctx
->request_channels
== 2 && s
->prim_channels
> 2) {
1164 s
->output
= DCA_STEREO
;
1167 avctx
->channels
= channels
;
1168 if(*data_size
< (s
->sample_blocks
/ 8) * 256 * sizeof(int16_t) * channels
)
1171 for (i
= 0; i
< (s
->sample_blocks
/ 8); i
++) {
1172 dca_decode_block(s
);
1173 s
->dsp
.float_to_int16(s
->tsamples
, s
->samples
, 256 * channels
);
1174 /* interleave samples */
1175 for (j
= 0; j
< 256; j
++) {
1176 for (k
= 0; k
< channels
; k
++)
1177 samples
[k
] = s
->tsamples
[j
+ k
* 256];
1178 samples
+= channels
;
1180 *data_size
+= 256 * sizeof(int16_t) * channels
;
1189 * Build the cosine modulation tables for the QMF
1191 * @param s pointer to the DCAContext
1194 static void pre_calc_cosmod(DCAContext
* s
)
1197 static int cosmod_inited
= 0;
1199 if(cosmod_inited
) return;
1200 for (j
= 0, k
= 0; k
< 16; k
++)
1201 for (i
= 0; i
< 16; i
++)
1202 cos_mod
[j
++] = cos((2 * i
+ 1) * (2 * k
+ 1) * M_PI
/ 64);
1204 for (k
= 0; k
< 16; k
++)
1205 for (i
= 0; i
< 16; i
++)
1206 cos_mod
[j
++] = cos((i
) * (2 * k
+ 1) * M_PI
/ 32);
1208 for (k
= 0; k
< 16; k
++)
1209 cos_mod
[j
++] = 0.25 / (2 * cos((2 * k
+ 1) * M_PI
/ 128));
1211 for (k
= 0; k
< 16; k
++)
1212 cos_mod
[j
++] = -0.25 / (2.0 * sin((2 * k
+ 1) * M_PI
/ 128));
1219 * DCA initialization
1221 * @param avctx pointer to the AVCodecContext
1224 static int dca_decode_init(AVCodecContext
* avctx
)
1226 DCAContext
*s
= avctx
->priv_data
;
1232 dsputil_init(&s
->dsp
, avctx
);
1237 AVCodec dca_decoder
= {
1239 .type
= CODEC_TYPE_AUDIO
,
1241 .priv_data_size
= sizeof(DCAContext
),
1242 .init
= dca_decode_init
,
1243 .decode
= dca_decode_frame
,