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 total_channels
; ///< number of channels including extensions
129 int prim_channels
; ///< number of primary audio channels
130 int subband_activity
[DCA_PRIM_CHANNELS_MAX
]; ///< subband activity count
131 int vq_start_subband
[DCA_PRIM_CHANNELS_MAX
]; ///< high frequency vq start subband
132 int joint_intensity
[DCA_PRIM_CHANNELS_MAX
]; ///< joint intensity coding index
133 int transient_huffman
[DCA_PRIM_CHANNELS_MAX
]; ///< transient mode code book
134 int scalefactor_huffman
[DCA_PRIM_CHANNELS_MAX
]; ///< scale factor code book
135 int bitalloc_huffman
[DCA_PRIM_CHANNELS_MAX
]; ///< bit allocation quantizer select
136 int quant_index_huffman
[DCA_PRIM_CHANNELS_MAX
][DCA_ABITS_MAX
]; ///< quantization index codebook select
137 float scalefactor_adj
[DCA_PRIM_CHANNELS_MAX
][DCA_ABITS_MAX
]; ///< scale factor adjustment
139 /* Primary audio coding side information */
140 int subsubframes
; ///< number of subsubframes
141 int partial_samples
; ///< partial subsubframe samples count
142 int prediction_mode
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< prediction mode (ADPCM used or not)
143 int prediction_vq
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< prediction VQ coefs
144 int bitalloc
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< bit allocation index
145 int transition_mode
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< transition mode (transients)
146 int scale_factor
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
][2]; ///< scale factors (2 if transient)
147 int joint_huff
[DCA_PRIM_CHANNELS_MAX
]; ///< joint subband scale factors codebook
148 int joint_scale_factor
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< joint subband scale factors
149 int downmix_coef
[DCA_PRIM_CHANNELS_MAX
][2]; ///< stereo downmix coefficients
150 int dynrange_coef
; ///< dynamic range coefficient
152 int high_freq_vq
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
]; ///< VQ encoded high frequency subbands
154 float lfe_data
[2 * DCA_SUBSUBFAMES_MAX
* DCA_LFE_MAX
*
155 2 /*history */ ]; ///< Low frequency effect data
156 int lfe_scale_factor
;
158 /* Subband samples history (for ADPCM) */
159 float subband_samples_hist
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
][4];
160 float subband_fir_hist
[DCA_PRIM_CHANNELS_MAX
][512];
161 float subband_fir_noidea
[DCA_PRIM_CHANNELS_MAX
][64];
163 int output
; ///< type of output
164 int bias
; ///< output bias
166 DECLARE_ALIGNED_16(float, samples
[1536]); /* 6 * 256 = 1536, might only need 5 */
167 DECLARE_ALIGNED_16(int16_t, tsamples
[1536]);
169 uint8_t dca_buffer
[DCA_MAX_FRAME_SIZE
];
170 int dca_buffer_size
; ///< how much data is in the dca_buffer
173 /* Current position in DCA frame */
174 int current_subframe
;
175 int current_subsubframe
;
177 int debug_flag
; ///< used for suppressing repeated error messages output
181 static av_cold
void dca_init_vlcs(void)
183 static int vlcs_initialized
= 0;
186 if (vlcs_initialized
)
189 dca_bitalloc_index
.offset
= 1;
190 dca_bitalloc_index
.wrap
= 2;
191 for (i
= 0; i
< 5; i
++)
192 init_vlc(&dca_bitalloc_index
.vlc
[i
], bitalloc_12_vlc_bits
[i
], 12,
193 bitalloc_12_bits
[i
], 1, 1,
194 bitalloc_12_codes
[i
], 2, 2, 1);
195 dca_scalefactor
.offset
= -64;
196 dca_scalefactor
.wrap
= 2;
197 for (i
= 0; i
< 5; i
++)
198 init_vlc(&dca_scalefactor
.vlc
[i
], SCALES_VLC_BITS
, 129,
199 scales_bits
[i
], 1, 1,
200 scales_codes
[i
], 2, 2, 1);
201 dca_tmode
.offset
= 0;
203 for (i
= 0; i
< 4; i
++)
204 init_vlc(&dca_tmode
.vlc
[i
], tmode_vlc_bits
[i
], 4,
206 tmode_codes
[i
], 2, 2, 1);
208 for(i
= 0; i
< 10; i
++)
209 for(j
= 0; j
< 7; j
++){
210 if(!bitalloc_codes
[i
][j
]) break;
211 dca_smpl_bitalloc
[i
+1].offset
= bitalloc_offsets
[i
];
212 dca_smpl_bitalloc
[i
+1].wrap
= 1 + (j
> 4);
213 init_vlc(&dca_smpl_bitalloc
[i
+1].vlc
[j
], bitalloc_maxbits
[i
][j
],
215 bitalloc_bits
[i
][j
], 1, 1,
216 bitalloc_codes
[i
][j
], 2, 2, 1);
218 vlcs_initialized
= 1;
221 static inline void get_array(GetBitContext
*gb
, int *dst
, int len
, int bits
)
224 *dst
++ = get_bits(gb
, bits
);
227 static int dca_parse_frame_header(DCAContext
* s
)
230 static const float adj_table
[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
231 static const int bitlen
[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
232 static const int thr
[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
234 s
->bias
= CONVERT_BIAS
;
236 init_get_bits(&s
->gb
, s
->dca_buffer
, s
->dca_buffer_size
* 8);
239 get_bits(&s
->gb
, 32);
242 s
->frame_type
= get_bits(&s
->gb
, 1);
243 s
->samples_deficit
= get_bits(&s
->gb
, 5) + 1;
244 s
->crc_present
= get_bits(&s
->gb
, 1);
245 s
->sample_blocks
= get_bits(&s
->gb
, 7) + 1;
246 s
->frame_size
= get_bits(&s
->gb
, 14) + 1;
247 if (s
->frame_size
< 95)
249 s
->amode
= get_bits(&s
->gb
, 6);
250 s
->sample_rate
= dca_sample_rates
[get_bits(&s
->gb
, 4)];
253 s
->bit_rate
= dca_bit_rates
[get_bits(&s
->gb
, 5)];
257 s
->downmix
= get_bits(&s
->gb
, 1);
258 s
->dynrange
= get_bits(&s
->gb
, 1);
259 s
->timestamp
= get_bits(&s
->gb
, 1);
260 s
->aux_data
= get_bits(&s
->gb
, 1);
261 s
->hdcd
= get_bits(&s
->gb
, 1);
262 s
->ext_descr
= get_bits(&s
->gb
, 3);
263 s
->ext_coding
= get_bits(&s
->gb
, 1);
264 s
->aspf
= get_bits(&s
->gb
, 1);
265 s
->lfe
= get_bits(&s
->gb
, 2);
266 s
->predictor_history
= get_bits(&s
->gb
, 1);
268 /* TODO: check CRC */
270 s
->header_crc
= get_bits(&s
->gb
, 16);
272 s
->multirate_inter
= get_bits(&s
->gb
, 1);
273 s
->version
= get_bits(&s
->gb
, 4);
274 s
->copy_history
= get_bits(&s
->gb
, 2);
275 s
->source_pcm_res
= get_bits(&s
->gb
, 3);
276 s
->front_sum
= get_bits(&s
->gb
, 1);
277 s
->surround_sum
= get_bits(&s
->gb
, 1);
278 s
->dialog_norm
= get_bits(&s
->gb
, 4);
280 /* FIXME: channels mixing levels */
281 s
->output
= s
->amode
;
282 if(s
->lfe
) s
->output
|= DCA_LFE
;
285 av_log(s
->avctx
, AV_LOG_DEBUG
, "frame type: %i\n", s
->frame_type
);
286 av_log(s
->avctx
, AV_LOG_DEBUG
, "samples deficit: %i\n", s
->samples_deficit
);
287 av_log(s
->avctx
, AV_LOG_DEBUG
, "crc present: %i\n", s
->crc_present
);
288 av_log(s
->avctx
, AV_LOG_DEBUG
, "sample blocks: %i (%i samples)\n",
289 s
->sample_blocks
, s
->sample_blocks
* 32);
290 av_log(s
->avctx
, AV_LOG_DEBUG
, "frame size: %i bytes\n", s
->frame_size
);
291 av_log(s
->avctx
, AV_LOG_DEBUG
, "amode: %i (%i channels)\n",
292 s
->amode
, dca_channels
[s
->amode
]);
293 av_log(s
->avctx
, AV_LOG_DEBUG
, "sample rate: %i (%i Hz)\n",
294 s
->sample_rate
, dca_sample_rates
[s
->sample_rate
]);
295 av_log(s
->avctx
, AV_LOG_DEBUG
, "bit rate: %i (%i bits/s)\n",
296 s
->bit_rate
, dca_bit_rates
[s
->bit_rate
]);
297 av_log(s
->avctx
, AV_LOG_DEBUG
, "downmix: %i\n", s
->downmix
);
298 av_log(s
->avctx
, AV_LOG_DEBUG
, "dynrange: %i\n", s
->dynrange
);
299 av_log(s
->avctx
, AV_LOG_DEBUG
, "timestamp: %i\n", s
->timestamp
);
300 av_log(s
->avctx
, AV_LOG_DEBUG
, "aux_data: %i\n", s
->aux_data
);
301 av_log(s
->avctx
, AV_LOG_DEBUG
, "hdcd: %i\n", s
->hdcd
);
302 av_log(s
->avctx
, AV_LOG_DEBUG
, "ext descr: %i\n", s
->ext_descr
);
303 av_log(s
->avctx
, AV_LOG_DEBUG
, "ext coding: %i\n", s
->ext_coding
);
304 av_log(s
->avctx
, AV_LOG_DEBUG
, "aspf: %i\n", s
->aspf
);
305 av_log(s
->avctx
, AV_LOG_DEBUG
, "lfe: %i\n", s
->lfe
);
306 av_log(s
->avctx
, AV_LOG_DEBUG
, "predictor history: %i\n",
307 s
->predictor_history
);
308 av_log(s
->avctx
, AV_LOG_DEBUG
, "header crc: %i\n", s
->header_crc
);
309 av_log(s
->avctx
, AV_LOG_DEBUG
, "multirate inter: %i\n",
311 av_log(s
->avctx
, AV_LOG_DEBUG
, "version number: %i\n", s
->version
);
312 av_log(s
->avctx
, AV_LOG_DEBUG
, "copy history: %i\n", s
->copy_history
);
313 av_log(s
->avctx
, AV_LOG_DEBUG
,
314 "source pcm resolution: %i (%i bits/sample)\n",
315 s
->source_pcm_res
, dca_bits_per_sample
[s
->source_pcm_res
]);
316 av_log(s
->avctx
, AV_LOG_DEBUG
, "front sum: %i\n", s
->front_sum
);
317 av_log(s
->avctx
, AV_LOG_DEBUG
, "surround sum: %i\n", s
->surround_sum
);
318 av_log(s
->avctx
, AV_LOG_DEBUG
, "dialog norm: %i\n", s
->dialog_norm
);
319 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
322 /* Primary audio coding header */
323 s
->subframes
= get_bits(&s
->gb
, 4) + 1;
324 s
->total_channels
= get_bits(&s
->gb
, 3) + 1;
325 s
->prim_channels
= s
->total_channels
;
326 if (s
->prim_channels
> DCA_PRIM_CHANNELS_MAX
)
327 s
->prim_channels
= DCA_PRIM_CHANNELS_MAX
; /* We only support DTS core */
330 for (i
= 0; i
< s
->prim_channels
; i
++) {
331 s
->subband_activity
[i
] = get_bits(&s
->gb
, 5) + 2;
332 if (s
->subband_activity
[i
] > DCA_SUBBANDS
)
333 s
->subband_activity
[i
] = DCA_SUBBANDS
;
335 for (i
= 0; i
< s
->prim_channels
; i
++) {
336 s
->vq_start_subband
[i
] = get_bits(&s
->gb
, 5) + 1;
337 if (s
->vq_start_subband
[i
] > DCA_SUBBANDS
)
338 s
->vq_start_subband
[i
] = DCA_SUBBANDS
;
340 get_array(&s
->gb
, s
->joint_intensity
, s
->prim_channels
, 3);
341 get_array(&s
->gb
, s
->transient_huffman
, s
->prim_channels
, 2);
342 get_array(&s
->gb
, s
->scalefactor_huffman
, s
->prim_channels
, 3);
343 get_array(&s
->gb
, s
->bitalloc_huffman
, s
->prim_channels
, 3);
345 /* Get codebooks quantization indexes */
346 memset(s
->quant_index_huffman
, 0, sizeof(s
->quant_index_huffman
));
347 for (j
= 1; j
< 11; j
++)
348 for (i
= 0; i
< s
->prim_channels
; i
++)
349 s
->quant_index_huffman
[i
][j
] = get_bits(&s
->gb
, bitlen
[j
]);
351 /* Get scale factor adjustment */
352 for (j
= 0; j
< 11; j
++)
353 for (i
= 0; i
< s
->prim_channels
; i
++)
354 s
->scalefactor_adj
[i
][j
] = 1;
356 for (j
= 1; j
< 11; j
++)
357 for (i
= 0; i
< s
->prim_channels
; i
++)
358 if (s
->quant_index_huffman
[i
][j
] < thr
[j
])
359 s
->scalefactor_adj
[i
][j
] = adj_table
[get_bits(&s
->gb
, 2)];
361 if (s
->crc_present
) {
362 /* Audio header CRC check */
363 get_bits(&s
->gb
, 16);
366 s
->current_subframe
= 0;
367 s
->current_subsubframe
= 0;
370 av_log(s
->avctx
, AV_LOG_DEBUG
, "subframes: %i\n", s
->subframes
);
371 av_log(s
->avctx
, AV_LOG_DEBUG
, "prim channels: %i\n", s
->prim_channels
);
372 for(i
= 0; i
< s
->prim_channels
; i
++){
373 av_log(s
->avctx
, AV_LOG_DEBUG
, "subband activity: %i\n", s
->subband_activity
[i
]);
374 av_log(s
->avctx
, AV_LOG_DEBUG
, "vq start subband: %i\n", s
->vq_start_subband
[i
]);
375 av_log(s
->avctx
, AV_LOG_DEBUG
, "joint intensity: %i\n", s
->joint_intensity
[i
]);
376 av_log(s
->avctx
, AV_LOG_DEBUG
, "transient mode codebook: %i\n", s
->transient_huffman
[i
]);
377 av_log(s
->avctx
, AV_LOG_DEBUG
, "scale factor codebook: %i\n", s
->scalefactor_huffman
[i
]);
378 av_log(s
->avctx
, AV_LOG_DEBUG
, "bit allocation quantizer: %i\n", s
->bitalloc_huffman
[i
]);
379 av_log(s
->avctx
, AV_LOG_DEBUG
, "quant index huff:");
380 for (j
= 0; j
< 11; j
++)
381 av_log(s
->avctx
, AV_LOG_DEBUG
, " %i",
382 s
->quant_index_huffman
[i
][j
]);
383 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
384 av_log(s
->avctx
, AV_LOG_DEBUG
, "scalefac adj:");
385 for (j
= 0; j
< 11; j
++)
386 av_log(s
->avctx
, AV_LOG_DEBUG
, " %1.3f", s
->scalefactor_adj
[i
][j
]);
387 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
395 static inline int get_scale(GetBitContext
*gb
, int level
, int value
)
398 /* huffman encoded */
399 value
+= get_bitalloc(gb
, &dca_scalefactor
, level
);
401 value
= get_bits(gb
, level
+ 1);
405 static int dca_subframe_header(DCAContext
* s
)
407 /* Primary audio coding side information */
410 s
->subsubframes
= get_bits(&s
->gb
, 2) + 1;
411 s
->partial_samples
= get_bits(&s
->gb
, 3);
412 for (j
= 0; j
< s
->prim_channels
; j
++) {
413 for (k
= 0; k
< s
->subband_activity
[j
]; k
++)
414 s
->prediction_mode
[j
][k
] = get_bits(&s
->gb
, 1);
417 /* Get prediction codebook */
418 for (j
= 0; j
< s
->prim_channels
; j
++) {
419 for (k
= 0; k
< s
->subband_activity
[j
]; k
++) {
420 if (s
->prediction_mode
[j
][k
] > 0) {
421 /* (Prediction coefficient VQ address) */
422 s
->prediction_vq
[j
][k
] = get_bits(&s
->gb
, 12);
427 /* Bit allocation index */
428 for (j
= 0; j
< s
->prim_channels
; j
++) {
429 for (k
= 0; k
< s
->vq_start_subband
[j
]; k
++) {
430 if (s
->bitalloc_huffman
[j
] == 6)
431 s
->bitalloc
[j
][k
] = get_bits(&s
->gb
, 5);
432 else if (s
->bitalloc_huffman
[j
] == 5)
433 s
->bitalloc
[j
][k
] = get_bits(&s
->gb
, 4);
434 else if (s
->bitalloc_huffman
[j
] == 7) {
435 av_log(s
->avctx
, AV_LOG_ERROR
,
436 "Invalid bit allocation index\n");
440 get_bitalloc(&s
->gb
, &dca_bitalloc_index
, s
->bitalloc_huffman
[j
]);
443 if (s
->bitalloc
[j
][k
] > 26) {
444 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
445 // j, k, s->bitalloc[j][k]);
451 /* Transition mode */
452 for (j
= 0; j
< s
->prim_channels
; j
++) {
453 for (k
= 0; k
< s
->subband_activity
[j
]; k
++) {
454 s
->transition_mode
[j
][k
] = 0;
455 if (s
->subsubframes
> 1 &&
456 k
< s
->vq_start_subband
[j
] && s
->bitalloc
[j
][k
] > 0) {
457 s
->transition_mode
[j
][k
] =
458 get_bitalloc(&s
->gb
, &dca_tmode
, s
->transient_huffman
[j
]);
463 for (j
= 0; j
< s
->prim_channels
; j
++) {
464 const uint32_t *scale_table
;
467 memset(s
->scale_factor
[j
], 0, s
->subband_activity
[j
] * sizeof(s
->scale_factor
[0][0][0]) * 2);
469 if (s
->scalefactor_huffman
[j
] == 6)
470 scale_table
= scale_factor_quant7
;
472 scale_table
= scale_factor_quant6
;
474 /* When huffman coded, only the difference is encoded */
477 for (k
= 0; k
< s
->subband_activity
[j
]; k
++) {
478 if (k
>= s
->vq_start_subband
[j
] || s
->bitalloc
[j
][k
] > 0) {
479 scale_sum
= get_scale(&s
->gb
, s
->scalefactor_huffman
[j
], scale_sum
);
480 s
->scale_factor
[j
][k
][0] = scale_table
[scale_sum
];
483 if (k
< s
->vq_start_subband
[j
] && s
->transition_mode
[j
][k
]) {
484 /* Get second scale factor */
485 scale_sum
= get_scale(&s
->gb
, s
->scalefactor_huffman
[j
], scale_sum
);
486 s
->scale_factor
[j
][k
][1] = scale_table
[scale_sum
];
491 /* Joint subband scale factor codebook select */
492 for (j
= 0; j
< s
->prim_channels
; j
++) {
493 /* Transmitted only if joint subband coding enabled */
494 if (s
->joint_intensity
[j
] > 0)
495 s
->joint_huff
[j
] = get_bits(&s
->gb
, 3);
498 /* Scale factors for joint subband coding */
499 for (j
= 0; j
< s
->prim_channels
; j
++) {
502 /* Transmitted only if joint subband coding enabled */
503 if (s
->joint_intensity
[j
] > 0) {
505 source_channel
= s
->joint_intensity
[j
] - 1;
507 /* When huffman coded, only the difference is encoded
508 * (is this valid as well for joint scales ???) */
510 for (k
= s
->subband_activity
[j
]; k
< s
->subband_activity
[source_channel
]; k
++) {
511 scale
= get_scale(&s
->gb
, s
->joint_huff
[j
], 0);
512 scale
+= 64; /* bias */
513 s
->joint_scale_factor
[j
][k
] = scale
; /*joint_scale_table[scale]; */
516 if (!s
->debug_flag
& 0x02) {
517 av_log(s
->avctx
, AV_LOG_DEBUG
,
518 "Joint stereo coding not supported\n");
519 s
->debug_flag
|= 0x02;
524 /* Stereo downmix coefficients */
525 if (s
->prim_channels
> 2) {
527 for (j
= 0; j
< s
->prim_channels
; j
++) {
528 s
->downmix_coef
[j
][0] = get_bits(&s
->gb
, 7);
529 s
->downmix_coef
[j
][1] = get_bits(&s
->gb
, 7);
532 int am
= s
->amode
& DCA_CHANNEL_MASK
;
533 for (j
= 0; j
< s
->prim_channels
; j
++) {
534 s
->downmix_coef
[j
][0] = dca_default_coeffs
[am
][j
][0];
535 s
->downmix_coef
[j
][1] = dca_default_coeffs
[am
][j
][1];
540 /* Dynamic range coefficient */
542 s
->dynrange_coef
= get_bits(&s
->gb
, 8);
544 /* Side information CRC check word */
545 if (s
->crc_present
) {
546 get_bits(&s
->gb
, 16);
550 * Primary audio data arrays
553 /* VQ encoded high frequency subbands */
554 for (j
= 0; j
< s
->prim_channels
; j
++)
555 for (k
= s
->vq_start_subband
[j
]; k
< s
->subband_activity
[j
]; k
++)
556 /* 1 vector -> 32 samples */
557 s
->high_freq_vq
[j
][k
] = get_bits(&s
->gb
, 10);
559 /* Low frequency effect data */
562 int lfe_samples
= 2 * s
->lfe
* s
->subsubframes
;
565 for (j
= lfe_samples
; j
< lfe_samples
* 2; j
++) {
566 /* Signed 8 bits int */
567 s
->lfe_data
[j
] = get_sbits(&s
->gb
, 8);
570 /* Scale factor index */
571 s
->lfe_scale_factor
= scale_factor_quant7
[get_bits(&s
->gb
, 8)];
573 /* Quantization step size * scale factor */
574 lfe_scale
= 0.035 * s
->lfe_scale_factor
;
576 for (j
= lfe_samples
; j
< lfe_samples
* 2; j
++)
577 s
->lfe_data
[j
] *= lfe_scale
;
581 av_log(s
->avctx
, AV_LOG_DEBUG
, "subsubframes: %i\n", s
->subsubframes
);
582 av_log(s
->avctx
, AV_LOG_DEBUG
, "partial samples: %i\n",
584 for (j
= 0; j
< s
->prim_channels
; j
++) {
585 av_log(s
->avctx
, AV_LOG_DEBUG
, "prediction mode:");
586 for (k
= 0; k
< s
->subband_activity
[j
]; k
++)
587 av_log(s
->avctx
, AV_LOG_DEBUG
, " %i", s
->prediction_mode
[j
][k
]);
588 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
590 for (j
= 0; j
< s
->prim_channels
; j
++) {
591 for (k
= 0; k
< s
->subband_activity
[j
]; k
++)
592 av_log(s
->avctx
, AV_LOG_DEBUG
,
593 "prediction coefs: %f, %f, %f, %f\n",
594 (float) adpcm_vb
[s
->prediction_vq
[j
][k
]][0] / 8192,
595 (float) adpcm_vb
[s
->prediction_vq
[j
][k
]][1] / 8192,
596 (float) adpcm_vb
[s
->prediction_vq
[j
][k
]][2] / 8192,
597 (float) adpcm_vb
[s
->prediction_vq
[j
][k
]][3] / 8192);
599 for (j
= 0; j
< s
->prim_channels
; j
++) {
600 av_log(s
->avctx
, AV_LOG_DEBUG
, "bitalloc index: ");
601 for (k
= 0; k
< s
->vq_start_subband
[j
]; k
++)
602 av_log(s
->avctx
, AV_LOG_DEBUG
, "%2.2i ", s
->bitalloc
[j
][k
]);
603 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
605 for (j
= 0; j
< s
->prim_channels
; j
++) {
606 av_log(s
->avctx
, AV_LOG_DEBUG
, "Transition mode:");
607 for (k
= 0; k
< s
->subband_activity
[j
]; k
++)
608 av_log(s
->avctx
, AV_LOG_DEBUG
, " %i", s
->transition_mode
[j
][k
]);
609 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
611 for (j
= 0; j
< s
->prim_channels
; j
++) {
612 av_log(s
->avctx
, AV_LOG_DEBUG
, "Scale factor:");
613 for (k
= 0; k
< s
->subband_activity
[j
]; k
++) {
614 if (k
>= s
->vq_start_subband
[j
] || s
->bitalloc
[j
][k
] > 0)
615 av_log(s
->avctx
, AV_LOG_DEBUG
, " %i", s
->scale_factor
[j
][k
][0]);
616 if (k
< s
->vq_start_subband
[j
] && s
->transition_mode
[j
][k
])
617 av_log(s
->avctx
, AV_LOG_DEBUG
, " %i(t)", s
->scale_factor
[j
][k
][1]);
619 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
621 for (j
= 0; j
< s
->prim_channels
; j
++) {
622 if (s
->joint_intensity
[j
] > 0) {
623 int source_channel
= s
->joint_intensity
[j
] - 1;
624 av_log(s
->avctx
, AV_LOG_DEBUG
, "Joint scale factor index:\n");
625 for (k
= s
->subband_activity
[j
]; k
< s
->subband_activity
[source_channel
]; k
++)
626 av_log(s
->avctx
, AV_LOG_DEBUG
, " %i", s
->joint_scale_factor
[j
][k
]);
627 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
630 if (s
->prim_channels
> 2 && s
->downmix
) {
631 av_log(s
->avctx
, AV_LOG_DEBUG
, "Downmix coeffs:\n");
632 for (j
= 0; j
< s
->prim_channels
; j
++) {
633 av_log(s
->avctx
, AV_LOG_DEBUG
, "Channel 0,%d = %f\n", j
, dca_downmix_coeffs
[s
->downmix_coef
[j
][0]]);
634 av_log(s
->avctx
, AV_LOG_DEBUG
, "Channel 1,%d = %f\n", j
, dca_downmix_coeffs
[s
->downmix_coef
[j
][1]]);
636 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
638 for (j
= 0; j
< s
->prim_channels
; j
++)
639 for (k
= s
->vq_start_subband
[j
]; k
< s
->subband_activity
[j
]; k
++)
640 av_log(s
->avctx
, AV_LOG_DEBUG
, "VQ index: %i\n", s
->high_freq_vq
[j
][k
]);
642 int lfe_samples
= 2 * s
->lfe
* s
->subsubframes
;
643 av_log(s
->avctx
, AV_LOG_DEBUG
, "LFE samples:\n");
644 for (j
= lfe_samples
; j
< lfe_samples
* 2; j
++)
645 av_log(s
->avctx
, AV_LOG_DEBUG
, " %f", s
->lfe_data
[j
]);
646 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
653 static void qmf_32_subbands(DCAContext
* s
, int chans
,
654 float samples_in
[32][8], float *samples_out
,
655 float scale
, float bias
)
657 const float *prCoeff
;
659 float praXin
[33], *raXin
= &praXin
[1];
661 float *subband_fir_hist
= s
->subband_fir_hist
[chans
];
662 float *subband_fir_hist2
= s
->subband_fir_noidea
[chans
];
664 int chindex
= 0, subindex
;
669 if (!s
->multirate_inter
) /* Non-perfect reconstruction */
670 prCoeff
= fir_32bands_nonperfect
;
671 else /* Perfect reconstruction */
672 prCoeff
= fir_32bands_perfect
;
674 /* Reconstructed channel sample index */
675 for (subindex
= 0; subindex
< 8; subindex
++) {
676 float t1
, t2
, sum
[16], diff
[16];
678 /* Load in one sample from each subband and clear inactive subbands */
679 for (i
= 0; i
< s
->subband_activity
[chans
]; i
++)
680 raXin
[i
] = samples_in
[i
][subindex
];
684 /* Multiply by cosine modulation coefficients and
685 * create temporary arrays SUM and DIFF */
686 for (j
= 0, k
= 0; k
< 16; k
++) {
689 for (i
= 0; i
< 16; i
++, j
++){
690 t1
+= (raXin
[2 * i
] + raXin
[2 * i
+ 1]) * cos_mod
[j
];
691 t2
+= (raXin
[2 * i
] + raXin
[2 * i
- 1]) * cos_mod
[j
+ 256];
699 for (k
= 0; k
< 16; k
++)
700 subband_fir_hist
[k
] = cos_mod
[j
++] * sum
[k
];
701 for (k
= 0; k
< 16; k
++)
702 subband_fir_hist
[32-k
-1] = cos_mod
[j
++] * diff
[k
];
704 /* Multiply by filter coefficients */
705 for (k
= 31, i
= 0; i
< 32; i
++, k
--)
706 for (j
= 0; j
< 512; j
+= 64){
707 subband_fir_hist2
[i
] += prCoeff
[i
+j
] * ( subband_fir_hist
[i
+j
] - subband_fir_hist
[j
+k
]);
708 subband_fir_hist2
[i
+32] += prCoeff
[i
+j
+32]*(-subband_fir_hist
[i
+j
] - subband_fir_hist
[j
+k
]);
711 /* Create 32 PCM output samples */
712 for (i
= 0; i
< 32; i
++)
713 samples_out
[chindex
++] = subband_fir_hist2
[i
] * scale
+ bias
;
715 /* Update working arrays */
716 memmove(&subband_fir_hist
[32], &subband_fir_hist
[0], (512 - 32) * sizeof(float));
717 memmove(&subband_fir_hist2
[0], &subband_fir_hist2
[32], 32 * sizeof(float));
718 memset(&subband_fir_hist2
[32], 0, 32 * sizeof(float));
722 static void lfe_interpolation_fir(int decimation_select
,
723 int num_deci_sample
, float *samples_in
,
724 float *samples_out
, float scale
,
727 /* samples_in: An array holding decimated samples.
728 * Samples in current subframe starts from samples_in[0],
729 * while samples_in[-1], samples_in[-2], ..., stores samples
730 * from last subframe as history.
732 * samples_out: An array holding interpolated samples
735 int decifactor
, k
, j
;
736 const float *prCoeff
;
738 int interp_index
= 0; /* Index to the interpolated samples */
741 /* Select decimation filter */
742 if (decimation_select
== 1) {
744 prCoeff
= lfe_fir_128
;
747 prCoeff
= lfe_fir_64
;
750 for (deciindex
= 0; deciindex
< num_deci_sample
; deciindex
++) {
751 /* One decimated sample generates decifactor interpolated ones */
752 for (k
= 0; k
< decifactor
; k
++) {
754 //FIXME the coeffs are symetric, fix that
755 for (j
= 0; j
< 512 / decifactor
; j
++)
756 rTmp
+= samples_in
[deciindex
- j
] * prCoeff
[k
+ j
* decifactor
];
757 samples_out
[interp_index
++] = rTmp
/ scale
+ bias
;
762 /* downmixing routines */
763 #define MIX_REAR1(samples, si1, rs, coef) \
764 samples[i] += samples[si1] * coef[rs][0]; \
765 samples[i+256] += samples[si1] * coef[rs][1];
767 #define MIX_REAR2(samples, si1, si2, rs, coef) \
768 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
769 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
771 #define MIX_FRONT3(samples, coef) \
773 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
774 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
776 #define DOWNMIX_TO_STEREO(op1, op2) \
777 for(i = 0; i < 256; i++){ \
782 static void dca_downmix(float *samples
, int srcfmt
,
783 int downmix_coef
[DCA_PRIM_CHANNELS_MAX
][2])
787 float coef
[DCA_PRIM_CHANNELS_MAX
][2];
789 for(i
=0; i
<DCA_PRIM_CHANNELS_MAX
; i
++) {
790 coef
[i
][0] = dca_downmix_coeffs
[downmix_coef
[i
][0]];
791 coef
[i
][1] = dca_downmix_coeffs
[downmix_coef
[i
][1]];
797 case DCA_STEREO_TOTAL
:
798 case DCA_STEREO_SUMDIFF
:
800 av_log(NULL
, 0, "Not implemented!\n");
805 DOWNMIX_TO_STEREO(MIX_FRONT3(samples
, coef
),);
808 DOWNMIX_TO_STEREO(MIX_REAR1(samples
, i
+ 512, 2, coef
),);
811 DOWNMIX_TO_STEREO(MIX_FRONT3(samples
, coef
),
812 MIX_REAR1(samples
, i
+ 768, 3, coef
));
815 DOWNMIX_TO_STEREO(MIX_REAR2(samples
, i
+ 512, i
+ 768, 2, coef
),);
818 DOWNMIX_TO_STEREO(MIX_FRONT3(samples
, coef
),
819 MIX_REAR2(samples
, i
+ 768, i
+ 1024, 3, coef
));
825 /* Very compact version of the block code decoder that does not use table
826 * look-up but is slightly slower */
827 static int decode_blockcode(int code
, int levels
, int *values
)
830 int offset
= (levels
- 1) >> 1;
832 for (i
= 0; i
< 4; i
++) {
833 values
[i
] = (code
% levels
) - offset
;
840 av_log(NULL
, AV_LOG_ERROR
, "ERROR: block code look-up failed\n");
845 static const uint8_t abits_sizes
[7] = { 7, 10, 12, 13, 15, 17, 19 };
846 static const uint8_t abits_levels
[7] = { 3, 5, 7, 9, 13, 17, 25 };
848 static int dca_subsubframe(DCAContext
* s
)
851 int subsubframe
= s
->current_subsubframe
;
853 const float *quant_step_table
;
856 float subband_samples
[DCA_PRIM_CHANNELS_MAX
][DCA_SUBBANDS
][8];
862 /* Select quantization step size table */
863 if (s
->bit_rate
== 0x1f)
864 quant_step_table
= lossless_quant_d
;
866 quant_step_table
= lossy_quant_d
;
868 for (k
= 0; k
< s
->prim_channels
; k
++) {
869 for (l
= 0; l
< s
->vq_start_subband
[k
]; l
++) {
872 /* Select the mid-tread linear quantizer */
873 int abits
= s
->bitalloc
[k
][l
];
875 float quant_step_size
= quant_step_table
[abits
];
879 * Determine quantization index code book and its type
882 /* Select quantization index code book */
883 int sel
= s
->quant_index_huffman
[k
][abits
];
886 * Extract bits from the bit stream
889 memset(subband_samples
[k
][l
], 0, 8 * sizeof(subband_samples
[0][0][0]));
890 }else if(abits
>= 11 || !dca_smpl_bitalloc
[abits
].vlc
[sel
].table
){
893 int block_code1
, block_code2
, size
, levels
;
896 size
= abits_sizes
[abits
-1];
897 levels
= abits_levels
[abits
-1];
899 block_code1
= get_bits(&s
->gb
, size
);
900 /* FIXME Should test return value */
901 decode_blockcode(block_code1
, levels
, block
);
902 block_code2
= get_bits(&s
->gb
, size
);
903 decode_blockcode(block_code2
, levels
, &block
[4]);
904 for (m
= 0; m
< 8; m
++)
905 subband_samples
[k
][l
][m
] = block
[m
];
908 for (m
= 0; m
< 8; m
++)
909 subband_samples
[k
][l
][m
] = get_sbits(&s
->gb
, abits
- 3);
913 for (m
= 0; m
< 8; m
++)
914 subband_samples
[k
][l
][m
] = get_bitalloc(&s
->gb
, &dca_smpl_bitalloc
[abits
], sel
);
917 /* Deal with transients */
918 if (s
->transition_mode
[k
][l
] &&
919 subsubframe
>= s
->transition_mode
[k
][l
])
920 rscale
= quant_step_size
* s
->scale_factor
[k
][l
][1];
922 rscale
= quant_step_size
* s
->scale_factor
[k
][l
][0];
924 rscale
*= s
->scalefactor_adj
[k
][sel
];
926 for (m
= 0; m
< 8; m
++)
927 subband_samples
[k
][l
][m
] *= rscale
;
930 * Inverse ADPCM if in prediction mode
932 if (s
->prediction_mode
[k
][l
]) {
934 for (m
= 0; m
< 8; m
++) {
935 for (n
= 1; n
<= 4; n
++)
937 subband_samples
[k
][l
][m
] +=
938 (adpcm_vb
[s
->prediction_vq
[k
][l
]][n
- 1] *
939 subband_samples
[k
][l
][m
- n
] / 8192);
940 else if (s
->predictor_history
)
941 subband_samples
[k
][l
][m
] +=
942 (adpcm_vb
[s
->prediction_vq
[k
][l
]][n
- 1] *
943 s
->subband_samples_hist
[k
][l
][m
- n
+
950 * Decode VQ encoded high frequencies
952 for (l
= s
->vq_start_subband
[k
]; l
< s
->subband_activity
[k
]; l
++) {
953 /* 1 vector -> 32 samples but we only need the 8 samples
954 * for this subsubframe. */
957 if (!s
->debug_flag
& 0x01) {
958 av_log(s
->avctx
, AV_LOG_DEBUG
, "Stream with high frequencies VQ coding\n");
959 s
->debug_flag
|= 0x01;
962 for (m
= 0; m
< 8; m
++) {
963 subband_samples
[k
][l
][m
] =
964 high_freq_vq
[s
->high_freq_vq
[k
][l
]][subsubframe
* 8 +
966 * (float) s
->scale_factor
[k
][l
][0] / 16.0;
971 /* Check for DSYNC after subsubframe */
972 if (s
->aspf
|| subsubframe
== s
->subsubframes
- 1) {
973 if (0xFFFF == get_bits(&s
->gb
, 16)) { /* 0xFFFF */
975 av_log(s
->avctx
, AV_LOG_DEBUG
, "Got subframe DSYNC\n");
978 av_log(s
->avctx
, AV_LOG_ERROR
, "Didn't get subframe DSYNC\n");
982 /* Backup predictor history for adpcm */
983 for (k
= 0; k
< s
->prim_channels
; k
++)
984 for (l
= 0; l
< s
->vq_start_subband
[k
]; l
++)
985 memcpy(s
->subband_samples_hist
[k
][l
], &subband_samples
[k
][l
][4],
986 4 * sizeof(subband_samples
[0][0][0]));
988 /* 32 subbands QMF */
989 for (k
= 0; k
< s
->prim_channels
; k
++) {
990 /* static float pcm_to_double[8] =
991 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
992 qmf_32_subbands(s
, k
, subband_samples
[k
], &s
->samples
[256 * k
],
993 2.0 / 3 /*pcm_to_double[s->source_pcm_res] */ ,
999 if (s
->prim_channels
> dca_channels
[s
->output
& DCA_CHANNEL_MASK
]) {
1000 dca_downmix(s
->samples
, s
->amode
, s
->downmix_coef
);
1003 /* Generate LFE samples for this subsubframe FIXME!!! */
1004 if (s
->output
& DCA_LFE
) {
1005 int lfe_samples
= 2 * s
->lfe
* s
->subsubframes
;
1006 int i_channels
= dca_channels
[s
->output
& DCA_CHANNEL_MASK
];
1008 lfe_interpolation_fir(s
->lfe
, 2 * s
->lfe
,
1009 s
->lfe_data
+ lfe_samples
+
1010 2 * s
->lfe
* subsubframe
,
1011 &s
->samples
[256 * i_channels
],
1012 256.0, 0 /* s->bias */);
1013 /* Outputs 20bits pcm samples */
1020 static int dca_subframe_footer(DCAContext
* s
)
1022 int aux_data_count
= 0, i
;
1026 * Unpack optional information
1030 get_bits(&s
->gb
, 32);
1033 aux_data_count
= get_bits(&s
->gb
, 6);
1035 for (i
= 0; i
< aux_data_count
; i
++)
1036 get_bits(&s
->gb
, 8);
1038 if (s
->crc_present
&& (s
->downmix
|| s
->dynrange
))
1039 get_bits(&s
->gb
, 16);
1041 lfe_samples
= 2 * s
->lfe
* s
->subsubframes
;
1042 for (i
= 0; i
< lfe_samples
; i
++) {
1043 s
->lfe_data
[i
] = s
->lfe_data
[i
+ lfe_samples
];
1050 * Decode a dca frame block
1052 * @param s pointer to the DCAContext
1055 static int dca_decode_block(DCAContext
* s
)
1059 if (s
->current_subframe
>= s
->subframes
) {
1060 av_log(s
->avctx
, AV_LOG_DEBUG
, "check failed: %i>%i",
1061 s
->current_subframe
, s
->subframes
);
1065 if (!s
->current_subsubframe
) {
1067 av_log(s
->avctx
, AV_LOG_DEBUG
, "DSYNC dca_subframe_header\n");
1069 /* Read subframe header */
1070 if (dca_subframe_header(s
))
1074 /* Read subsubframe */
1076 av_log(s
->avctx
, AV_LOG_DEBUG
, "DSYNC dca_subsubframe\n");
1078 if (dca_subsubframe(s
))
1082 s
->current_subsubframe
++;
1083 if (s
->current_subsubframe
>= s
->subsubframes
) {
1084 s
->current_subsubframe
= 0;
1085 s
->current_subframe
++;
1087 if (s
->current_subframe
>= s
->subframes
) {
1089 av_log(s
->avctx
, AV_LOG_DEBUG
, "DSYNC dca_subframe_footer\n");
1091 /* Read subframe footer */
1092 if (dca_subframe_footer(s
))
1100 * Convert bitstream to one representation based on sync marker
1102 static int dca_convert_bitstream(const uint8_t * src
, int src_size
, uint8_t * dst
,
1107 const uint16_t *ssrc
= (const uint16_t *) src
;
1108 uint16_t *sdst
= (uint16_t *) dst
;
1111 if((unsigned)src_size
> (unsigned)max_size
) {
1112 av_log(NULL
, AV_LOG_ERROR
, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1118 case DCA_MARKER_RAW_BE
:
1119 memcpy(dst
, src
, FFMIN(src_size
, max_size
));
1120 return FFMIN(src_size
, max_size
);
1121 case DCA_MARKER_RAW_LE
:
1122 for (i
= 0; i
< (FFMIN(src_size
, max_size
) + 1) >> 1; i
++)
1123 *sdst
++ = bswap_16(*ssrc
++);
1124 return FFMIN(src_size
, max_size
);
1125 case DCA_MARKER_14B_BE
:
1126 case DCA_MARKER_14B_LE
:
1127 init_put_bits(&pb
, dst
, max_size
);
1128 for (i
= 0; i
< (src_size
+ 1) >> 1; i
++, src
+= 2) {
1129 tmp
= ((mrk
== DCA_MARKER_14B_BE
) ? AV_RB16(src
) : AV_RL16(src
)) & 0x3FFF;
1130 put_bits(&pb
, 14, tmp
);
1132 flush_put_bits(&pb
);
1133 return (put_bits_count(&pb
) + 7) >> 3;
1140 * Main frame decoding function
1141 * FIXME add arguments
1143 static int dca_decode_frame(AVCodecContext
* avctx
,
1144 void *data
, int *data_size
,
1145 const uint8_t * buf
, int buf_size
)
1149 int16_t *samples
= data
;
1150 DCAContext
*s
= avctx
->priv_data
;
1154 s
->dca_buffer_size
= dca_convert_bitstream(buf
, buf_size
, s
->dca_buffer
, DCA_MAX_FRAME_SIZE
);
1155 if (s
->dca_buffer_size
== -1) {
1156 av_log(avctx
, AV_LOG_ERROR
, "Not a valid DCA frame\n");
1160 init_get_bits(&s
->gb
, s
->dca_buffer
, s
->dca_buffer_size
* 8);
1161 if (dca_parse_frame_header(s
) < 0) {
1162 //seems like the frame is corrupt, try with the next one
1166 //set AVCodec values with parsed data
1167 avctx
->sample_rate
= s
->sample_rate
;
1168 avctx
->bit_rate
= s
->bit_rate
;
1170 channels
= s
->prim_channels
+ !!s
->lfe
;
1171 if(avctx
->request_channels
== 2 && s
->prim_channels
> 2) {
1173 s
->output
= DCA_STEREO
;
1176 /* There is nothing that prevents a dts frame to change channel configuration
1177 but FFmpeg doesn't support that so only set the channels if it is previously
1178 unset. Ideally during the first probe for channels the crc should be checked
1179 and only set avctx->channels when the crc is ok. Right now the decoder could
1180 set the channels based on a broken first frame.*/
1181 if (!avctx
->channels
)
1182 avctx
->channels
= channels
;
1184 if(*data_size
< (s
->sample_blocks
/ 8) * 256 * sizeof(int16_t) * channels
)
1187 for (i
= 0; i
< (s
->sample_blocks
/ 8); i
++) {
1188 dca_decode_block(s
);
1189 s
->dsp
.float_to_int16(s
->tsamples
, s
->samples
, 256 * channels
);
1190 /* interleave samples */
1191 for (j
= 0; j
< 256; j
++) {
1192 for (k
= 0; k
< channels
; k
++)
1193 samples
[k
] = s
->tsamples
[j
+ k
* 256];
1194 samples
+= channels
;
1196 *data_size
+= 256 * sizeof(int16_t) * channels
;
1205 * Build the cosine modulation tables for the QMF
1207 * @param s pointer to the DCAContext
1210 static av_cold
void pre_calc_cosmod(DCAContext
* s
)
1213 static int cosmod_initialized
= 0;
1215 if(cosmod_initialized
) return;
1216 for (j
= 0, k
= 0; k
< 16; k
++)
1217 for (i
= 0; i
< 16; i
++)
1218 cos_mod
[j
++] = cos((2 * i
+ 1) * (2 * k
+ 1) * M_PI
/ 64);
1220 for (k
= 0; k
< 16; k
++)
1221 for (i
= 0; i
< 16; i
++)
1222 cos_mod
[j
++] = cos((i
) * (2 * k
+ 1) * M_PI
/ 32);
1224 for (k
= 0; k
< 16; k
++)
1225 cos_mod
[j
++] = 0.25 / (2 * cos((2 * k
+ 1) * M_PI
/ 128));
1227 for (k
= 0; k
< 16; k
++)
1228 cos_mod
[j
++] = -0.25 / (2.0 * sin((2 * k
+ 1) * M_PI
/ 128));
1230 cosmod_initialized
= 1;
1235 * DCA initialization
1237 * @param avctx pointer to the AVCodecContext
1240 static av_cold
int dca_decode_init(AVCodecContext
* avctx
)
1242 DCAContext
*s
= avctx
->priv_data
;
1248 dsputil_init(&s
->dsp
, avctx
);
1250 /* allow downmixing to stereo */
1251 if (avctx
->channels
> 0 && avctx
->request_channels
< avctx
->channels
&&
1252 avctx
->request_channels
== 2) {
1253 avctx
->channels
= avctx
->request_channels
;
1260 AVCodec dca_decoder
= {
1262 .type
= CODEC_TYPE_AUDIO
,
1264 .priv_data_size
= sizeof(DCAContext
),
1265 .init
= dca_decode_init
,
1266 .decode
= dca_decode_frame
,
1267 .long_name
= NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),