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
26 * @file libavcodec/dca.c
43 #define DCA_PRIM_CHANNELS_MAX (5)
44 #define DCA_SUBBANDS (32)
45 #define DCA_ABITS_MAX (32) /* Should be 28 */
46 #define DCA_SUBSUBFAMES_MAX (4)
47 #define DCA_LFE_MAX (3)
63 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
64 * Some compromises have been made for special configurations. Most configurations
65 * are never used so complete accuracy is not needed.
67 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
68 * S -> side, when both rear and back are configured move one of them to the side channel
70 * All 2 channel configurations -> CH_LAYOUT_STEREO
73 static const int64_t dca_core_channel_layout[] = {
74 CH_FRONT_CENTER, ///< 1, A
75 CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
76 CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
77 CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
78 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
79 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
80 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
81 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
82 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
83 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
84 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
85 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
86 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
87 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
88 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
89 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 static const int8_t dca_lfe_index[] = {
93 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
96 static const int8_t dca_channel_reorder_lfe[][8] = {
97 { 0, -1, -1, -1, -1, -1, -1, -1},
98 { 0, 1, -1, -1, -1, -1, -1, -1},
99 { 0, 1, -1, -1, -1, -1, -1, -1},
100 { 0, 1, -1, -1, -1, -1, -1, -1},
101 { 0, 1, -1, -1, -1, -1, -1, -1},
102 { 2, 0, 1, -1, -1, -1, -1, -1},
103 { 0, 1, 3, -1, -1, -1, -1, -1},
104 { 2, 0, 1, 4, -1, -1, -1, -1},
105 { 0, 1, 3, 4, -1, -1, -1, -1},
106 { 2, 0, 1, 4, 5, -1, -1, -1},
107 { 3, 4, 0, 1, 5, 6, -1, -1},
108 { 2, 0, 1, 4, 5, 6, -1, -1},
109 { 0, 6, 4, 5, 2, 3, -1, -1},
110 { 4, 2, 5, 0, 1, 6, 7, -1},
111 { 5, 6, 0, 1, 7, 3, 8, 4},
112 { 4, 2, 5, 0, 1, 6, 8, 7},
115 static const int8_t dca_channel_reorder_nolfe[][8] = {
116 { 0, -1, -1, -1, -1, -1, -1, -1},
117 { 0, 1, -1, -1, -1, -1, -1, -1},
118 { 0, 1, -1, -1, -1, -1, -1, -1},
119 { 0, 1, -1, -1, -1, -1, -1, -1},
120 { 0, 1, -1, -1, -1, -1, -1, -1},
121 { 2, 0, 1, -1, -1, -1, -1, -1},
122 { 0, 1, 2, -1, -1, -1, -1, -1},
123 { 2, 0, 1, 3, -1, -1, -1, -1},
124 { 0, 1, 2, 3, -1, -1, -1, -1},
125 { 2, 0, 1, 3, 4, -1, -1, -1},
126 { 2, 3, 0, 1, 4, 5, -1, -1},
127 { 2, 0, 1, 3, 4, 5, -1, -1},
128 { 0, 5, 3, 4, 1, 2, -1, -1},
129 { 3, 2, 4, 0, 1, 5, 6, -1},
130 { 4, 5, 0, 1, 6, 2, 7, 3},
131 { 3, 2, 4, 0, 1, 5, 7, 6},
135 #define DCA_DOLBY 101 /* FIXME */
137 #define DCA_CHANNEL_BITS 6
138 #define DCA_CHANNEL_MASK 0x3F
142 #define HEADER_SIZE 14
144 #define DCA_MAX_FRAME_SIZE 16384
146 /** Bit allocation */
148 int offset; ///< code values offset
149 int maxbits[8]; ///< max bits in VLC
150 int wrap; ///< wrap for get_vlc2()
151 VLC vlc[8]; ///< actual codes
154 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
155 static BitAlloc dca_tmode; ///< transition mode VLCs
156 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
157 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
159 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
161 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
165 AVCodecContext *avctx;
167 int frame_type; ///< type of the current frame
168 int samples_deficit; ///< deficit sample count
169 int crc_present; ///< crc is present in the bitstream
170 int sample_blocks; ///< number of PCM sample blocks
171 int frame_size; ///< primary frame byte size
172 int amode; ///< audio channels arrangement
173 int sample_rate; ///< audio sampling rate
174 int bit_rate; ///< transmission bit rate
175 int bit_rate_index; ///< transmission bit rate index
177 int downmix; ///< embedded downmix enabled
178 int dynrange; ///< embedded dynamic range flag
179 int timestamp; ///< embedded time stamp flag
180 int aux_data; ///< auxiliary data flag
181 int hdcd; ///< source material is mastered in HDCD
182 int ext_descr; ///< extension audio descriptor flag
183 int ext_coding; ///< extended coding flag
184 int aspf; ///< audio sync word insertion flag
185 int lfe; ///< low frequency effects flag
186 int predictor_history; ///< predictor history flag
187 int header_crc; ///< header crc check bytes
188 int multirate_inter; ///< multirate interpolator switch
189 int version; ///< encoder software revision
190 int copy_history; ///< copy history
191 int source_pcm_res; ///< source pcm resolution
192 int front_sum; ///< front sum/difference flag
193 int surround_sum; ///< surround sum/difference flag
194 int dialog_norm; ///< dialog normalisation parameter
196 /* Primary audio coding header */
197 int subframes; ///< number of subframes
198 int total_channels; ///< number of channels including extensions
199 int prim_channels; ///< number of primary audio channels
200 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
201 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
202 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
203 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
204 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
205 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
206 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
207 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
209 /* Primary audio coding side information */
210 int subsubframes; ///< number of subsubframes
211 int partial_samples; ///< partial subsubframe samples count
212 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
213 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
214 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
215 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
216 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
217 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
218 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
219 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
220 int dynrange_coef; ///< dynamic range coefficient
222 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
224 float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
225 2 /*history */ ]; ///< Low frequency effect data
226 int lfe_scale_factor;
228 /* Subband samples history (for ADPCM) */
229 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
230 DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]);
231 float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];
232 int hist_index[DCA_PRIM_CHANNELS_MAX];
234 int output; ///< type of output
235 float add_bias; ///< output bias
236 float scale_bias; ///< output scale
238 DECLARE_ALIGNED_16(float, samples[1536]); /* 6 * 256 = 1536, might only need 5 */
239 const float *samples_chanptr[6];
241 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
242 int dca_buffer_size; ///< how much data is in the dca_buffer
244 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
246 /* Current position in DCA frame */
247 int current_subframe;
248 int current_subsubframe;
250 int debug_flag; ///< used for suppressing repeated error messages output
255 static av_cold void dca_init_vlcs(void)
257 static int vlcs_initialized = 0;
260 if (vlcs_initialized)
263 dca_bitalloc_index.offset = 1;
264 dca_bitalloc_index.wrap = 2;
265 for (i = 0; i < 5; i++)
266 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
267 bitalloc_12_bits[i], 1, 1,
268 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_STATIC);
269 dca_scalefactor.offset = -64;
270 dca_scalefactor.wrap = 2;
271 for (i = 0; i < 5; i++)
272 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
273 scales_bits[i], 1, 1,
274 scales_codes[i], 2, 2, INIT_VLC_USE_STATIC);
275 dca_tmode.offset = 0;
277 for (i = 0; i < 4; i++)
278 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
280 tmode_codes[i], 2, 2, INIT_VLC_USE_STATIC);
282 for(i = 0; i < 10; i++)
283 for(j = 0; j < 7; j++){
284 if(!bitalloc_codes[i][j]) break;
285 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
286 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
287 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
289 bitalloc_bits[i][j], 1, 1,
290 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_STATIC);
292 vlcs_initialized = 1;
295 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
298 *dst++ = get_bits(gb, bits);
301 static int dca_parse_frame_header(DCAContext * s)
304 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
305 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
306 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
308 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
311 get_bits(&s->gb, 32);
314 s->frame_type = get_bits(&s->gb, 1);
315 s->samples_deficit = get_bits(&s->gb, 5) + 1;
316 s->crc_present = get_bits(&s->gb, 1);
317 s->sample_blocks = get_bits(&s->gb, 7) + 1;
318 s->frame_size = get_bits(&s->gb, 14) + 1;
319 if (s->frame_size < 95)
321 s->amode = get_bits(&s->gb, 6);
322 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
325 s->bit_rate_index = get_bits(&s->gb, 5);
326 s->bit_rate = dca_bit_rates[s->bit_rate_index];
330 s->downmix = get_bits(&s->gb, 1);
331 s->dynrange = get_bits(&s->gb, 1);
332 s->timestamp = get_bits(&s->gb, 1);
333 s->aux_data = get_bits(&s->gb, 1);
334 s->hdcd = get_bits(&s->gb, 1);
335 s->ext_descr = get_bits(&s->gb, 3);
336 s->ext_coding = get_bits(&s->gb, 1);
337 s->aspf = get_bits(&s->gb, 1);
338 s->lfe = get_bits(&s->gb, 2);
339 s->predictor_history = get_bits(&s->gb, 1);
341 /* TODO: check CRC */
343 s->header_crc = get_bits(&s->gb, 16);
345 s->multirate_inter = get_bits(&s->gb, 1);
346 s->version = get_bits(&s->gb, 4);
347 s->copy_history = get_bits(&s->gb, 2);
348 s->source_pcm_res = get_bits(&s->gb, 3);
349 s->front_sum = get_bits(&s->gb, 1);
350 s->surround_sum = get_bits(&s->gb, 1);
351 s->dialog_norm = get_bits(&s->gb, 4);
353 /* FIXME: channels mixing levels */
354 s->output = s->amode;
355 if(s->lfe) s->output |= DCA_LFE;
358 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
359 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
360 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
361 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
362 s->sample_blocks, s->sample_blocks * 32);
363 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
364 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
365 s->amode, dca_channels[s->amode]);
366 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
368 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
370 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
371 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
372 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
373 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
374 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
375 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
376 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
377 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
378 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
379 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
380 s->predictor_history);
381 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
382 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
384 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
385 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
386 av_log(s->avctx, AV_LOG_DEBUG,
387 "source pcm resolution: %i (%i bits/sample)\n",
388 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
389 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
390 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
391 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
392 av_log(s->avctx, AV_LOG_DEBUG, "\n");
395 /* Primary audio coding header */
396 s->subframes = get_bits(&s->gb, 4) + 1;
397 s->total_channels = get_bits(&s->gb, 3) + 1;
398 s->prim_channels = s->total_channels;
399 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
400 s->prim_channels = DCA_PRIM_CHANNELS_MAX; /* We only support DTS core */
403 for (i = 0; i < s->prim_channels; i++) {
404 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
405 if (s->subband_activity[i] > DCA_SUBBANDS)
406 s->subband_activity[i] = DCA_SUBBANDS;
408 for (i = 0; i < s->prim_channels; i++) {
409 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
410 if (s->vq_start_subband[i] > DCA_SUBBANDS)
411 s->vq_start_subband[i] = DCA_SUBBANDS;
413 get_array(&s->gb, s->joint_intensity, s->prim_channels, 3);
414 get_array(&s->gb, s->transient_huffman, s->prim_channels, 2);
415 get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
416 get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3);
418 /* Get codebooks quantization indexes */
419 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
420 for (j = 1; j < 11; j++)
421 for (i = 0; i < s->prim_channels; i++)
422 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
424 /* Get scale factor adjustment */
425 for (j = 0; j < 11; j++)
426 for (i = 0; i < s->prim_channels; i++)
427 s->scalefactor_adj[i][j] = 1;
429 for (j = 1; j < 11; j++)
430 for (i = 0; i < s->prim_channels; i++)
431 if (s->quant_index_huffman[i][j] < thr[j])
432 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
434 if (s->crc_present) {
435 /* Audio header CRC check */
436 get_bits(&s->gb, 16);
439 s->current_subframe = 0;
440 s->current_subsubframe = 0;
443 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
444 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
445 for(i = 0; i < s->prim_channels; i++){
446 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
447 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
448 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
449 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
450 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
451 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
452 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
453 for (j = 0; j < 11; j++)
454 av_log(s->avctx, AV_LOG_DEBUG, " %i",
455 s->quant_index_huffman[i][j]);
456 av_log(s->avctx, AV_LOG_DEBUG, "\n");
457 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
458 for (j = 0; j < 11; j++)
459 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
460 av_log(s->avctx, AV_LOG_DEBUG, "\n");
468 static inline int get_scale(GetBitContext *gb, int level, int value)
471 /* huffman encoded */
472 value += get_bitalloc(gb, &dca_scalefactor, level);
474 value = get_bits(gb, level + 1);
478 static int dca_subframe_header(DCAContext * s)
480 /* Primary audio coding side information */
483 s->subsubframes = get_bits(&s->gb, 2) + 1;
484 s->partial_samples = get_bits(&s->gb, 3);
485 for (j = 0; j < s->prim_channels; j++) {
486 for (k = 0; k < s->subband_activity[j]; k++)
487 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
490 /* Get prediction codebook */
491 for (j = 0; j < s->prim_channels; j++) {
492 for (k = 0; k < s->subband_activity[j]; k++) {
493 if (s->prediction_mode[j][k] > 0) {
494 /* (Prediction coefficient VQ address) */
495 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
500 /* Bit allocation index */
501 for (j = 0; j < s->prim_channels; j++) {
502 for (k = 0; k < s->vq_start_subband[j]; k++) {
503 if (s->bitalloc_huffman[j] == 6)
504 s->bitalloc[j][k] = get_bits(&s->gb, 5);
505 else if (s->bitalloc_huffman[j] == 5)
506 s->bitalloc[j][k] = get_bits(&s->gb, 4);
507 else if (s->bitalloc_huffman[j] == 7) {
508 av_log(s->avctx, AV_LOG_ERROR,
509 "Invalid bit allocation index\n");
513 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
516 if (s->bitalloc[j][k] > 26) {
517 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
518 // j, k, s->bitalloc[j][k]);
524 /* Transition mode */
525 for (j = 0; j < s->prim_channels; j++) {
526 for (k = 0; k < s->subband_activity[j]; k++) {
527 s->transition_mode[j][k] = 0;
528 if (s->subsubframes > 1 &&
529 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
530 s->transition_mode[j][k] =
531 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
536 for (j = 0; j < s->prim_channels; j++) {
537 const uint32_t *scale_table;
540 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
542 if (s->scalefactor_huffman[j] == 6)
543 scale_table = scale_factor_quant7;
545 scale_table = scale_factor_quant6;
547 /* When huffman coded, only the difference is encoded */
550 for (k = 0; k < s->subband_activity[j]; k++) {
551 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
552 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
553 s->scale_factor[j][k][0] = scale_table[scale_sum];
556 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
557 /* Get second scale factor */
558 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
559 s->scale_factor[j][k][1] = scale_table[scale_sum];
564 /* Joint subband scale factor codebook select */
565 for (j = 0; j < s->prim_channels; j++) {
566 /* Transmitted only if joint subband coding enabled */
567 if (s->joint_intensity[j] > 0)
568 s->joint_huff[j] = get_bits(&s->gb, 3);
571 /* Scale factors for joint subband coding */
572 for (j = 0; j < s->prim_channels; j++) {
575 /* Transmitted only if joint subband coding enabled */
576 if (s->joint_intensity[j] > 0) {
578 source_channel = s->joint_intensity[j] - 1;
580 /* When huffman coded, only the difference is encoded
581 * (is this valid as well for joint scales ???) */
583 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
584 scale = get_scale(&s->gb, s->joint_huff[j], 0);
585 scale += 64; /* bias */
586 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
589 if (!s->debug_flag & 0x02) {
590 av_log(s->avctx, AV_LOG_DEBUG,
591 "Joint stereo coding not supported\n");
592 s->debug_flag |= 0x02;
597 /* Stereo downmix coefficients */
598 if (s->prim_channels > 2) {
600 for (j = 0; j < s->prim_channels; j++) {
601 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
602 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
605 int am = s->amode & DCA_CHANNEL_MASK;
606 for (j = 0; j < s->prim_channels; j++) {
607 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
608 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
613 /* Dynamic range coefficient */
615 s->dynrange_coef = get_bits(&s->gb, 8);
617 /* Side information CRC check word */
618 if (s->crc_present) {
619 get_bits(&s->gb, 16);
623 * Primary audio data arrays
626 /* VQ encoded high frequency subbands */
627 for (j = 0; j < s->prim_channels; j++)
628 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
629 /* 1 vector -> 32 samples */
630 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
632 /* Low frequency effect data */
635 int lfe_samples = 2 * s->lfe * s->subsubframes;
638 for (j = lfe_samples; j < lfe_samples * 2; j++) {
639 /* Signed 8 bits int */
640 s->lfe_data[j] = get_sbits(&s->gb, 8);
643 /* Scale factor index */
644 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
646 /* Quantization step size * scale factor */
647 lfe_scale = 0.035 * s->lfe_scale_factor;
649 for (j = lfe_samples; j < lfe_samples * 2; j++)
650 s->lfe_data[j] *= lfe_scale;
654 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
655 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
657 for (j = 0; j < s->prim_channels; j++) {
658 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
659 for (k = 0; k < s->subband_activity[j]; k++)
660 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
661 av_log(s->avctx, AV_LOG_DEBUG, "\n");
663 for (j = 0; j < s->prim_channels; j++) {
664 for (k = 0; k < s->subband_activity[j]; k++)
665 av_log(s->avctx, AV_LOG_DEBUG,
666 "prediction coefs: %f, %f, %f, %f\n",
667 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
668 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
669 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
670 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
672 for (j = 0; j < s->prim_channels; j++) {
673 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
674 for (k = 0; k < s->vq_start_subband[j]; k++)
675 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
676 av_log(s->avctx, AV_LOG_DEBUG, "\n");
678 for (j = 0; j < s->prim_channels; j++) {
679 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
680 for (k = 0; k < s->subband_activity[j]; k++)
681 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
682 av_log(s->avctx, AV_LOG_DEBUG, "\n");
684 for (j = 0; j < s->prim_channels; j++) {
685 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
686 for (k = 0; k < s->subband_activity[j]; k++) {
687 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
688 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
689 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
690 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
692 av_log(s->avctx, AV_LOG_DEBUG, "\n");
694 for (j = 0; j < s->prim_channels; j++) {
695 if (s->joint_intensity[j] > 0) {
696 int source_channel = s->joint_intensity[j] - 1;
697 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
698 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
699 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
700 av_log(s->avctx, AV_LOG_DEBUG, "\n");
703 if (s->prim_channels > 2 && s->downmix) {
704 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
705 for (j = 0; j < s->prim_channels; j++) {
706 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
707 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
709 av_log(s->avctx, AV_LOG_DEBUG, "\n");
711 for (j = 0; j < s->prim_channels; j++)
712 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
713 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
715 int lfe_samples = 2 * s->lfe * s->subsubframes;
716 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
717 for (j = lfe_samples; j < lfe_samples * 2; j++)
718 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
719 av_log(s->avctx, AV_LOG_DEBUG, "\n");
726 static void qmf_32_subbands(DCAContext * s, int chans,
727 float samples_in[32][8], float *samples_out,
728 float scale, float bias)
730 const float *prCoeff;
732 DECLARE_ALIGNED_16(float, raXin[32]);
734 int hist_index= s->hist_index[chans];
735 float *subband_fir_hist2 = s->subband_fir_noidea[chans];
739 scale *= sqrt(1/8.0);
742 if (!s->multirate_inter) /* Non-perfect reconstruction */
743 prCoeff = fir_32bands_nonperfect;
744 else /* Perfect reconstruction */
745 prCoeff = fir_32bands_perfect;
747 /* Reconstructed channel sample index */
748 for (subindex = 0; subindex < 8; subindex++) {
749 float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
750 /* Load in one sample from each subband and clear inactive subbands */
751 for (i = 0; i < s->subband_activity[chans]; i++){
752 if((i-1)&2) raXin[i] = -samples_in[i][subindex];
753 else raXin[i] = samples_in[i][subindex];
758 ff_imdct_half(&s->imdct, subband_fir_hist, raXin);
760 /* Multiply by filter coefficients */
761 for (i = 0; i < 16; i++){
762 float a= subband_fir_hist2[i ];
763 float b= subband_fir_hist2[i+16];
766 for (j = 0; j < 512-hist_index; j += 64){
767 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j]);
768 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j]);
769 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
770 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
772 for ( ; j < 512; j += 64){
773 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j-512]);
774 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j-512]);
775 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
776 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
778 samples_out[i ] = a * scale + bias;
779 samples_out[i+16] = b * scale + bias;
780 subband_fir_hist2[i ] = c;
781 subband_fir_hist2[i+16] = d;
785 hist_index = (hist_index-32)&511;
787 s->hist_index[chans]= hist_index;
790 static void lfe_interpolation_fir(int decimation_select,
791 int num_deci_sample, float *samples_in,
792 float *samples_out, float scale,
795 /* samples_in: An array holding decimated samples.
796 * Samples in current subframe starts from samples_in[0],
797 * while samples_in[-1], samples_in[-2], ..., stores samples
798 * from last subframe as history.
800 * samples_out: An array holding interpolated samples
803 int decifactor, k, j;
804 const float *prCoeff;
806 int interp_index = 0; /* Index to the interpolated samples */
809 /* Select decimation filter */
810 if (decimation_select == 1) {
812 prCoeff = lfe_fir_128;
815 prCoeff = lfe_fir_64;
818 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
819 /* One decimated sample generates decifactor interpolated ones */
820 for (k = 0; k < decifactor; k++) {
822 //FIXME the coeffs are symetric, fix that
823 for (j = 0; j < 512 / decifactor; j++)
824 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
825 samples_out[interp_index++] = (rTmp * scale) + bias;
830 /* downmixing routines */
831 #define MIX_REAR1(samples, si1, rs, coef) \
832 samples[i] += samples[si1] * coef[rs][0]; \
833 samples[i+256] += samples[si1] * coef[rs][1];
835 #define MIX_REAR2(samples, si1, si2, rs, coef) \
836 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
837 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
839 #define MIX_FRONT3(samples, coef) \
841 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
842 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
844 #define DOWNMIX_TO_STEREO(op1, op2) \
845 for(i = 0; i < 256; i++){ \
850 static void dca_downmix(float *samples, int srcfmt,
851 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
855 float coef[DCA_PRIM_CHANNELS_MAX][2];
857 for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
858 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
859 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
865 case DCA_STEREO_TOTAL:
866 case DCA_STEREO_SUMDIFF:
868 av_log(NULL, 0, "Not implemented!\n");
873 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
876 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
879 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
880 MIX_REAR1(samples, i + 768, 3, coef));
883 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
886 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
887 MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
893 /* Very compact version of the block code decoder that does not use table
894 * look-up but is slightly slower */
895 static int decode_blockcode(int code, int levels, int *values)
898 int offset = (levels - 1) >> 1;
900 for (i = 0; i < 4; i++) {
901 values[i] = (code % levels) - offset;
908 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
913 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
914 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
916 static int dca_subsubframe(DCAContext * s)
919 int subsubframe = s->current_subsubframe;
921 const float *quant_step_table;
924 float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
930 /* Select quantization step size table */
931 if (s->bit_rate_index == 0x1f)
932 quant_step_table = lossless_quant_d;
934 quant_step_table = lossy_quant_d;
936 for (k = 0; k < s->prim_channels; k++) {
937 for (l = 0; l < s->vq_start_subband[k]; l++) {
940 /* Select the mid-tread linear quantizer */
941 int abits = s->bitalloc[k][l];
943 float quant_step_size = quant_step_table[abits];
947 * Determine quantization index code book and its type
950 /* Select quantization index code book */
951 int sel = s->quant_index_huffman[k][abits];
954 * Extract bits from the bit stream
957 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
958 }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
961 int block_code1, block_code2, size, levels;
964 size = abits_sizes[abits-1];
965 levels = abits_levels[abits-1];
967 block_code1 = get_bits(&s->gb, size);
968 /* FIXME Should test return value */
969 decode_blockcode(block_code1, levels, block);
970 block_code2 = get_bits(&s->gb, size);
971 decode_blockcode(block_code2, levels, &block[4]);
972 for (m = 0; m < 8; m++)
973 subband_samples[k][l][m] = block[m];
976 for (m = 0; m < 8; m++)
977 subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
981 for (m = 0; m < 8; m++)
982 subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
985 /* Deal with transients */
986 if (s->transition_mode[k][l] &&
987 subsubframe >= s->transition_mode[k][l])
988 rscale = quant_step_size * s->scale_factor[k][l][1];
990 rscale = quant_step_size * s->scale_factor[k][l][0];
992 rscale *= s->scalefactor_adj[k][sel];
994 for (m = 0; m < 8; m++)
995 subband_samples[k][l][m] *= rscale;
998 * Inverse ADPCM if in prediction mode
1000 if (s->prediction_mode[k][l]) {
1002 for (m = 0; m < 8; m++) {
1003 for (n = 1; n <= 4; n++)
1005 subband_samples[k][l][m] +=
1006 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1007 subband_samples[k][l][m - n] / 8192);
1008 else if (s->predictor_history)
1009 subband_samples[k][l][m] +=
1010 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1011 s->subband_samples_hist[k][l][m - n +
1018 * Decode VQ encoded high frequencies
1020 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1021 /* 1 vector -> 32 samples but we only need the 8 samples
1022 * for this subsubframe. */
1025 if (!s->debug_flag & 0x01) {
1026 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1027 s->debug_flag |= 0x01;
1030 for (m = 0; m < 8; m++) {
1031 subband_samples[k][l][m] =
1032 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1034 * (float) s->scale_factor[k][l][0] / 16.0;
1039 /* Check for DSYNC after subsubframe */
1040 if (s->aspf || subsubframe == s->subsubframes - 1) {
1041 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1043 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1046 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1050 /* Backup predictor history for adpcm */
1051 for (k = 0; k < s->prim_channels; k++)
1052 for (l = 0; l < s->vq_start_subband[k]; l++)
1053 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1054 4 * sizeof(subband_samples[0][0][0]));
1056 /* 32 subbands QMF */
1057 for (k = 0; k < s->prim_channels; k++) {
1058 /* static float pcm_to_double[8] =
1059 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1060 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1061 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1067 if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1068 dca_downmix(s->samples, s->amode, s->downmix_coef);
1071 /* Generate LFE samples for this subsubframe FIXME!!! */
1072 if (s->output & DCA_LFE) {
1073 int lfe_samples = 2 * s->lfe * s->subsubframes;
1075 lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1076 s->lfe_data + lfe_samples +
1077 2 * s->lfe * subsubframe,
1078 &s->samples[256 * dca_lfe_index[s->amode]],
1079 (1.0/256.0)*s->scale_bias, s->add_bias);
1080 /* Outputs 20bits pcm samples */
1087 static int dca_subframe_footer(DCAContext * s)
1089 int aux_data_count = 0, i;
1093 * Unpack optional information
1097 get_bits(&s->gb, 32);
1100 aux_data_count = get_bits(&s->gb, 6);
1102 for (i = 0; i < aux_data_count; i++)
1103 get_bits(&s->gb, 8);
1105 if (s->crc_present && (s->downmix || s->dynrange))
1106 get_bits(&s->gb, 16);
1108 lfe_samples = 2 * s->lfe * s->subsubframes;
1109 for (i = 0; i < lfe_samples; i++) {
1110 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1117 * Decode a dca frame block
1119 * @param s pointer to the DCAContext
1122 static int dca_decode_block(DCAContext * s)
1126 if (s->current_subframe >= s->subframes) {
1127 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1128 s->current_subframe, s->subframes);
1132 if (!s->current_subsubframe) {
1134 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1136 /* Read subframe header */
1137 if (dca_subframe_header(s))
1141 /* Read subsubframe */
1143 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1145 if (dca_subsubframe(s))
1149 s->current_subsubframe++;
1150 if (s->current_subsubframe >= s->subsubframes) {
1151 s->current_subsubframe = 0;
1152 s->current_subframe++;
1154 if (s->current_subframe >= s->subframes) {
1156 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1158 /* Read subframe footer */
1159 if (dca_subframe_footer(s))
1167 * Convert bitstream to one representation based on sync marker
1169 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1174 const uint16_t *ssrc = (const uint16_t *) src;
1175 uint16_t *sdst = (uint16_t *) dst;
1178 if((unsigned)src_size > (unsigned)max_size) {
1179 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1181 src_size = max_size;
1186 case DCA_MARKER_RAW_BE:
1187 memcpy(dst, src, src_size);
1189 case DCA_MARKER_RAW_LE:
1190 for (i = 0; i < (src_size + 1) >> 1; i++)
1191 *sdst++ = bswap_16(*ssrc++);
1193 case DCA_MARKER_14B_BE:
1194 case DCA_MARKER_14B_LE:
1195 init_put_bits(&pb, dst, max_size);
1196 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1197 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1198 put_bits(&pb, 14, tmp);
1200 flush_put_bits(&pb);
1201 return (put_bits_count(&pb) + 7) >> 3;
1208 * Main frame decoding function
1209 * FIXME add arguments
1211 static int dca_decode_frame(AVCodecContext * avctx,
1212 void *data, int *data_size,
1215 const uint8_t *buf = avpkt->data;
1216 int buf_size = avpkt->size;
1219 int16_t *samples = data;
1220 DCAContext *s = avctx->priv_data;
1224 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1225 if (s->dca_buffer_size == -1) {
1226 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1230 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1231 if (dca_parse_frame_header(s) < 0) {
1232 //seems like the frame is corrupt, try with the next one
1236 //set AVCodec values with parsed data
1237 avctx->sample_rate = s->sample_rate;
1238 avctx->bit_rate = s->bit_rate;
1240 channels = s->prim_channels + !!s->lfe;
1243 avctx->channel_layout = dca_core_channel_layout[s->amode];
1246 avctx->channel_layout |= CH_LOW_FREQUENCY;
1247 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1249 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1251 if(avctx->request_channels == 2 && s->prim_channels > 2) {
1253 s->output = DCA_STEREO;
1254 avctx->channel_layout = CH_LAYOUT_STEREO;
1257 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1262 /* There is nothing that prevents a dts frame to change channel configuration
1263 but FFmpeg doesn't support that so only set the channels if it is previously
1264 unset. Ideally during the first probe for channels the crc should be checked
1265 and only set avctx->channels when the crc is ok. Right now the decoder could
1266 set the channels based on a broken first frame.*/
1267 if (!avctx->channels)
1268 avctx->channels = channels;
1270 if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1272 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1273 for (i = 0; i < (s->sample_blocks / 8); i++) {
1274 dca_decode_block(s);
1275 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1276 samples += 256 * channels;
1285 * DCA initialization
1287 * @param avctx pointer to the AVCodecContext
1290 static av_cold int dca_decode_init(AVCodecContext * avctx)
1292 DCAContext *s = avctx->priv_data;
1298 dsputil_init(&s->dsp, avctx);
1299 ff_mdct_init(&s->imdct, 6, 1);
1301 for(i = 0; i < 6; i++)
1302 s->samples_chanptr[i] = s->samples + i * 256;
1303 avctx->sample_fmt = SAMPLE_FMT_S16;
1305 if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1306 s->add_bias = 385.0f;
1307 s->scale_bias = 1.0 / 32768.0;
1310 s->scale_bias = 1.0;
1312 /* allow downmixing to stereo */
1313 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1314 avctx->request_channels == 2) {
1315 avctx->channels = avctx->request_channels;
1323 static av_cold int dca_decode_end(AVCodecContext * avctx)
1325 DCAContext *s = avctx->priv_data;
1326 ff_mdct_end(&s->imdct);
1330 AVCodec dca_decoder = {
1332 .type = CODEC_TYPE_AUDIO,
1334 .priv_data_size = sizeof(DCAContext),
1335 .init = dca_decode_init,
1336 .decode = dca_decode_frame,
1337 .close = dca_decode_end,
1338 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),