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
41 #include "synth_filter.h"
45 #define DCA_PRIM_CHANNELS_MAX (5)
46 #define DCA_SUBBANDS (32)
47 #define DCA_ABITS_MAX (32) /* Should be 28 */
48 #define DCA_SUBSUBFAMES_MAX (4)
49 #define DCA_LFE_MAX (3)
65 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
66 * Some compromises have been made for special configurations. Most configurations
67 * are never used so complete accuracy is not needed.
69 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
70 * S -> side, when both rear and back are configured move one of them to the side channel
72 * All 2 channel configurations -> CH_LAYOUT_STEREO
75 static const int64_t dca_core_channel_layout[] = {
76 CH_FRONT_CENTER, ///< 1, A
77 CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
78 CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
79 CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
80 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
81 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
82 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
83 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
84 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
85 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
86 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
87 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
88 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
89 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
90 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
91 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
94 static const int8_t dca_lfe_index[] = {
95 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
98 static const int8_t dca_channel_reorder_lfe[][8] = {
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 { 0, 1, -1, -1, -1, -1, -1, -1},
103 { 0, 1, -1, -1, -1, -1, -1, -1},
104 { 2, 0, 1, -1, -1, -1, -1, -1},
105 { 0, 1, 3, -1, -1, -1, -1, -1},
106 { 2, 0, 1, 4, -1, -1, -1, -1},
107 { 0, 1, 3, 4, -1, -1, -1, -1},
108 { 2, 0, 1, 4, 5, -1, -1, -1},
109 { 3, 4, 0, 1, 5, 6, -1, -1},
110 { 2, 0, 1, 4, 5, 6, -1, -1},
111 { 0, 6, 4, 5, 2, 3, -1, -1},
112 { 4, 2, 5, 0, 1, 6, 7, -1},
113 { 5, 6, 0, 1, 7, 3, 8, 4},
114 { 4, 2, 5, 0, 1, 6, 8, 7},
117 static const int8_t dca_channel_reorder_nolfe[][8] = {
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 { 0, 1, -1, -1, -1, -1, -1, -1},
122 { 0, 1, -1, -1, -1, -1, -1, -1},
123 { 2, 0, 1, -1, -1, -1, -1, -1},
124 { 0, 1, 2, -1, -1, -1, -1, -1},
125 { 2, 0, 1, 3, -1, -1, -1, -1},
126 { 0, 1, 2, 3, -1, -1, -1, -1},
127 { 2, 0, 1, 3, 4, -1, -1, -1},
128 { 2, 3, 0, 1, 4, 5, -1, -1},
129 { 2, 0, 1, 3, 4, 5, -1, -1},
130 { 0, 5, 3, 4, 1, 2, -1, -1},
131 { 3, 2, 4, 0, 1, 5, 6, -1},
132 { 4, 5, 0, 1, 6, 2, 7, 3},
133 { 3, 2, 4, 0, 1, 5, 7, 6},
137 #define DCA_DOLBY 101 /* FIXME */
139 #define DCA_CHANNEL_BITS 6
140 #define DCA_CHANNEL_MASK 0x3F
144 #define HEADER_SIZE 14
146 #define DCA_MAX_FRAME_SIZE 16384
148 /** Bit allocation */
150 int offset; ///< code values offset
151 int maxbits[8]; ///< max bits in VLC
152 int wrap; ///< wrap for get_vlc2()
153 VLC vlc[8]; ///< actual codes
156 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
157 static BitAlloc dca_tmode; ///< transition mode VLCs
158 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
159 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
161 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
163 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
167 AVCodecContext *avctx;
169 int frame_type; ///< type of the current frame
170 int samples_deficit; ///< deficit sample count
171 int crc_present; ///< crc is present in the bitstream
172 int sample_blocks; ///< number of PCM sample blocks
173 int frame_size; ///< primary frame byte size
174 int amode; ///< audio channels arrangement
175 int sample_rate; ///< audio sampling rate
176 int bit_rate; ///< transmission bit rate
177 int bit_rate_index; ///< transmission bit rate index
179 int downmix; ///< embedded downmix enabled
180 int dynrange; ///< embedded dynamic range flag
181 int timestamp; ///< embedded time stamp flag
182 int aux_data; ///< auxiliary data flag
183 int hdcd; ///< source material is mastered in HDCD
184 int ext_descr; ///< extension audio descriptor flag
185 int ext_coding; ///< extended coding flag
186 int aspf; ///< audio sync word insertion flag
187 int lfe; ///< low frequency effects flag
188 int predictor_history; ///< predictor history flag
189 int header_crc; ///< header crc check bytes
190 int multirate_inter; ///< multirate interpolator switch
191 int version; ///< encoder software revision
192 int copy_history; ///< copy history
193 int source_pcm_res; ///< source pcm resolution
194 int front_sum; ///< front sum/difference flag
195 int surround_sum; ///< surround sum/difference flag
196 int dialog_norm; ///< dialog normalisation parameter
198 /* Primary audio coding header */
199 int subframes; ///< number of subframes
200 int total_channels; ///< number of channels including extensions
201 int prim_channels; ///< number of primary audio channels
202 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
203 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
204 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
205 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
206 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
207 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
208 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
209 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
211 /* Primary audio coding side information */
212 int subsubframes; ///< number of subsubframes
213 int partial_samples; ///< partial subsubframe samples count
214 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
215 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
216 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
217 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
218 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
219 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
220 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
221 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
222 int dynrange_coef; ///< dynamic range coefficient
224 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
226 float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
227 2 /*history */ ]; ///< Low frequency effect data
228 int lfe_scale_factor;
230 /* Subband samples history (for ADPCM) */
231 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
232 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
233 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
234 int hist_index[DCA_PRIM_CHANNELS_MAX];
235 DECLARE_ALIGNED(16, float, raXin)[32];
237 int output; ///< type of output
238 float add_bias; ///< output bias
239 float scale_bias; ///< output scale
241 DECLARE_ALIGNED(16, float, samples)[1536]; /* 6 * 256 = 1536, might only need 5 */
242 const float *samples_chanptr[6];
244 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
245 int dca_buffer_size; ///< how much data is in the dca_buffer
247 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
249 /* Current position in DCA frame */
250 int current_subframe;
251 int current_subsubframe;
253 int debug_flag; ///< used for suppressing repeated error messages output
258 static const uint16_t dca_vlc_offs[] = {
259 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
260 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
261 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
262 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
263 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
264 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
267 static av_cold void dca_init_vlcs(void)
269 static int vlcs_initialized = 0;
271 static VLC_TYPE dca_table[23622][2];
273 if (vlcs_initialized)
276 dca_bitalloc_index.offset = 1;
277 dca_bitalloc_index.wrap = 2;
278 for (i = 0; i < 5; i++) {
279 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
280 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
281 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
282 bitalloc_12_bits[i], 1, 1,
283 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
285 dca_scalefactor.offset = -64;
286 dca_scalefactor.wrap = 2;
287 for (i = 0; i < 5; i++) {
288 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
289 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
290 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
291 scales_bits[i], 1, 1,
292 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
294 dca_tmode.offset = 0;
296 for (i = 0; i < 4; i++) {
297 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
298 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
299 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
301 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
304 for(i = 0; i < 10; i++)
305 for(j = 0; j < 7; j++){
306 if(!bitalloc_codes[i][j]) break;
307 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
308 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
309 dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
310 dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
311 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
313 bitalloc_bits[i][j], 1, 1,
314 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
317 vlcs_initialized = 1;
320 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
323 *dst++ = get_bits(gb, bits);
326 static int dca_parse_frame_header(DCAContext * s)
329 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
330 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
331 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
333 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
336 get_bits(&s->gb, 32);
339 s->frame_type = get_bits(&s->gb, 1);
340 s->samples_deficit = get_bits(&s->gb, 5) + 1;
341 s->crc_present = get_bits(&s->gb, 1);
342 s->sample_blocks = get_bits(&s->gb, 7) + 1;
343 s->frame_size = get_bits(&s->gb, 14) + 1;
344 if (s->frame_size < 95)
346 s->amode = get_bits(&s->gb, 6);
347 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
350 s->bit_rate_index = get_bits(&s->gb, 5);
351 s->bit_rate = dca_bit_rates[s->bit_rate_index];
355 s->downmix = get_bits(&s->gb, 1);
356 s->dynrange = get_bits(&s->gb, 1);
357 s->timestamp = get_bits(&s->gb, 1);
358 s->aux_data = get_bits(&s->gb, 1);
359 s->hdcd = get_bits(&s->gb, 1);
360 s->ext_descr = get_bits(&s->gb, 3);
361 s->ext_coding = get_bits(&s->gb, 1);
362 s->aspf = get_bits(&s->gb, 1);
363 s->lfe = get_bits(&s->gb, 2);
364 s->predictor_history = get_bits(&s->gb, 1);
366 /* TODO: check CRC */
368 s->header_crc = get_bits(&s->gb, 16);
370 s->multirate_inter = get_bits(&s->gb, 1);
371 s->version = get_bits(&s->gb, 4);
372 s->copy_history = get_bits(&s->gb, 2);
373 s->source_pcm_res = get_bits(&s->gb, 3);
374 s->front_sum = get_bits(&s->gb, 1);
375 s->surround_sum = get_bits(&s->gb, 1);
376 s->dialog_norm = get_bits(&s->gb, 4);
378 /* FIXME: channels mixing levels */
379 s->output = s->amode;
380 if(s->lfe) s->output |= DCA_LFE;
383 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
384 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
385 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
386 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
387 s->sample_blocks, s->sample_blocks * 32);
388 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
389 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
390 s->amode, dca_channels[s->amode]);
391 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
393 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
395 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
396 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
397 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
398 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
399 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
400 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
401 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
402 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
403 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
404 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
405 s->predictor_history);
406 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
407 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
409 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
410 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
411 av_log(s->avctx, AV_LOG_DEBUG,
412 "source pcm resolution: %i (%i bits/sample)\n",
413 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
414 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
415 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
416 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
417 av_log(s->avctx, AV_LOG_DEBUG, "\n");
420 /* Primary audio coding header */
421 s->subframes = get_bits(&s->gb, 4) + 1;
422 s->total_channels = get_bits(&s->gb, 3) + 1;
423 s->prim_channels = s->total_channels;
424 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
425 s->prim_channels = DCA_PRIM_CHANNELS_MAX; /* We only support DTS core */
428 for (i = 0; i < s->prim_channels; i++) {
429 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
430 if (s->subband_activity[i] > DCA_SUBBANDS)
431 s->subband_activity[i] = DCA_SUBBANDS;
433 for (i = 0; i < s->prim_channels; i++) {
434 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
435 if (s->vq_start_subband[i] > DCA_SUBBANDS)
436 s->vq_start_subband[i] = DCA_SUBBANDS;
438 get_array(&s->gb, s->joint_intensity, s->prim_channels, 3);
439 get_array(&s->gb, s->transient_huffman, s->prim_channels, 2);
440 get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
441 get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3);
443 /* Get codebooks quantization indexes */
444 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
445 for (j = 1; j < 11; j++)
446 for (i = 0; i < s->prim_channels; i++)
447 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
449 /* Get scale factor adjustment */
450 for (j = 0; j < 11; j++)
451 for (i = 0; i < s->prim_channels; i++)
452 s->scalefactor_adj[i][j] = 1;
454 for (j = 1; j < 11; j++)
455 for (i = 0; i < s->prim_channels; i++)
456 if (s->quant_index_huffman[i][j] < thr[j])
457 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
459 if (s->crc_present) {
460 /* Audio header CRC check */
461 get_bits(&s->gb, 16);
464 s->current_subframe = 0;
465 s->current_subsubframe = 0;
468 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
469 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
470 for(i = 0; i < s->prim_channels; i++){
471 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
472 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
473 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
474 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
475 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
476 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
477 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
478 for (j = 0; j < 11; j++)
479 av_log(s->avctx, AV_LOG_DEBUG, " %i",
480 s->quant_index_huffman[i][j]);
481 av_log(s->avctx, AV_LOG_DEBUG, "\n");
482 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
483 for (j = 0; j < 11; j++)
484 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
485 av_log(s->avctx, AV_LOG_DEBUG, "\n");
493 static inline int get_scale(GetBitContext *gb, int level, int value)
496 /* huffman encoded */
497 value += get_bitalloc(gb, &dca_scalefactor, level);
499 value = get_bits(gb, level + 1);
503 static int dca_subframe_header(DCAContext * s)
505 /* Primary audio coding side information */
508 s->subsubframes = get_bits(&s->gb, 2) + 1;
509 s->partial_samples = get_bits(&s->gb, 3);
510 for (j = 0; j < s->prim_channels; j++) {
511 for (k = 0; k < s->subband_activity[j]; k++)
512 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
515 /* Get prediction codebook */
516 for (j = 0; j < s->prim_channels; j++) {
517 for (k = 0; k < s->subband_activity[j]; k++) {
518 if (s->prediction_mode[j][k] > 0) {
519 /* (Prediction coefficient VQ address) */
520 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
525 /* Bit allocation index */
526 for (j = 0; j < s->prim_channels; j++) {
527 for (k = 0; k < s->vq_start_subband[j]; k++) {
528 if (s->bitalloc_huffman[j] == 6)
529 s->bitalloc[j][k] = get_bits(&s->gb, 5);
530 else if (s->bitalloc_huffman[j] == 5)
531 s->bitalloc[j][k] = get_bits(&s->gb, 4);
532 else if (s->bitalloc_huffman[j] == 7) {
533 av_log(s->avctx, AV_LOG_ERROR,
534 "Invalid bit allocation index\n");
538 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
541 if (s->bitalloc[j][k] > 26) {
542 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
543 // j, k, s->bitalloc[j][k]);
549 /* Transition mode */
550 for (j = 0; j < s->prim_channels; j++) {
551 for (k = 0; k < s->subband_activity[j]; k++) {
552 s->transition_mode[j][k] = 0;
553 if (s->subsubframes > 1 &&
554 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
555 s->transition_mode[j][k] =
556 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
561 for (j = 0; j < s->prim_channels; j++) {
562 const uint32_t *scale_table;
565 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
567 if (s->scalefactor_huffman[j] == 6)
568 scale_table = scale_factor_quant7;
570 scale_table = scale_factor_quant6;
572 /* When huffman coded, only the difference is encoded */
575 for (k = 0; k < s->subband_activity[j]; k++) {
576 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
577 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
578 s->scale_factor[j][k][0] = scale_table[scale_sum];
581 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
582 /* Get second scale factor */
583 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
584 s->scale_factor[j][k][1] = scale_table[scale_sum];
589 /* Joint subband scale factor codebook select */
590 for (j = 0; j < s->prim_channels; j++) {
591 /* Transmitted only if joint subband coding enabled */
592 if (s->joint_intensity[j] > 0)
593 s->joint_huff[j] = get_bits(&s->gb, 3);
596 /* Scale factors for joint subband coding */
597 for (j = 0; j < s->prim_channels; j++) {
600 /* Transmitted only if joint subband coding enabled */
601 if (s->joint_intensity[j] > 0) {
603 source_channel = s->joint_intensity[j] - 1;
605 /* When huffman coded, only the difference is encoded
606 * (is this valid as well for joint scales ???) */
608 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
609 scale = get_scale(&s->gb, s->joint_huff[j], 0);
610 scale += 64; /* bias */
611 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
614 if (!(s->debug_flag & 0x02)) {
615 av_log(s->avctx, AV_LOG_DEBUG,
616 "Joint stereo coding not supported\n");
617 s->debug_flag |= 0x02;
622 /* Stereo downmix coefficients */
623 if (s->prim_channels > 2) {
625 for (j = 0; j < s->prim_channels; j++) {
626 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
627 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
630 int am = s->amode & DCA_CHANNEL_MASK;
631 for (j = 0; j < s->prim_channels; j++) {
632 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
633 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
638 /* Dynamic range coefficient */
640 s->dynrange_coef = get_bits(&s->gb, 8);
642 /* Side information CRC check word */
643 if (s->crc_present) {
644 get_bits(&s->gb, 16);
648 * Primary audio data arrays
651 /* VQ encoded high frequency subbands */
652 for (j = 0; j < s->prim_channels; j++)
653 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
654 /* 1 vector -> 32 samples */
655 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
657 /* Low frequency effect data */
660 int lfe_samples = 2 * s->lfe * s->subsubframes;
663 for (j = lfe_samples; j < lfe_samples * 2; j++) {
664 /* Signed 8 bits int */
665 s->lfe_data[j] = get_sbits(&s->gb, 8);
668 /* Scale factor index */
669 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
671 /* Quantization step size * scale factor */
672 lfe_scale = 0.035 * s->lfe_scale_factor;
674 for (j = lfe_samples; j < lfe_samples * 2; j++)
675 s->lfe_data[j] *= lfe_scale;
679 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
680 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
682 for (j = 0; j < s->prim_channels; j++) {
683 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
684 for (k = 0; k < s->subband_activity[j]; k++)
685 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
686 av_log(s->avctx, AV_LOG_DEBUG, "\n");
688 for (j = 0; j < s->prim_channels; j++) {
689 for (k = 0; k < s->subband_activity[j]; k++)
690 av_log(s->avctx, AV_LOG_DEBUG,
691 "prediction coefs: %f, %f, %f, %f\n",
692 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
693 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
694 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
695 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
697 for (j = 0; j < s->prim_channels; j++) {
698 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
699 for (k = 0; k < s->vq_start_subband[j]; k++)
700 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
701 av_log(s->avctx, AV_LOG_DEBUG, "\n");
703 for (j = 0; j < s->prim_channels; j++) {
704 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
705 for (k = 0; k < s->subband_activity[j]; k++)
706 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
707 av_log(s->avctx, AV_LOG_DEBUG, "\n");
709 for (j = 0; j < s->prim_channels; j++) {
710 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
711 for (k = 0; k < s->subband_activity[j]; k++) {
712 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
713 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
714 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
715 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
717 av_log(s->avctx, AV_LOG_DEBUG, "\n");
719 for (j = 0; j < s->prim_channels; j++) {
720 if (s->joint_intensity[j] > 0) {
721 int source_channel = s->joint_intensity[j] - 1;
722 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
723 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
724 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
725 av_log(s->avctx, AV_LOG_DEBUG, "\n");
728 if (s->prim_channels > 2 && s->downmix) {
729 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
730 for (j = 0; j < s->prim_channels; j++) {
731 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
732 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
734 av_log(s->avctx, AV_LOG_DEBUG, "\n");
736 for (j = 0; j < s->prim_channels; j++)
737 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
738 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
740 int lfe_samples = 2 * s->lfe * s->subsubframes;
741 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
742 for (j = lfe_samples; j < lfe_samples * 2; j++)
743 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
744 av_log(s->avctx, AV_LOG_DEBUG, "\n");
751 static void qmf_32_subbands(DCAContext * s, int chans,
752 float samples_in[32][8], float *samples_out,
753 float scale, float bias)
755 const float *prCoeff;
760 scale *= sqrt(1/8.0);
763 if (!s->multirate_inter) /* Non-perfect reconstruction */
764 prCoeff = fir_32bands_nonperfect;
765 else /* Perfect reconstruction */
766 prCoeff = fir_32bands_perfect;
768 /* Reconstructed channel sample index */
769 for (subindex = 0; subindex < 8; subindex++) {
770 /* Load in one sample from each subband and clear inactive subbands */
771 for (i = 0; i < s->subband_activity[chans]; i++){
772 if((i-1)&2) s->raXin[i] = -samples_in[i][subindex];
773 else s->raXin[i] = samples_in[i][subindex];
778 ff_synth_filter_float(&s->imdct,
779 s->subband_fir_hist[chans], &s->hist_index[chans],
780 s->subband_fir_noidea[chans], prCoeff,
781 samples_out, s->raXin, scale, bias);
787 static void lfe_interpolation_fir(int decimation_select,
788 int num_deci_sample, float *samples_in,
789 float *samples_out, float scale,
792 /* samples_in: An array holding decimated samples.
793 * Samples in current subframe starts from samples_in[0],
794 * while samples_in[-1], samples_in[-2], ..., stores samples
795 * from last subframe as history.
797 * samples_out: An array holding interpolated samples
800 int decifactor, k, j;
801 const float *prCoeff;
803 int interp_index = 0; /* Index to the interpolated samples */
806 /* Select decimation filter */
807 if (decimation_select == 1) {
809 prCoeff = lfe_fir_128;
812 prCoeff = lfe_fir_64;
815 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
816 /* One decimated sample generates decifactor interpolated ones */
817 for (k = 0; k < decifactor; k++) {
819 //FIXME the coeffs are symetric, fix that
820 for (j = 0; j < 512 / decifactor; j++)
821 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
822 samples_out[interp_index++] = (rTmp * scale) + bias;
827 /* downmixing routines */
828 #define MIX_REAR1(samples, si1, rs, coef) \
829 samples[i] += samples[si1] * coef[rs][0]; \
830 samples[i+256] += samples[si1] * coef[rs][1];
832 #define MIX_REAR2(samples, si1, si2, rs, coef) \
833 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
834 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
836 #define MIX_FRONT3(samples, coef) \
838 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
839 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
841 #define DOWNMIX_TO_STEREO(op1, op2) \
842 for(i = 0; i < 256; i++){ \
847 static void dca_downmix(float *samples, int srcfmt,
848 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
852 float coef[DCA_PRIM_CHANNELS_MAX][2];
854 for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
855 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
856 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
862 case DCA_STEREO_TOTAL:
863 case DCA_STEREO_SUMDIFF:
865 av_log(NULL, 0, "Not implemented!\n");
870 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
873 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
876 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
877 MIX_REAR1(samples, i + 768, 3, coef));
880 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
883 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
884 MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
890 /* Very compact version of the block code decoder that does not use table
891 * look-up but is slightly slower */
892 static int decode_blockcode(int code, int levels, int *values)
895 int offset = (levels - 1) >> 1;
897 for (i = 0; i < 4; i++) {
898 values[i] = (code % levels) - offset;
905 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
910 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
911 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
913 static int dca_subsubframe(DCAContext * s)
916 int subsubframe = s->current_subsubframe;
918 const float *quant_step_table;
921 float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
927 /* Select quantization step size table */
928 if (s->bit_rate_index == 0x1f)
929 quant_step_table = lossless_quant_d;
931 quant_step_table = lossy_quant_d;
933 for (k = 0; k < s->prim_channels; k++) {
934 for (l = 0; l < s->vq_start_subband[k]; l++) {
937 /* Select the mid-tread linear quantizer */
938 int abits = s->bitalloc[k][l];
940 float quant_step_size = quant_step_table[abits];
944 * Determine quantization index code book and its type
947 /* Select quantization index code book */
948 int sel = s->quant_index_huffman[k][abits];
951 * Extract bits from the bit stream
954 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
955 }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
958 int block_code1, block_code2, size, levels;
961 size = abits_sizes[abits-1];
962 levels = abits_levels[abits-1];
964 block_code1 = get_bits(&s->gb, size);
965 /* FIXME Should test return value */
966 decode_blockcode(block_code1, levels, block);
967 block_code2 = get_bits(&s->gb, size);
968 decode_blockcode(block_code2, levels, &block[4]);
969 for (m = 0; m < 8; m++)
970 subband_samples[k][l][m] = block[m];
973 for (m = 0; m < 8; m++)
974 subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
978 for (m = 0; m < 8; m++)
979 subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
982 /* Deal with transients */
983 if (s->transition_mode[k][l] &&
984 subsubframe >= s->transition_mode[k][l])
985 rscale = quant_step_size * s->scale_factor[k][l][1];
987 rscale = quant_step_size * s->scale_factor[k][l][0];
989 rscale *= s->scalefactor_adj[k][sel];
991 for (m = 0; m < 8; m++)
992 subband_samples[k][l][m] *= rscale;
995 * Inverse ADPCM if in prediction mode
997 if (s->prediction_mode[k][l]) {
999 for (m = 0; m < 8; m++) {
1000 for (n = 1; n <= 4; n++)
1002 subband_samples[k][l][m] +=
1003 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1004 subband_samples[k][l][m - n] / 8192);
1005 else if (s->predictor_history)
1006 subband_samples[k][l][m] +=
1007 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1008 s->subband_samples_hist[k][l][m - n +
1015 * Decode VQ encoded high frequencies
1017 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1018 /* 1 vector -> 32 samples but we only need the 8 samples
1019 * for this subsubframe. */
1022 if (!s->debug_flag & 0x01) {
1023 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1024 s->debug_flag |= 0x01;
1027 for (m = 0; m < 8; m++) {
1028 subband_samples[k][l][m] =
1029 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1031 * (float) s->scale_factor[k][l][0] / 16.0;
1036 /* Check for DSYNC after subsubframe */
1037 if (s->aspf || subsubframe == s->subsubframes - 1) {
1038 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1040 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1043 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1047 /* Backup predictor history for adpcm */
1048 for (k = 0; k < s->prim_channels; k++)
1049 for (l = 0; l < s->vq_start_subband[k]; l++)
1050 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1051 4 * sizeof(subband_samples[0][0][0]));
1053 /* 32 subbands QMF */
1054 for (k = 0; k < s->prim_channels; k++) {
1055 /* static float pcm_to_double[8] =
1056 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1057 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1058 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1064 if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1065 dca_downmix(s->samples, s->amode, s->downmix_coef);
1068 /* Generate LFE samples for this subsubframe FIXME!!! */
1069 if (s->output & DCA_LFE) {
1070 int lfe_samples = 2 * s->lfe * s->subsubframes;
1072 lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1073 s->lfe_data + lfe_samples +
1074 2 * s->lfe * subsubframe,
1075 &s->samples[256 * dca_lfe_index[s->amode]],
1076 (1.0/256.0)*s->scale_bias, s->add_bias);
1077 /* Outputs 20bits pcm samples */
1084 static int dca_subframe_footer(DCAContext * s)
1086 int aux_data_count = 0, i;
1090 * Unpack optional information
1094 get_bits(&s->gb, 32);
1097 aux_data_count = get_bits(&s->gb, 6);
1099 for (i = 0; i < aux_data_count; i++)
1100 get_bits(&s->gb, 8);
1102 if (s->crc_present && (s->downmix || s->dynrange))
1103 get_bits(&s->gb, 16);
1105 lfe_samples = 2 * s->lfe * s->subsubframes;
1106 for (i = 0; i < lfe_samples; i++) {
1107 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1114 * Decode a dca frame block
1116 * @param s pointer to the DCAContext
1119 static int dca_decode_block(DCAContext * s)
1123 if (s->current_subframe >= s->subframes) {
1124 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1125 s->current_subframe, s->subframes);
1129 if (!s->current_subsubframe) {
1131 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1133 /* Read subframe header */
1134 if (dca_subframe_header(s))
1138 /* Read subsubframe */
1140 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1142 if (dca_subsubframe(s))
1146 s->current_subsubframe++;
1147 if (s->current_subsubframe >= s->subsubframes) {
1148 s->current_subsubframe = 0;
1149 s->current_subframe++;
1151 if (s->current_subframe >= s->subframes) {
1153 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1155 /* Read subframe footer */
1156 if (dca_subframe_footer(s))
1164 * Convert bitstream to one representation based on sync marker
1166 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1171 const uint16_t *ssrc = (const uint16_t *) src;
1172 uint16_t *sdst = (uint16_t *) dst;
1175 if((unsigned)src_size > (unsigned)max_size) {
1176 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1178 src_size = max_size;
1183 case DCA_MARKER_RAW_BE:
1184 memcpy(dst, src, src_size);
1186 case DCA_MARKER_RAW_LE:
1187 for (i = 0; i < (src_size + 1) >> 1; i++)
1188 *sdst++ = bswap_16(*ssrc++);
1190 case DCA_MARKER_14B_BE:
1191 case DCA_MARKER_14B_LE:
1192 init_put_bits(&pb, dst, max_size);
1193 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1194 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1195 put_bits(&pb, 14, tmp);
1197 flush_put_bits(&pb);
1198 return (put_bits_count(&pb) + 7) >> 3;
1205 * Main frame decoding function
1206 * FIXME add arguments
1208 static int dca_decode_frame(AVCodecContext * avctx,
1209 void *data, int *data_size,
1212 const uint8_t *buf = avpkt->data;
1213 int buf_size = avpkt->size;
1216 int16_t *samples = data;
1217 DCAContext *s = avctx->priv_data;
1221 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1222 if (s->dca_buffer_size == -1) {
1223 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1227 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1228 if (dca_parse_frame_header(s) < 0) {
1229 //seems like the frame is corrupt, try with the next one
1233 //set AVCodec values with parsed data
1234 avctx->sample_rate = s->sample_rate;
1235 avctx->bit_rate = s->bit_rate;
1237 channels = s->prim_channels + !!s->lfe;
1240 avctx->channel_layout = dca_core_channel_layout[s->amode];
1243 avctx->channel_layout |= CH_LOW_FREQUENCY;
1244 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1246 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1248 if (s->prim_channels > 0 &&
1249 s->channel_order_tab[s->prim_channels - 1] < 0)
1252 if(avctx->request_channels == 2 && s->prim_channels > 2) {
1254 s->output = DCA_STEREO;
1255 avctx->channel_layout = CH_LAYOUT_STEREO;
1258 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1263 /* There is nothing that prevents a dts frame to change channel configuration
1264 but FFmpeg doesn't support that so only set the channels if it is previously
1265 unset. Ideally during the first probe for channels the crc should be checked
1266 and only set avctx->channels when the crc is ok. Right now the decoder could
1267 set the channels based on a broken first frame.*/
1268 if (!avctx->channels)
1269 avctx->channels = channels;
1271 if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1273 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1274 for (i = 0; i < (s->sample_blocks / 8); i++) {
1275 dca_decode_block(s);
1276 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1277 samples += 256 * channels;
1286 * DCA initialization
1288 * @param avctx pointer to the AVCodecContext
1291 static av_cold int dca_decode_init(AVCodecContext * avctx)
1293 DCAContext *s = avctx->priv_data;
1299 dsputil_init(&s->dsp, avctx);
1300 ff_mdct_init(&s->imdct, 6, 1, 1.0);
1302 for(i = 0; i < 6; i++)
1303 s->samples_chanptr[i] = s->samples + i * 256;
1304 avctx->sample_fmt = SAMPLE_FMT_S16;
1306 if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
1307 s->add_bias = 385.0f;
1308 s->scale_bias = 1.0 / 32768.0;
1311 s->scale_bias = 1.0;
1313 /* allow downmixing to stereo */
1314 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1315 avctx->request_channels == 2) {
1316 avctx->channels = avctx->request_channels;
1324 static av_cold int dca_decode_end(AVCodecContext * avctx)
1326 DCAContext *s = avctx->priv_data;
1327 ff_mdct_end(&s->imdct);
1331 AVCodec dca_decoder = {
1333 .type = AVMEDIA_TYPE_AUDIO,
1335 .priv_data_size = sizeof(DCAContext),
1336 .init = dca_decode_init,
1337 .decode = dca_decode_frame,
1338 .close = dca_decode_end,
1339 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),