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 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
63 * Some compromises have been made for special configurations. Most configurations
64 * are never used so complete accuracy is not needed.
66 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
67 * S -> side, when both rear and back are configured move one of them to the side channel
69 * All 2 channel configurations -> CH_LAYOUT_STEREO
72 static const int64_t dca_core_channel_layout[] = {
73 CH_FRONT_CENTER, ///< 1, A
74 CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
75 CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
76 CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
77 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
78 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
79 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
80 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
81 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
82 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
83 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
84 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
85 CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR
86 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
87 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
88 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
92 #define DCA_DOLBY 101 /* FIXME */
94 #define DCA_CHANNEL_BITS 6
95 #define DCA_CHANNEL_MASK 0x3F
99 #define HEADER_SIZE 14
101 #define DCA_MAX_FRAME_SIZE 16384
103 /** Bit allocation */
105 int offset; ///< code values offset
106 int maxbits[8]; ///< max bits in VLC
107 int wrap; ///< wrap for get_vlc2()
108 VLC vlc[8]; ///< actual codes
111 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
112 static BitAlloc dca_tmode; ///< transition mode VLCs
113 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
114 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
116 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
118 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
122 AVCodecContext *avctx;
124 int frame_type; ///< type of the current frame
125 int samples_deficit; ///< deficit sample count
126 int crc_present; ///< crc is present in the bitstream
127 int sample_blocks; ///< number of PCM sample blocks
128 int frame_size; ///< primary frame byte size
129 int amode; ///< audio channels arrangement
130 int sample_rate; ///< audio sampling rate
131 int bit_rate; ///< transmission bit rate
132 int bit_rate_index; ///< transmission bit rate index
134 int downmix; ///< embedded downmix enabled
135 int dynrange; ///< embedded dynamic range flag
136 int timestamp; ///< embedded time stamp flag
137 int aux_data; ///< auxiliary data flag
138 int hdcd; ///< source material is mastered in HDCD
139 int ext_descr; ///< extension audio descriptor flag
140 int ext_coding; ///< extended coding flag
141 int aspf; ///< audio sync word insertion flag
142 int lfe; ///< low frequency effects flag
143 int predictor_history; ///< predictor history flag
144 int header_crc; ///< header crc check bytes
145 int multirate_inter; ///< multirate interpolator switch
146 int version; ///< encoder software revision
147 int copy_history; ///< copy history
148 int source_pcm_res; ///< source pcm resolution
149 int front_sum; ///< front sum/difference flag
150 int surround_sum; ///< surround sum/difference flag
151 int dialog_norm; ///< dialog normalisation parameter
153 /* Primary audio coding header */
154 int subframes; ///< number of subframes
155 int total_channels; ///< number of channels including extensions
156 int prim_channels; ///< number of primary audio channels
157 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
158 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
159 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
160 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
161 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
162 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
163 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
164 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
166 /* Primary audio coding side information */
167 int subsubframes; ///< number of subsubframes
168 int partial_samples; ///< partial subsubframe samples count
169 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
170 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
171 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
172 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
173 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
174 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
175 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
176 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
177 int dynrange_coef; ///< dynamic range coefficient
179 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
181 float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
182 2 /*history */ ]; ///< Low frequency effect data
183 int lfe_scale_factor;
185 /* Subband samples history (for ADPCM) */
186 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
187 DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]);
188 float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];
189 int hist_index[DCA_PRIM_CHANNELS_MAX];
191 int output; ///< type of output
192 float add_bias; ///< output bias
193 float scale_bias; ///< output scale
195 DECLARE_ALIGNED_16(float, samples[1536]); /* 6 * 256 = 1536, might only need 5 */
196 const float *samples_chanptr[6];
198 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
199 int dca_buffer_size; ///< how much data is in the dca_buffer
202 /* Current position in DCA frame */
203 int current_subframe;
204 int current_subsubframe;
206 int debug_flag; ///< used for suppressing repeated error messages output
211 static av_cold void dca_init_vlcs(void)
213 static int vlcs_initialized = 0;
216 if (vlcs_initialized)
219 dca_bitalloc_index.offset = 1;
220 dca_bitalloc_index.wrap = 2;
221 for (i = 0; i < 5; i++)
222 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
223 bitalloc_12_bits[i], 1, 1,
224 bitalloc_12_codes[i], 2, 2, 1);
225 dca_scalefactor.offset = -64;
226 dca_scalefactor.wrap = 2;
227 for (i = 0; i < 5; i++)
228 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
229 scales_bits[i], 1, 1,
230 scales_codes[i], 2, 2, 1);
231 dca_tmode.offset = 0;
233 for (i = 0; i < 4; i++)
234 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
236 tmode_codes[i], 2, 2, 1);
238 for(i = 0; i < 10; i++)
239 for(j = 0; j < 7; j++){
240 if(!bitalloc_codes[i][j]) break;
241 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
242 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
243 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
245 bitalloc_bits[i][j], 1, 1,
246 bitalloc_codes[i][j], 2, 2, 1);
248 vlcs_initialized = 1;
251 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
254 *dst++ = get_bits(gb, bits);
257 static int dca_parse_frame_header(DCAContext * s)
260 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
261 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
262 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
264 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
267 get_bits(&s->gb, 32);
270 s->frame_type = get_bits(&s->gb, 1);
271 s->samples_deficit = get_bits(&s->gb, 5) + 1;
272 s->crc_present = get_bits(&s->gb, 1);
273 s->sample_blocks = get_bits(&s->gb, 7) + 1;
274 s->frame_size = get_bits(&s->gb, 14) + 1;
275 if (s->frame_size < 95)
277 s->amode = get_bits(&s->gb, 6);
278 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
281 s->bit_rate_index = get_bits(&s->gb, 5);
282 s->bit_rate = dca_bit_rates[s->bit_rate_index];
286 s->downmix = get_bits(&s->gb, 1);
287 s->dynrange = get_bits(&s->gb, 1);
288 s->timestamp = get_bits(&s->gb, 1);
289 s->aux_data = get_bits(&s->gb, 1);
290 s->hdcd = get_bits(&s->gb, 1);
291 s->ext_descr = get_bits(&s->gb, 3);
292 s->ext_coding = get_bits(&s->gb, 1);
293 s->aspf = get_bits(&s->gb, 1);
294 s->lfe = get_bits(&s->gb, 2);
295 s->predictor_history = get_bits(&s->gb, 1);
297 /* TODO: check CRC */
299 s->header_crc = get_bits(&s->gb, 16);
301 s->multirate_inter = get_bits(&s->gb, 1);
302 s->version = get_bits(&s->gb, 4);
303 s->copy_history = get_bits(&s->gb, 2);
304 s->source_pcm_res = get_bits(&s->gb, 3);
305 s->front_sum = get_bits(&s->gb, 1);
306 s->surround_sum = get_bits(&s->gb, 1);
307 s->dialog_norm = get_bits(&s->gb, 4);
309 /* FIXME: channels mixing levels */
310 s->output = s->amode;
311 if(s->lfe) s->output |= DCA_LFE;
314 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
315 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
316 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
317 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
318 s->sample_blocks, s->sample_blocks * 32);
319 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
320 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
321 s->amode, dca_channels[s->amode]);
322 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
324 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
326 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
327 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
328 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
329 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
330 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
331 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
332 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
333 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
334 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
335 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
336 s->predictor_history);
337 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
338 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
340 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
341 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
342 av_log(s->avctx, AV_LOG_DEBUG,
343 "source pcm resolution: %i (%i bits/sample)\n",
344 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
345 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
346 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
347 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
348 av_log(s->avctx, AV_LOG_DEBUG, "\n");
351 /* Primary audio coding header */
352 s->subframes = get_bits(&s->gb, 4) + 1;
353 s->total_channels = get_bits(&s->gb, 3) + 1;
354 s->prim_channels = s->total_channels;
355 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
356 s->prim_channels = DCA_PRIM_CHANNELS_MAX; /* We only support DTS core */
359 for (i = 0; i < s->prim_channels; i++) {
360 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
361 if (s->subband_activity[i] > DCA_SUBBANDS)
362 s->subband_activity[i] = DCA_SUBBANDS;
364 for (i = 0; i < s->prim_channels; i++) {
365 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
366 if (s->vq_start_subband[i] > DCA_SUBBANDS)
367 s->vq_start_subband[i] = DCA_SUBBANDS;
369 get_array(&s->gb, s->joint_intensity, s->prim_channels, 3);
370 get_array(&s->gb, s->transient_huffman, s->prim_channels, 2);
371 get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
372 get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3);
374 /* Get codebooks quantization indexes */
375 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
376 for (j = 1; j < 11; j++)
377 for (i = 0; i < s->prim_channels; i++)
378 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
380 /* Get scale factor adjustment */
381 for (j = 0; j < 11; j++)
382 for (i = 0; i < s->prim_channels; i++)
383 s->scalefactor_adj[i][j] = 1;
385 for (j = 1; j < 11; j++)
386 for (i = 0; i < s->prim_channels; i++)
387 if (s->quant_index_huffman[i][j] < thr[j])
388 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
390 if (s->crc_present) {
391 /* Audio header CRC check */
392 get_bits(&s->gb, 16);
395 s->current_subframe = 0;
396 s->current_subsubframe = 0;
399 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
400 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
401 for(i = 0; i < s->prim_channels; i++){
402 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
403 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
404 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
405 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
406 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
407 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
408 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
409 for (j = 0; j < 11; j++)
410 av_log(s->avctx, AV_LOG_DEBUG, " %i",
411 s->quant_index_huffman[i][j]);
412 av_log(s->avctx, AV_LOG_DEBUG, "\n");
413 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
414 for (j = 0; j < 11; j++)
415 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
416 av_log(s->avctx, AV_LOG_DEBUG, "\n");
424 static inline int get_scale(GetBitContext *gb, int level, int value)
427 /* huffman encoded */
428 value += get_bitalloc(gb, &dca_scalefactor, level);
430 value = get_bits(gb, level + 1);
434 static int dca_subframe_header(DCAContext * s)
436 /* Primary audio coding side information */
439 s->subsubframes = get_bits(&s->gb, 2) + 1;
440 s->partial_samples = get_bits(&s->gb, 3);
441 for (j = 0; j < s->prim_channels; j++) {
442 for (k = 0; k < s->subband_activity[j]; k++)
443 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
446 /* Get prediction codebook */
447 for (j = 0; j < s->prim_channels; j++) {
448 for (k = 0; k < s->subband_activity[j]; k++) {
449 if (s->prediction_mode[j][k] > 0) {
450 /* (Prediction coefficient VQ address) */
451 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
456 /* Bit allocation index */
457 for (j = 0; j < s->prim_channels; j++) {
458 for (k = 0; k < s->vq_start_subband[j]; k++) {
459 if (s->bitalloc_huffman[j] == 6)
460 s->bitalloc[j][k] = get_bits(&s->gb, 5);
461 else if (s->bitalloc_huffman[j] == 5)
462 s->bitalloc[j][k] = get_bits(&s->gb, 4);
463 else if (s->bitalloc_huffman[j] == 7) {
464 av_log(s->avctx, AV_LOG_ERROR,
465 "Invalid bit allocation index\n");
469 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
472 if (s->bitalloc[j][k] > 26) {
473 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
474 // j, k, s->bitalloc[j][k]);
480 /* Transition mode */
481 for (j = 0; j < s->prim_channels; j++) {
482 for (k = 0; k < s->subband_activity[j]; k++) {
483 s->transition_mode[j][k] = 0;
484 if (s->subsubframes > 1 &&
485 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
486 s->transition_mode[j][k] =
487 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
492 for (j = 0; j < s->prim_channels; j++) {
493 const uint32_t *scale_table;
496 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
498 if (s->scalefactor_huffman[j] == 6)
499 scale_table = scale_factor_quant7;
501 scale_table = scale_factor_quant6;
503 /* When huffman coded, only the difference is encoded */
506 for (k = 0; k < s->subband_activity[j]; k++) {
507 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
508 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
509 s->scale_factor[j][k][0] = scale_table[scale_sum];
512 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
513 /* Get second scale factor */
514 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
515 s->scale_factor[j][k][1] = scale_table[scale_sum];
520 /* Joint subband scale factor codebook select */
521 for (j = 0; j < s->prim_channels; j++) {
522 /* Transmitted only if joint subband coding enabled */
523 if (s->joint_intensity[j] > 0)
524 s->joint_huff[j] = get_bits(&s->gb, 3);
527 /* Scale factors for joint subband coding */
528 for (j = 0; j < s->prim_channels; j++) {
531 /* Transmitted only if joint subband coding enabled */
532 if (s->joint_intensity[j] > 0) {
534 source_channel = s->joint_intensity[j] - 1;
536 /* When huffman coded, only the difference is encoded
537 * (is this valid as well for joint scales ???) */
539 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
540 scale = get_scale(&s->gb, s->joint_huff[j], 0);
541 scale += 64; /* bias */
542 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
545 if (!s->debug_flag & 0x02) {
546 av_log(s->avctx, AV_LOG_DEBUG,
547 "Joint stereo coding not supported\n");
548 s->debug_flag |= 0x02;
553 /* Stereo downmix coefficients */
554 if (s->prim_channels > 2) {
556 for (j = 0; j < s->prim_channels; j++) {
557 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
558 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
561 int am = s->amode & DCA_CHANNEL_MASK;
562 for (j = 0; j < s->prim_channels; j++) {
563 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
564 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
569 /* Dynamic range coefficient */
571 s->dynrange_coef = get_bits(&s->gb, 8);
573 /* Side information CRC check word */
574 if (s->crc_present) {
575 get_bits(&s->gb, 16);
579 * Primary audio data arrays
582 /* VQ encoded high frequency subbands */
583 for (j = 0; j < s->prim_channels; j++)
584 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
585 /* 1 vector -> 32 samples */
586 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
588 /* Low frequency effect data */
591 int lfe_samples = 2 * s->lfe * s->subsubframes;
594 for (j = lfe_samples; j < lfe_samples * 2; j++) {
595 /* Signed 8 bits int */
596 s->lfe_data[j] = get_sbits(&s->gb, 8);
599 /* Scale factor index */
600 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
602 /* Quantization step size * scale factor */
603 lfe_scale = 0.035 * s->lfe_scale_factor;
605 for (j = lfe_samples; j < lfe_samples * 2; j++)
606 s->lfe_data[j] *= lfe_scale;
610 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
611 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
613 for (j = 0; j < s->prim_channels; j++) {
614 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
615 for (k = 0; k < s->subband_activity[j]; k++)
616 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
617 av_log(s->avctx, AV_LOG_DEBUG, "\n");
619 for (j = 0; j < s->prim_channels; j++) {
620 for (k = 0; k < s->subband_activity[j]; k++)
621 av_log(s->avctx, AV_LOG_DEBUG,
622 "prediction coefs: %f, %f, %f, %f\n",
623 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
624 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
625 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
626 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
628 for (j = 0; j < s->prim_channels; j++) {
629 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
630 for (k = 0; k < s->vq_start_subband[j]; k++)
631 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
632 av_log(s->avctx, AV_LOG_DEBUG, "\n");
634 for (j = 0; j < s->prim_channels; j++) {
635 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
636 for (k = 0; k < s->subband_activity[j]; k++)
637 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
638 av_log(s->avctx, AV_LOG_DEBUG, "\n");
640 for (j = 0; j < s->prim_channels; j++) {
641 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
642 for (k = 0; k < s->subband_activity[j]; k++) {
643 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
644 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
645 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
646 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
648 av_log(s->avctx, AV_LOG_DEBUG, "\n");
650 for (j = 0; j < s->prim_channels; j++) {
651 if (s->joint_intensity[j] > 0) {
652 int source_channel = s->joint_intensity[j] - 1;
653 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
654 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
655 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
656 av_log(s->avctx, AV_LOG_DEBUG, "\n");
659 if (s->prim_channels > 2 && s->downmix) {
660 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
661 for (j = 0; j < s->prim_channels; j++) {
662 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
663 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
665 av_log(s->avctx, AV_LOG_DEBUG, "\n");
667 for (j = 0; j < s->prim_channels; j++)
668 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
669 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
671 int lfe_samples = 2 * s->lfe * s->subsubframes;
672 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
673 for (j = lfe_samples; j < lfe_samples * 2; j++)
674 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
675 av_log(s->avctx, AV_LOG_DEBUG, "\n");
682 static void qmf_32_subbands(DCAContext * s, int chans,
683 float samples_in[32][8], float *samples_out,
684 float scale, float bias)
686 const float *prCoeff;
688 DECLARE_ALIGNED_16(float, raXin[32]);
690 int hist_index= s->hist_index[chans];
691 float *subband_fir_hist2 = s->subband_fir_noidea[chans];
695 scale *= sqrt(1/8.0);
698 if (!s->multirate_inter) /* Non-perfect reconstruction */
699 prCoeff = fir_32bands_nonperfect;
700 else /* Perfect reconstruction */
701 prCoeff = fir_32bands_perfect;
703 /* Reconstructed channel sample index */
704 for (subindex = 0; subindex < 8; subindex++) {
705 float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
706 /* Load in one sample from each subband and clear inactive subbands */
707 for (i = 0; i < s->subband_activity[chans]; i++){
708 if((i-1)&2) raXin[i] = -samples_in[i][subindex];
709 else raXin[i] = samples_in[i][subindex];
714 ff_imdct_half(&s->imdct, subband_fir_hist, raXin);
716 /* Multiply by filter coefficients */
717 for (i = 0; i < 16; i++){
718 float a= subband_fir_hist2[i ];
719 float b= subband_fir_hist2[i+16];
722 for (j = 0; j < 512-hist_index; j += 64){
723 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j]);
724 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j]);
725 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
726 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
728 for ( ; j < 512; j += 64){
729 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j-512]);
730 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j-512]);
731 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
732 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
734 samples_out[i ] = a * scale + bias;
735 samples_out[i+16] = b * scale + bias;
736 subband_fir_hist2[i ] = c;
737 subband_fir_hist2[i+16] = d;
741 hist_index = (hist_index-32)&511;
743 s->hist_index[chans]= hist_index;
746 static void lfe_interpolation_fir(int decimation_select,
747 int num_deci_sample, float *samples_in,
748 float *samples_out, float scale,
751 /* samples_in: An array holding decimated samples.
752 * Samples in current subframe starts from samples_in[0],
753 * while samples_in[-1], samples_in[-2], ..., stores samples
754 * from last subframe as history.
756 * samples_out: An array holding interpolated samples
759 int decifactor, k, j;
760 const float *prCoeff;
762 int interp_index = 0; /* Index to the interpolated samples */
765 /* Select decimation filter */
766 if (decimation_select == 1) {
768 prCoeff = lfe_fir_128;
771 prCoeff = lfe_fir_64;
774 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
775 /* One decimated sample generates decifactor interpolated ones */
776 for (k = 0; k < decifactor; k++) {
778 //FIXME the coeffs are symetric, fix that
779 for (j = 0; j < 512 / decifactor; j++)
780 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
781 samples_out[interp_index++] = (rTmp * scale) + bias;
786 /* downmixing routines */
787 #define MIX_REAR1(samples, si1, rs, coef) \
788 samples[i] += samples[si1] * coef[rs][0]; \
789 samples[i+256] += samples[si1] * coef[rs][1];
791 #define MIX_REAR2(samples, si1, si2, rs, coef) \
792 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
793 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
795 #define MIX_FRONT3(samples, coef) \
797 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
798 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
800 #define DOWNMIX_TO_STEREO(op1, op2) \
801 for(i = 0; i < 256; i++){ \
806 static void dca_downmix(float *samples, int srcfmt,
807 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
811 float coef[DCA_PRIM_CHANNELS_MAX][2];
813 for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
814 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
815 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
821 case DCA_STEREO_TOTAL:
822 case DCA_STEREO_SUMDIFF:
824 av_log(NULL, 0, "Not implemented!\n");
829 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
832 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
835 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
836 MIX_REAR1(samples, i + 768, 3, coef));
839 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
842 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
843 MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
849 /* Very compact version of the block code decoder that does not use table
850 * look-up but is slightly slower */
851 static int decode_blockcode(int code, int levels, int *values)
854 int offset = (levels - 1) >> 1;
856 for (i = 0; i < 4; i++) {
857 values[i] = (code % levels) - offset;
864 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
869 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
870 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
872 static int dca_subsubframe(DCAContext * s)
875 int subsubframe = s->current_subsubframe;
877 const float *quant_step_table;
880 float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
886 /* Select quantization step size table */
887 if (s->bit_rate_index == 0x1f)
888 quant_step_table = lossless_quant_d;
890 quant_step_table = lossy_quant_d;
892 for (k = 0; k < s->prim_channels; k++) {
893 for (l = 0; l < s->vq_start_subband[k]; l++) {
896 /* Select the mid-tread linear quantizer */
897 int abits = s->bitalloc[k][l];
899 float quant_step_size = quant_step_table[abits];
903 * Determine quantization index code book and its type
906 /* Select quantization index code book */
907 int sel = s->quant_index_huffman[k][abits];
910 * Extract bits from the bit stream
913 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
914 }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
917 int block_code1, block_code2, size, levels;
920 size = abits_sizes[abits-1];
921 levels = abits_levels[abits-1];
923 block_code1 = get_bits(&s->gb, size);
924 /* FIXME Should test return value */
925 decode_blockcode(block_code1, levels, block);
926 block_code2 = get_bits(&s->gb, size);
927 decode_blockcode(block_code2, levels, &block[4]);
928 for (m = 0; m < 8; m++)
929 subband_samples[k][l][m] = block[m];
932 for (m = 0; m < 8; m++)
933 subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
937 for (m = 0; m < 8; m++)
938 subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
941 /* Deal with transients */
942 if (s->transition_mode[k][l] &&
943 subsubframe >= s->transition_mode[k][l])
944 rscale = quant_step_size * s->scale_factor[k][l][1];
946 rscale = quant_step_size * s->scale_factor[k][l][0];
948 rscale *= s->scalefactor_adj[k][sel];
950 for (m = 0; m < 8; m++)
951 subband_samples[k][l][m] *= rscale;
954 * Inverse ADPCM if in prediction mode
956 if (s->prediction_mode[k][l]) {
958 for (m = 0; m < 8; m++) {
959 for (n = 1; n <= 4; n++)
961 subband_samples[k][l][m] +=
962 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
963 subband_samples[k][l][m - n] / 8192);
964 else if (s->predictor_history)
965 subband_samples[k][l][m] +=
966 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
967 s->subband_samples_hist[k][l][m - n +
974 * Decode VQ encoded high frequencies
976 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
977 /* 1 vector -> 32 samples but we only need the 8 samples
978 * for this subsubframe. */
981 if (!s->debug_flag & 0x01) {
982 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
983 s->debug_flag |= 0x01;
986 for (m = 0; m < 8; m++) {
987 subband_samples[k][l][m] =
988 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
990 * (float) s->scale_factor[k][l][0] / 16.0;
995 /* Check for DSYNC after subsubframe */
996 if (s->aspf || subsubframe == s->subsubframes - 1) {
997 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
999 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1002 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1006 /* Backup predictor history for adpcm */
1007 for (k = 0; k < s->prim_channels; k++)
1008 for (l = 0; l < s->vq_start_subband[k]; l++)
1009 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1010 4 * sizeof(subband_samples[0][0][0]));
1012 /* 32 subbands QMF */
1013 for (k = 0; k < s->prim_channels; k++) {
1014 /* static float pcm_to_double[8] =
1015 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1016 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * k],
1017 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1023 if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1024 dca_downmix(s->samples, s->amode, s->downmix_coef);
1027 /* Generate LFE samples for this subsubframe FIXME!!! */
1028 if (s->output & DCA_LFE) {
1029 int lfe_samples = 2 * s->lfe * s->subsubframes;
1030 int i_channels = dca_channels[s->output & DCA_CHANNEL_MASK];
1032 lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1033 s->lfe_data + lfe_samples +
1034 2 * s->lfe * subsubframe,
1035 &s->samples[256 * i_channels],
1036 (1.0/256.0)*s->scale_bias, s->add_bias);
1037 /* Outputs 20bits pcm samples */
1044 static int dca_subframe_footer(DCAContext * s)
1046 int aux_data_count = 0, i;
1050 * Unpack optional information
1054 get_bits(&s->gb, 32);
1057 aux_data_count = get_bits(&s->gb, 6);
1059 for (i = 0; i < aux_data_count; i++)
1060 get_bits(&s->gb, 8);
1062 if (s->crc_present && (s->downmix || s->dynrange))
1063 get_bits(&s->gb, 16);
1065 lfe_samples = 2 * s->lfe * s->subsubframes;
1066 for (i = 0; i < lfe_samples; i++) {
1067 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1074 * Decode a dca frame block
1076 * @param s pointer to the DCAContext
1079 static int dca_decode_block(DCAContext * s)
1083 if (s->current_subframe >= s->subframes) {
1084 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1085 s->current_subframe, s->subframes);
1089 if (!s->current_subsubframe) {
1091 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1093 /* Read subframe header */
1094 if (dca_subframe_header(s))
1098 /* Read subsubframe */
1100 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1102 if (dca_subsubframe(s))
1106 s->current_subsubframe++;
1107 if (s->current_subsubframe >= s->subsubframes) {
1108 s->current_subsubframe = 0;
1109 s->current_subframe++;
1111 if (s->current_subframe >= s->subframes) {
1113 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1115 /* Read subframe footer */
1116 if (dca_subframe_footer(s))
1124 * Convert bitstream to one representation based on sync marker
1126 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1131 const uint16_t *ssrc = (const uint16_t *) src;
1132 uint16_t *sdst = (uint16_t *) dst;
1135 if((unsigned)src_size > (unsigned)max_size) {
1136 av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1142 case DCA_MARKER_RAW_BE:
1143 memcpy(dst, src, src_size);
1145 case DCA_MARKER_RAW_LE:
1146 for (i = 0; i < (src_size + 1) >> 1; i++)
1147 *sdst++ = bswap_16(*ssrc++);
1149 case DCA_MARKER_14B_BE:
1150 case DCA_MARKER_14B_LE:
1151 init_put_bits(&pb, dst, max_size);
1152 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1153 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1154 put_bits(&pb, 14, tmp);
1156 flush_put_bits(&pb);
1157 return (put_bits_count(&pb) + 7) >> 3;
1164 * Main frame decoding function
1165 * FIXME add arguments
1167 static int dca_decode_frame(AVCodecContext * avctx,
1168 void *data, int *data_size,
1169 const uint8_t * buf, int buf_size)
1173 int16_t *samples = data;
1174 DCAContext *s = avctx->priv_data;
1178 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1179 if (s->dca_buffer_size == -1) {
1180 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1184 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1185 if (dca_parse_frame_header(s) < 0) {
1186 //seems like the frame is corrupt, try with the next one
1190 //set AVCodec values with parsed data
1191 avctx->sample_rate = s->sample_rate;
1192 avctx->bit_rate = s->bit_rate;
1194 channels = s->prim_channels + !!s->lfe;
1195 if(avctx->request_channels == 2 && s->prim_channels > 2) {
1197 s->output = DCA_STEREO;
1198 avctx->channel_layout = CH_LAYOUT_STEREO;
1201 avctx->channel_layout = dca_core_channel_layout[s->amode];
1203 if (s->lfe) avctx->channel_layout |= CH_LOW_FREQUENCY;
1205 /* There is nothing that prevents a dts frame to change channel configuration
1206 but FFmpeg doesn't support that so only set the channels if it is previously
1207 unset. Ideally during the first probe for channels the crc should be checked
1208 and only set avctx->channels when the crc is ok. Right now the decoder could
1209 set the channels based on a broken first frame.*/
1210 if (!avctx->channels)
1211 avctx->channels = channels;
1213 if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1215 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1216 for (i = 0; i < (s->sample_blocks / 8); i++) {
1217 dca_decode_block(s);
1218 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1219 samples += 256 * channels;
1228 * DCA initialization
1230 * @param avctx pointer to the AVCodecContext
1233 static av_cold int dca_decode_init(AVCodecContext * avctx)
1235 DCAContext *s = avctx->priv_data;
1241 dsputil_init(&s->dsp, avctx);
1242 ff_mdct_init(&s->imdct, 6, 1);
1244 for(i = 0; i < 6; i++)
1245 s->samples_chanptr[i] = s->samples + i * 256;
1246 avctx->sample_fmt = SAMPLE_FMT_S16;
1248 if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1249 s->add_bias = 385.0f;
1250 s->scale_bias = 1.0 / 32768.0;
1253 s->scale_bias = 1.0;
1255 /* allow downmixing to stereo */
1256 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1257 avctx->request_channels == 2) {
1258 avctx->channels = avctx->request_channels;
1266 static av_cold int dca_decode_end(AVCodecContext * avctx)
1268 DCAContext *s = avctx->priv_data;
1269 ff_mdct_end(&s->imdct);
1273 AVCodec dca_decoder = {
1275 .type = CODEC_TYPE_AUDIO,
1277 .priv_data_size = sizeof(DCAContext),
1278 .init = dca_decode_init,
1279 .decode = dca_decode_frame,
1280 .close = dca_decode_end,
1281 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),