?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
[ffmpeg-lucabe.git] / libavcodec / dca.c
blob8dfec8e9a913df08d1d635445eea7a52377321d8
1 /*
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
7 *
8 * This file is part of FFmpeg.
9 *
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.
14 *
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.
19 *
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
23 */
24
25 /**
26 * @file libavcodec/dca.c
27 */
28
29 #include <math.h>
30 #include <stddef.h>
31 #include <stdio.h>
32
33 #include "avcodec.h"
34 #include "dsputil.h"
35 #include "bitstream.h"
36 #include "dcadata.h"
37 #include "dcahuff.h"
38 #include "dca.h"
39
40 //#define TRACE
41
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)
47
48 enum DCAMode {
49 DCA_MONO = 0,
50 DCA_CHANNEL,
51 DCA_STEREO,
52 DCA_STEREO_SUMDIFF,
53 DCA_STEREO_TOTAL,
54 DCA_3F,
55 DCA_2F1R,
56 DCA_3F1R,
57 DCA_2F2R,
58 DCA_3F2R,
59 DCA_4F2R
60 };
61
62 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
63 * Some compromises have been made for special configurations. Most configurations
64 * are never used so complete accuracy is not needed.
65 *
66 * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
67 * S -> side, when both rear and back are configured move one of them to the side channel
68 * OV -> center back
69 * All 2 channel configurations -> CH_LAYOUT_STEREO
70 */
71
72 static const int64_t dca_core_channel_layout[] = {
73 CH_FRONT_CENTER, ///< 1, A
74 CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
75 CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
76 CH_LAYOUT_STEREO, ///< 2, (L+R) + (L-R) (sum-difference)
77 CH_LAYOUT_STEREO, ///< 2, LT +RT (left and right total)
78 CH_LAYOUT_STEREO|CH_FRONT_CENTER, ///< 3, C+L+R
79 CH_LAYOUT_STEREO|CH_BACK_CENTER, ///< 3, L+R+S
80 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 4, C + L + R+ S
81 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 4, L + R +SL+ SR
82 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 5, C + L + R+ SL+SR
83 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
84 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER, ///< 6, C + L + R+ LR + RR + OV
85 CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 6, CF+ CR+LF+ RF+LR + RR
86 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
87 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2
88 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR
89 };
90
91 static const int8_t dca_lfe_index[] = {
92 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
93 };
94
95 static const int8_t dca_channel_reorder_lfe[][8] = {
96 { 0, -1, -1, -1, -1, -1, -1, -1},
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 { 2, 0, 1, -1, -1, -1, -1, -1},
102 { 0, 1, 3, -1, -1, -1, -1, -1},
103 { 2, 0, 1, 4, -1, -1, -1, -1},
104 { 0, 1, 3, 4, -1, -1, -1, -1},
105 { 2, 0, 1, 4, 5, -1, -1, -1},
106 { 3, 4, 0, 1, 5, 6, -1, -1},
107 { 2, 0, 1, 4, 5, 6, -1, -1},
108 { 0, 6, 4, 5, 2, 3, -1, -1},
109 { 4, 2, 5, 0, 1, 6, 7, -1},
110 { 5, 6, 0, 1, 7, 3, 8, 4},
111 { 4, 2, 5, 0, 1, 6, 8, 7},
112 };
113
114 static const int8_t dca_channel_reorder_nolfe[][8] = {
115 { 0, -1, -1, -1, -1, -1, -1, -1},
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 { 2, 0, 1, -1, -1, -1, -1, -1},
121 { 0, 1, 2, -1, -1, -1, -1, -1},
122 { 2, 0, 1, 3, -1, -1, -1, -1},
123 { 0, 1, 2, 3, -1, -1, -1, -1},
124 { 2, 0, 1, 3, 4, -1, -1, -1},
125 { 2, 3, 0, 1, 4, 5, -1, -1},
126 { 2, 0, 1, 3, 4, 5, -1, -1},
127 { 0, 5, 3, 4, 1, 2, -1, -1},
128 { 3, 2, 4, 0, 1, 5, 6, -1},
129 { 4, 5, 0, 1, 6, 2, 7, 3},
130 { 3, 2, 4, 0, 1, 5, 7, 6},
131 };
132
133
134 #define DCA_DOLBY 101 /* FIXME */
135
136 #define DCA_CHANNEL_BITS 6
137 #define DCA_CHANNEL_MASK 0x3F
138
139 #define DCA_LFE 0x80
140
141 #define HEADER_SIZE 14
142
143 #define DCA_MAX_FRAME_SIZE 16384
144
145 /** Bit allocation */
146 typedef struct {
147 int offset; ///< code values offset
148 int maxbits[8]; ///< max bits in VLC
149 int wrap; ///< wrap for get_vlc2()
150 VLC vlc[8]; ///< actual codes
151 } BitAlloc;
152
153 static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
154 static BitAlloc dca_tmode; ///< transition mode VLCs
155 static BitAlloc dca_scalefactor; ///< scalefactor VLCs
156 static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
157
158 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
159 {
160 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
161 }
162
163 typedef struct {
164 AVCodecContext *avctx;
165 /* Frame header */
166 int frame_type; ///< type of the current frame
167 int samples_deficit; ///< deficit sample count
168 int crc_present; ///< crc is present in the bitstream
169 int sample_blocks; ///< number of PCM sample blocks
170 int frame_size; ///< primary frame byte size
171 int amode; ///< audio channels arrangement
172 int sample_rate; ///< audio sampling rate
173 int bit_rate; ///< transmission bit rate
174 int bit_rate_index; ///< transmission bit rate index
175
176 int downmix; ///< embedded downmix enabled
177 int dynrange; ///< embedded dynamic range flag
178 int timestamp; ///< embedded time stamp flag
179 int aux_data; ///< auxiliary data flag
180 int hdcd; ///< source material is mastered in HDCD
181 int ext_descr; ///< extension audio descriptor flag
182 int ext_coding; ///< extended coding flag
183 int aspf; ///< audio sync word insertion flag
184 int lfe; ///< low frequency effects flag
185 int predictor_history; ///< predictor history flag
186 int header_crc; ///< header crc check bytes
187 int multirate_inter; ///< multirate interpolator switch
188 int version; ///< encoder software revision
189 int copy_history; ///< copy history
190 int source_pcm_res; ///< source pcm resolution
191 int front_sum; ///< front sum/difference flag
192 int surround_sum; ///< surround sum/difference flag
193 int dialog_norm; ///< dialog normalisation parameter
194
195 /* Primary audio coding header */
196 int subframes; ///< number of subframes
197 int total_channels; ///< number of channels including extensions
198 int prim_channels; ///< number of primary audio channels
199 int subband_activity[DCA_PRIM_CHANNELS_MAX]; ///< subband activity count
200 int vq_start_subband[DCA_PRIM_CHANNELS_MAX]; ///< high frequency vq start subband
201 int joint_intensity[DCA_PRIM_CHANNELS_MAX]; ///< joint intensity coding index
202 int transient_huffman[DCA_PRIM_CHANNELS_MAX]; ///< transient mode code book
203 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book
204 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX]; ///< bit allocation quantizer select
205 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select
206 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< scale factor adjustment
207
208 /* Primary audio coding side information */
209 int subsubframes; ///< number of subsubframes
210 int partial_samples; ///< partial subsubframe samples count
211 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction mode (ADPCM used or not)
212 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< prediction VQ coefs
213 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< bit allocation index
214 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< transition mode (transients)
215 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2]; ///< scale factors (2 if transient)
216 int joint_huff[DCA_PRIM_CHANNELS_MAX]; ///< joint subband scale factors codebook
217 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors
218 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2]; ///< stereo downmix coefficients
219 int dynrange_coef; ///< dynamic range coefficient
220
221 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< VQ encoded high frequency subbands
222
223 float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
224 2 /*history */ ]; ///< Low frequency effect data
225 int lfe_scale_factor;
226
227 /* Subband samples history (for ADPCM) */
228 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
229 DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]);
230 float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];
231 int hist_index[DCA_PRIM_CHANNELS_MAX];
232
233 int output; ///< type of output
234 float add_bias; ///< output bias
235 float scale_bias; ///< output scale
236
237 DECLARE_ALIGNED_16(float, samples[1536]); /* 6 * 256 = 1536, might only need 5 */
238 const float *samples_chanptr[6];
239
240 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
241 int dca_buffer_size; ///< how much data is in the dca_buffer
242
243 const int8_t* channel_order_tab; ///< channel reordering table, lfe and non lfe
244 GetBitContext gb;
245 /* Current position in DCA frame */
246 int current_subframe;
247 int current_subsubframe;
248
249 int debug_flag; ///< used for suppressing repeated error messages output
250 DSPContext dsp;
251 MDCTContext imdct;
252 } DCAContext;
253
254 static av_cold void dca_init_vlcs(void)
255 {
256 static int vlcs_initialized = 0;
257 int i, j;
258
259 if (vlcs_initialized)
260 return;
261
262 dca_bitalloc_index.offset = 1;
263 dca_bitalloc_index.wrap = 2;
264 for (i = 0; i < 5; i++)
265 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
266 bitalloc_12_bits[i], 1, 1,
267 bitalloc_12_codes[i], 2, 2, 1);
268 dca_scalefactor.offset = -64;
269 dca_scalefactor.wrap = 2;
270 for (i = 0; i < 5; i++)
271 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
272 scales_bits[i], 1, 1,
273 scales_codes[i], 2, 2, 1);
274 dca_tmode.offset = 0;
275 dca_tmode.wrap = 1;
276 for (i = 0; i < 4; i++)
277 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
278 tmode_bits[i], 1, 1,
279 tmode_codes[i], 2, 2, 1);
280
281 for(i = 0; i < 10; i++)
282 for(j = 0; j < 7; j++){
283 if(!bitalloc_codes[i][j]) break;
284 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
285 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
286 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
287 bitalloc_sizes[i],
288 bitalloc_bits[i][j], 1, 1,
289 bitalloc_codes[i][j], 2, 2, 1);
290 }
291 vlcs_initialized = 1;
292 }
293
294 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
295 {
296 while(len--)
297 *dst++ = get_bits(gb, bits);
298 }
299
300 static int dca_parse_frame_header(DCAContext * s)
301 {
302 int i, j;
303 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
304 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
305 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
306
307 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
308
309 /* Sync code */
310 get_bits(&s->gb, 32);
311
312 /* Frame header */
313 s->frame_type = get_bits(&s->gb, 1);
314 s->samples_deficit = get_bits(&s->gb, 5) + 1;
315 s->crc_present = get_bits(&s->gb, 1);
316 s->sample_blocks = get_bits(&s->gb, 7) + 1;
317 s->frame_size = get_bits(&s->gb, 14) + 1;
318 if (s->frame_size < 95)
319 return -1;
320 s->amode = get_bits(&s->gb, 6);
321 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
322 if (!s->sample_rate)
323 return -1;
324 s->bit_rate_index = get_bits(&s->gb, 5);
325 s->bit_rate = dca_bit_rates[s->bit_rate_index];
326 if (!s->bit_rate)
327 return -1;
328
329 s->downmix = get_bits(&s->gb, 1);
330 s->dynrange = get_bits(&s->gb, 1);
331 s->timestamp = get_bits(&s->gb, 1);
332 s->aux_data = get_bits(&s->gb, 1);
333 s->hdcd = get_bits(&s->gb, 1);
334 s->ext_descr = get_bits(&s->gb, 3);
335 s->ext_coding = get_bits(&s->gb, 1);
336 s->aspf = get_bits(&s->gb, 1);
337 s->lfe = get_bits(&s->gb, 2);
338 s->predictor_history = get_bits(&s->gb, 1);
339
340 /* TODO: check CRC */
341 if (s->crc_present)
342 s->header_crc = get_bits(&s->gb, 16);
343
344 s->multirate_inter = get_bits(&s->gb, 1);
345 s->version = get_bits(&s->gb, 4);
346 s->copy_history = get_bits(&s->gb, 2);
347 s->source_pcm_res = get_bits(&s->gb, 3);
348 s->front_sum = get_bits(&s->gb, 1);
349 s->surround_sum = get_bits(&s->gb, 1);
350 s->dialog_norm = get_bits(&s->gb, 4);
351
352 /* FIXME: channels mixing levels */
353 s->output = s->amode;
354 if(s->lfe) s->output |= DCA_LFE;
355
356 #ifdef TRACE
357 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
358 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
359 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
360 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
361 s->sample_blocks, s->sample_blocks * 32);
362 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
363 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
364 s->amode, dca_channels[s->amode]);
365 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
366 s->sample_rate);
367 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
368 s->bit_rate);
369 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
370 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
371 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
372 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
373 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
374 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
375 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
376 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
377 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
378 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
379 s->predictor_history);
380 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
381 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
382 s->multirate_inter);
383 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
384 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
385 av_log(s->avctx, AV_LOG_DEBUG,
386 "source pcm resolution: %i (%i bits/sample)\n",
387 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
388 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
389 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
390 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
391 av_log(s->avctx, AV_LOG_DEBUG, "\n");
392 #endif
393
394 /* Primary audio coding header */
395 s->subframes = get_bits(&s->gb, 4) + 1;
396 s->total_channels = get_bits(&s->gb, 3) + 1;
397 s->prim_channels = s->total_channels;
398 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
399 s->prim_channels = DCA_PRIM_CHANNELS_MAX; /* We only support DTS core */
400
401
402 for (i = 0; i < s->prim_channels; i++) {
403 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
404 if (s->subband_activity[i] > DCA_SUBBANDS)
405 s->subband_activity[i] = DCA_SUBBANDS;
406 }
407 for (i = 0; i < s->prim_channels; i++) {
408 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
409 if (s->vq_start_subband[i] > DCA_SUBBANDS)
410 s->vq_start_subband[i] = DCA_SUBBANDS;
411 }
412 get_array(&s->gb, s->joint_intensity, s->prim_channels, 3);
413 get_array(&s->gb, s->transient_huffman, s->prim_channels, 2);
414 get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
415 get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3);
416
417 /* Get codebooks quantization indexes */
418 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
419 for (j = 1; j < 11; j++)
420 for (i = 0; i < s->prim_channels; i++)
421 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
422
423 /* Get scale factor adjustment */
424 for (j = 0; j < 11; j++)
425 for (i = 0; i < s->prim_channels; i++)
426 s->scalefactor_adj[i][j] = 1;
427
428 for (j = 1; j < 11; j++)
429 for (i = 0; i < s->prim_channels; i++)
430 if (s->quant_index_huffman[i][j] < thr[j])
431 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
432
433 if (s->crc_present) {
434 /* Audio header CRC check */
435 get_bits(&s->gb, 16);
436 }
437
438 s->current_subframe = 0;
439 s->current_subsubframe = 0;
440
441 #ifdef TRACE
442 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
443 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
444 for(i = 0; i < s->prim_channels; i++){
445 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
446 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
447 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
448 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
449 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
450 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
451 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
452 for (j = 0; j < 11; j++)
453 av_log(s->avctx, AV_LOG_DEBUG, " %i",
454 s->quant_index_huffman[i][j]);
455 av_log(s->avctx, AV_LOG_DEBUG, "\n");
456 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
457 for (j = 0; j < 11; j++)
458 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
459 av_log(s->avctx, AV_LOG_DEBUG, "\n");
460 }
461 #endif
462
463 return 0;
464 }
465
466
467 static inline int get_scale(GetBitContext *gb, int level, int value)
468 {
469 if (level < 5) {
470 /* huffman encoded */
471 value += get_bitalloc(gb, &dca_scalefactor, level);
472 } else if(level < 8)
473 value = get_bits(gb, level + 1);
474 return value;
475 }
476
477 static int dca_subframe_header(DCAContext * s)
478 {
479 /* Primary audio coding side information */
480 int j, k;
481
482 s->subsubframes = get_bits(&s->gb, 2) + 1;
483 s->partial_samples = get_bits(&s->gb, 3);
484 for (j = 0; j < s->prim_channels; j++) {
485 for (k = 0; k < s->subband_activity[j]; k++)
486 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
487 }
488
489 /* Get prediction codebook */
490 for (j = 0; j < s->prim_channels; j++) {
491 for (k = 0; k < s->subband_activity[j]; k++) {
492 if (s->prediction_mode[j][k] > 0) {
493 /* (Prediction coefficient VQ address) */
494 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
495 }
496 }
497 }
498
499 /* Bit allocation index */
500 for (j = 0; j < s->prim_channels; j++) {
501 for (k = 0; k < s->vq_start_subband[j]; k++) {
502 if (s->bitalloc_huffman[j] == 6)
503 s->bitalloc[j][k] = get_bits(&s->gb, 5);
504 else if (s->bitalloc_huffman[j] == 5)
505 s->bitalloc[j][k] = get_bits(&s->gb, 4);
506 else if (s->bitalloc_huffman[j] == 7) {
507 av_log(s->avctx, AV_LOG_ERROR,
508 "Invalid bit allocation index\n");
509 return -1;
510 } else {
511 s->bitalloc[j][k] =
512 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
513 }
514
515 if (s->bitalloc[j][k] > 26) {
516 // av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",
517 // j, k, s->bitalloc[j][k]);
518 return -1;
519 }
520 }
521 }
522
523 /* Transition mode */
524 for (j = 0; j < s->prim_channels; j++) {
525 for (k = 0; k < s->subband_activity[j]; k++) {
526 s->transition_mode[j][k] = 0;
527 if (s->subsubframes > 1 &&
528 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
529 s->transition_mode[j][k] =
530 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
531 }
532 }
533 }
534
535 for (j = 0; j < s->prim_channels; j++) {
536 const uint32_t *scale_table;
537 int scale_sum;
538
539 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
540
541 if (s->scalefactor_huffman[j] == 6)
542 scale_table = scale_factor_quant7;
543 else
544 scale_table = scale_factor_quant6;
545
546 /* When huffman coded, only the difference is encoded */
547 scale_sum = 0;
548
549 for (k = 0; k < s->subband_activity[j]; k++) {
550 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
551 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
552 s->scale_factor[j][k][0] = scale_table[scale_sum];
553 }
554
555 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
556 /* Get second scale factor */
557 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
558 s->scale_factor[j][k][1] = scale_table[scale_sum];
559 }
560 }
561 }
562
563 /* Joint subband scale factor codebook select */
564 for (j = 0; j < s->prim_channels; j++) {
565 /* Transmitted only if joint subband coding enabled */
566 if (s->joint_intensity[j] > 0)
567 s->joint_huff[j] = get_bits(&s->gb, 3);
568 }
569
570 /* Scale factors for joint subband coding */
571 for (j = 0; j < s->prim_channels; j++) {
572 int source_channel;
573
574 /* Transmitted only if joint subband coding enabled */
575 if (s->joint_intensity[j] > 0) {
576 int scale = 0;
577 source_channel = s->joint_intensity[j] - 1;
578
579 /* When huffman coded, only the difference is encoded
580 * (is this valid as well for joint scales ???) */
581
582 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
583 scale = get_scale(&s->gb, s->joint_huff[j], 0);
584 scale += 64; /* bias */
585 s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
586 }
587
588 if (!s->debug_flag & 0x02) {
589 av_log(s->avctx, AV_LOG_DEBUG,
590 "Joint stereo coding not supported\n");
591 s->debug_flag |= 0x02;
592 }
593 }
594 }
595
596 /* Stereo downmix coefficients */
597 if (s->prim_channels > 2) {
598 if(s->downmix) {
599 for (j = 0; j < s->prim_channels; j++) {
600 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
601 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
602 }
603 } else {
604 int am = s->amode & DCA_CHANNEL_MASK;
605 for (j = 0; j < s->prim_channels; j++) {
606 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
607 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
608 }
609 }
610 }
611
612 /* Dynamic range coefficient */
613 if (s->dynrange)
614 s->dynrange_coef = get_bits(&s->gb, 8);
615
616 /* Side information CRC check word */
617 if (s->crc_present) {
618 get_bits(&s->gb, 16);
619 }
620
621 /*
622 * Primary audio data arrays
623 */
624
625 /* VQ encoded high frequency subbands */
626 for (j = 0; j < s->prim_channels; j++)
627 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
628 /* 1 vector -> 32 samples */
629 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
630
631 /* Low frequency effect data */
632 if (s->lfe) {
633 /* LFE samples */
634 int lfe_samples = 2 * s->lfe * s->subsubframes;
635 float lfe_scale;
636
637 for (j = lfe_samples; j < lfe_samples * 2; j++) {
638 /* Signed 8 bits int */
639 s->lfe_data[j] = get_sbits(&s->gb, 8);
640 }
641
642 /* Scale factor index */
643 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
644
645 /* Quantization step size * scale factor */
646 lfe_scale = 0.035 * s->lfe_scale_factor;
647
648 for (j = lfe_samples; j < lfe_samples * 2; j++)
649 s->lfe_data[j] *= lfe_scale;
650 }
651
652 #ifdef TRACE
653 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
654 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
655 s->partial_samples);
656 for (j = 0; j < s->prim_channels; j++) {
657 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
658 for (k = 0; k < s->subband_activity[j]; k++)
659 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
660 av_log(s->avctx, AV_LOG_DEBUG, "\n");
661 }
662 for (j = 0; j < s->prim_channels; j++) {
663 for (k = 0; k < s->subband_activity[j]; k++)
664 av_log(s->avctx, AV_LOG_DEBUG,
665 "prediction coefs: %f, %f, %f, %f\n",
666 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
667 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
668 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
669 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
670 }
671 for (j = 0; j < s->prim_channels; j++) {
672 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
673 for (k = 0; k < s->vq_start_subband[j]; k++)
674 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
675 av_log(s->avctx, AV_LOG_DEBUG, "\n");
676 }
677 for (j = 0; j < s->prim_channels; j++) {
678 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
679 for (k = 0; k < s->subband_activity[j]; k++)
680 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
681 av_log(s->avctx, AV_LOG_DEBUG, "\n");
682 }
683 for (j = 0; j < s->prim_channels; j++) {
684 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
685 for (k = 0; k < s->subband_activity[j]; k++) {
686 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
687 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
688 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
689 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
690 }
691 av_log(s->avctx, AV_LOG_DEBUG, "\n");
692 }
693 for (j = 0; j < s->prim_channels; j++) {
694 if (s->joint_intensity[j] > 0) {
695 int source_channel = s->joint_intensity[j] - 1;
696 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
697 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
698 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
699 av_log(s->avctx, AV_LOG_DEBUG, "\n");
700 }
701 }
702 if (s->prim_channels > 2 && s->downmix) {
703 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
704 for (j = 0; j < s->prim_channels; j++) {
705 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
706 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
707 }
708 av_log(s->avctx, AV_LOG_DEBUG, "\n");
709 }
710 for (j = 0; j < s->prim_channels; j++)
711 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
712 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
713 if(s->lfe){
714 int lfe_samples = 2 * s->lfe * s->subsubframes;
715 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
716 for (j = lfe_samples; j < lfe_samples * 2; j++)
717 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
718 av_log(s->avctx, AV_LOG_DEBUG, "\n");
719 }
720 #endif
721
722 return 0;
723 }
724
725 static void qmf_32_subbands(DCAContext * s, int chans,
726 float samples_in[32][8], float *samples_out,
727 float scale, float bias)
728 {
729 const float *prCoeff;
730 int i, j;
731 DECLARE_ALIGNED_16(float, raXin[32]);
732
733 int hist_index= s->hist_index[chans];
734 float *subband_fir_hist2 = s->subband_fir_noidea[chans];
735
736 int subindex;
737
738 scale *= sqrt(1/8.0);
739
740 /* Select filter */
741 if (!s->multirate_inter) /* Non-perfect reconstruction */
742 prCoeff = fir_32bands_nonperfect;
743 else /* Perfect reconstruction */
744 prCoeff = fir_32bands_perfect;
745
746 /* Reconstructed channel sample index */
747 for (subindex = 0; subindex < 8; subindex++) {
748 float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;
749 /* Load in one sample from each subband and clear inactive subbands */
750 for (i = 0; i < s->subband_activity[chans]; i++){
751 if((i-1)&2) raXin[i] = -samples_in[i][subindex];
752 else raXin[i] = samples_in[i][subindex];
753 }
754 for (; i < 32; i++)
755 raXin[i] = 0.0;
756
757 ff_imdct_half(&s->imdct, subband_fir_hist, raXin);
758
759 /* Multiply by filter coefficients */
760 for (i = 0; i < 16; i++){
761 float a= subband_fir_hist2[i ];
762 float b= subband_fir_hist2[i+16];
763 float c= 0;
764 float d= 0;
765 for (j = 0; j < 512-hist_index; j += 64){
766 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j]);
767 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j]);
768 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);
769 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);
770 }
771 for ( ; j < 512; j += 64){
772 a += prCoeff[i+j ]*(-subband_fir_hist[15-i+j-512]);
773 b += prCoeff[i+j+16]*( subband_fir_hist[ i+j-512]);
774 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);
775 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);
776 }
777 samples_out[i ] = a * scale + bias;
778 samples_out[i+16] = b * scale + bias;
779 subband_fir_hist2[i ] = c;
780 subband_fir_hist2[i+16] = d;
781 }
782 samples_out+= 32;
783
784 hist_index = (hist_index-32)&511;
785 }
786 s->hist_index[chans]= hist_index;
787 }
788
789 static void lfe_interpolation_fir(int decimation_select,
790 int num_deci_sample, float *samples_in,
791 float *samples_out, float scale,
792 float bias)
793 {
794 /* samples_in: An array holding decimated samples.
795 * Samples in current subframe starts from samples_in[0],
796 * while samples_in[-1], samples_in[-2], ..., stores samples
797 * from last subframe as history.
798 *
799 * samples_out: An array holding interpolated samples
800 */
801
802 int decifactor, k, j;
803 const float *prCoeff;
804
805 int interp_index = 0; /* Index to the interpolated samples */
806 int deciindex;
807
808 /* Select decimation filter */
809 if (decimation_select == 1) {
810 decifactor = 128;
811 prCoeff = lfe_fir_128;
812 } else {
813 decifactor = 64;
814 prCoeff = lfe_fir_64;
815 }
816 /* Interpolation */
817 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
818 /* One decimated sample generates decifactor interpolated ones */
819 for (k = 0; k < decifactor; k++) {
820 float rTmp = 0.0;
821 //FIXME the coeffs are symetric, fix that
822 for (j = 0; j < 512 / decifactor; j++)
823 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];
824 samples_out[interp_index++] = (rTmp * scale) + bias;
825 }
826 }
827 }
828
829 /* downmixing routines */
830 #define MIX_REAR1(samples, si1, rs, coef) \
831 samples[i] += samples[si1] * coef[rs][0]; \
832 samples[i+256] += samples[si1] * coef[rs][1];
833
834 #define MIX_REAR2(samples, si1, si2, rs, coef) \
835 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
836 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
837
838 #define MIX_FRONT3(samples, coef) \
839 t = samples[i]; \
840 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
841 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
842
843 #define DOWNMIX_TO_STEREO(op1, op2) \
844 for(i = 0; i < 256; i++){ \
845 op1 \
846 op2 \
847 }
848
849 static void dca_downmix(float *samples, int srcfmt,
850 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
851 {
852 int i;
853 float t;
854 float coef[DCA_PRIM_CHANNELS_MAX][2];
855
856 for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
857 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
858 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
859 }
860
861 switch (srcfmt) {
862 case DCA_MONO:
863 case DCA_CHANNEL:
864 case DCA_STEREO_TOTAL:
865 case DCA_STEREO_SUMDIFF:
866 case DCA_4F2R:
867 av_log(NULL, 0, "Not implemented!\n");
868 break;
869 case DCA_STEREO:
870 break;
871 case DCA_3F:
872 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
873 break;
874 case DCA_2F1R:
875 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
876 break;
877 case DCA_3F1R:
878 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
879 MIX_REAR1(samples, i + 768, 3, coef));
880 break;
881 case DCA_2F2R:
882 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
883 break;
884 case DCA_3F2R:
885 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
886 MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
887 break;
888 }
889 }
890
891
892 /* Very compact version of the block code decoder that does not use table
893 * look-up but is slightly slower */
894 static int decode_blockcode(int code, int levels, int *values)
895 {
896 int i;
897 int offset = (levels - 1) >> 1;
898
899 for (i = 0; i < 4; i++) {
900 values[i] = (code % levels) - offset;
901 code /= levels;
902 }
903
904 if (code == 0)
905 return 0;
906 else {
907 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
908 return -1;
909 }
910 }
911
912 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
913 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
914
915 static int dca_subsubframe(DCAContext * s)
916 {
917 int k, l;
918 int subsubframe = s->current_subsubframe;
919
920 const float *quant_step_table;
921
922 /* FIXME */
923 float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
924
925 /*
926 * Audio data
927 */
928
929 /* Select quantization step size table */
930 if (s->bit_rate_index == 0x1f)
931 quant_step_table = lossless_quant_d;
932 else
933 quant_step_table = lossy_quant_d;
934
935 for (k = 0; k < s->prim_channels; k++) {
936 for (l = 0; l < s->vq_start_subband[k]; l++) {
937 int m;
938
939 /* Select the mid-tread linear quantizer */
940 int abits = s->bitalloc[k][l];
941
942 float quant_step_size = quant_step_table[abits];
943 float rscale;
944
945 /*
946 * Determine quantization index code book and its type
947 */
948
949 /* Select quantization index code book */
950 int sel = s->quant_index_huffman[k][abits];
951
952 /*
953 * Extract bits from the bit stream
954 */
955 if(!abits){
956 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
957 }else if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
958 if(abits <= 7){
959 /* Block code */
960 int block_code1, block_code2, size, levels;
961 int block[8];
962
963 size = abits_sizes[abits-1];
964 levels = abits_levels[abits-1];
965
966 block_code1 = get_bits(&s->gb, size);
967 /* FIXME Should test return value */
968 decode_blockcode(block_code1, levels, block);
969 block_code2 = get_bits(&s->gb, size);
970 decode_blockcode(block_code2, levels, &block[4]);
971 for (m = 0; m < 8; m++)
972 subband_samples[k][l][m] = block[m];
973 }else{
974 /* no coding */
975 for (m = 0; m < 8; m++)
976 subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);
977 }
978 }else{
979 /* Huffman coded */
980 for (m = 0; m < 8; m++)
981 subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
982 }
983
984 /* Deal with transients */
985 if (s->transition_mode[k][l] &&
986 subsubframe >= s->transition_mode[k][l])
987 rscale = quant_step_size * s->scale_factor[k][l][1];
988 else
989 rscale = quant_step_size * s->scale_factor[k][l][0];
990
991 rscale *= s->scalefactor_adj[k][sel];
992
993 for (m = 0; m < 8; m++)
994 subband_samples[k][l][m] *= rscale;
995
996 /*
997 * Inverse ADPCM if in prediction mode
998 */
999 if (s->prediction_mode[k][l]) {
1000 int n;
1001 for (m = 0; m < 8; m++) {
1002 for (n = 1; n <= 4; n++)
1003 if (m >= n)
1004 subband_samples[k][l][m] +=
1005 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1006 subband_samples[k][l][m - n] / 8192);
1007 else if (s->predictor_history)
1008 subband_samples[k][l][m] +=
1009 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
1010 s->subband_samples_hist[k][l][m - n +
1011 4] / 8192);
1012 }
1013 }
1014 }
1015
1016 /*
1017 * Decode VQ encoded high frequencies
1018 */
1019 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
1020 /* 1 vector -> 32 samples but we only need the 8 samples
1021 * for this subsubframe. */
1022 int m;
1023
1024 if (!s->debug_flag & 0x01) {
1025 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
1026 s->debug_flag |= 0x01;
1027 }
1028
1029 for (m = 0; m < 8; m++) {
1030 subband_samples[k][l][m] =
1031 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
1032 m]
1033 * (float) s->scale_factor[k][l][0] / 16.0;
1034 }
1035 }
1036 }
1037
1038 /* Check for DSYNC after subsubframe */
1039 if (s->aspf || subsubframe == s->subsubframes - 1) {
1040 if (0xFFFF == get_bits(&s->gb, 16)) { /* 0xFFFF */
1041 #ifdef TRACE
1042 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
1043 #endif
1044 } else {
1045 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
1046 }
1047 }
1048
1049 /* Backup predictor history for adpcm */
1050 for (k = 0; k < s->prim_channels; k++)
1051 for (l = 0; l < s->vq_start_subband[k]; l++)
1052 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
1053 4 * sizeof(subband_samples[0][0][0]));
1054
1055 /* 32 subbands QMF */
1056 for (k = 0; k < s->prim_channels; k++) {
1057 /* static float pcm_to_double[8] =
1058 {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/
1059 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
1060 M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,
1061 s->add_bias );
1062 }
1063
1064 /* Down mixing */
1065
1066 if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
1067 dca_downmix(s->samples, s->amode, s->downmix_coef);
1068 }
1069
1070 /* Generate LFE samples for this subsubframe FIXME!!! */
1071 if (s->output & DCA_LFE) {
1072 int lfe_samples = 2 * s->lfe * s->subsubframes;
1073
1074 lfe_interpolation_fir(s->lfe, 2 * s->lfe,
1075 s->lfe_data + lfe_samples +
1076 2 * s->lfe * subsubframe,
1077 &s->samples[256 * dca_lfe_index[s->amode]],
1078 (1.0/256.0)*s->scale_bias, s->add_bias);
1079 /* Outputs 20bits pcm samples */
1080 }
1081
1082 return 0;
1083 }
1084
1085
1086 static int dca_subframe_footer(DCAContext * s)
1087 {
1088 int aux_data_count = 0, i;
1089 int lfe_samples;
1090
1091 /*
1092 * Unpack optional information
1093 */
1094
1095 if (s->timestamp)
1096 get_bits(&s->gb, 32);
1097
1098 if (s->aux_data)
1099 aux_data_count = get_bits(&s->gb, 6);
1100
1101 for (i = 0; i < aux_data_count; i++)
1102 get_bits(&s->gb, 8);
1103
1104 if (s->crc_present && (s->downmix || s->dynrange))
1105 get_bits(&s->gb, 16);
1106
1107 lfe_samples = 2 * s->lfe * s->subsubframes;
1108 for (i = 0; i < lfe_samples; i++) {
1109 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
1110 }
1111
1112 return 0;
1113 }
1114
1115 /**
1116 * Decode a dca frame block
1117 *
1118 * @param s pointer to the DCAContext
1119 */
1120
1121 static int dca_decode_block(DCAContext * s)
1122 {
1123
1124 /* Sanity check */
1125 if (s->current_subframe >= s->subframes) {
1126 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
1127 s->current_subframe, s->subframes);
1128 return -1;
1129 }
1130
1131 if (!s->current_subsubframe) {
1132 #ifdef TRACE
1133 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
1134 #endif
1135 /* Read subframe header */
1136 if (dca_subframe_header(s))
1137 return -1;
1138 }
1139
1140 /* Read subsubframe */
1141 #ifdef TRACE
1142 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
1143 #endif
1144 if (dca_subsubframe(s))
1145 return -1;
1146
1147 /* Update state */
1148 s->current_subsubframe++;
1149 if (s->current_subsubframe >= s->subsubframes) {
1150 s->current_subsubframe = 0;
1151 s->current_subframe++;
1152 }
1153 if (s->current_subframe >= s->subframes) {
1154 #ifdef TRACE
1155 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
1156 #endif
1157 /* Read subframe footer */
1158 if (dca_subframe_footer(s))
1159 return -1;
1160 }
1161
1162 return 0;
1163 }
1164
1165 /**
1166 * Convert bitstream to one representation based on sync marker
1167 */
1168 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
1169 int max_size)
1170 {
1171 uint32_t mrk;
1172 int i, tmp;
1173 const uint16_t *ssrc = (const uint16_t *) src;
1174 uint16_t *sdst = (uint16_t *) dst;
1175 PutBitContext pb;
1176
1177 if((unsigned)src_size > (unsigned)max_size) {
1178 // av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");
1179 // return -1;
1180 src_size = max_size;
1181 }
1182
1183 mrk = AV_RB32(src);
1184 switch (mrk) {
1185 case DCA_MARKER_RAW_BE:
1186 memcpy(dst, src, src_size);
1187 return src_size;
1188 case DCA_MARKER_RAW_LE:
1189 for (i = 0; i < (src_size + 1) >> 1; i++)
1190 *sdst++ = bswap_16(*ssrc++);
1191 return src_size;
1192 case DCA_MARKER_14B_BE:
1193 case DCA_MARKER_14B_LE:
1194 init_put_bits(&pb, dst, max_size);
1195 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
1196 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
1197 put_bits(&pb, 14, tmp);
1198 }
1199 flush_put_bits(&pb);
1200 return (put_bits_count(&pb) + 7) >> 3;
1201 default:
1202 return -1;
1203 }
1204 }
1205
1206 /**
1207 * Main frame decoding function
1208 * FIXME add arguments
1209 */
1210 static int dca_decode_frame(AVCodecContext * avctx,
1211 void *data, int *data_size,
1212 AVPacket *avpkt)
1213 {
1214 const uint8_t *buf = avpkt->data;
1215 int buf_size = avpkt->size;
1216
1217 int i;
1218 int16_t *samples = data;
1219 DCAContext *s = avctx->priv_data;
1220 int channels;
1221
1222
1223 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
1224 if (s->dca_buffer_size == -1) {
1225 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
1226 return -1;
1227 }
1228
1229 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
1230 if (dca_parse_frame_header(s) < 0) {
1231 //seems like the frame is corrupt, try with the next one
1232 *data_size=0;
1233 return buf_size;
1234 }
1235 //set AVCodec values with parsed data
1236 avctx->sample_rate = s->sample_rate;
1237 avctx->bit_rate = s->bit_rate;
1238
1239 channels = s->prim_channels + !!s->lfe;
1240
1241 if (s->amode<16) {
1242 avctx->channel_layout = dca_core_channel_layout[s->amode];
1243
1244 if (s->lfe) {
1245 avctx->channel_layout |= CH_LOW_FREQUENCY;
1246 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
1247 } else
1248 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
1249
1250 if(avctx->request_channels == 2 && s->prim_channels > 2) {
1251 channels = 2;
1252 s->output = DCA_STEREO;
1253 avctx->channel_layout = CH_LAYOUT_STEREO;
1254 }
1255 } else {
1256 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
1257 return -1;
1258 }
1259
1260
1261 /* There is nothing that prevents a dts frame to change channel configuration
1262 but FFmpeg doesn't support that so only set the channels if it is previously
1263 unset. Ideally during the first probe for channels the crc should be checked
1264 and only set avctx->channels when the crc is ok. Right now the decoder could
1265 set the channels based on a broken first frame.*/
1266 if (!avctx->channels)
1267 avctx->channels = channels;
1268
1269 if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
1270 return -1;
1271 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
1272 for (i = 0; i < (s->sample_blocks / 8); i++) {
1273 dca_decode_block(s);
1274 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
1275 samples += 256 * channels;
1276 }
1277
1278 return buf_size;
1279 }
1280
1281
1282
1283 /**
1284 * DCA initialization
1285 *
1286 * @param avctx pointer to the AVCodecContext
1287 */
1288
1289 static av_cold int dca_decode_init(AVCodecContext * avctx)
1290 {
1291 DCAContext *s = avctx->priv_data;
1292 int i;
1293
1294 s->avctx = avctx;
1295 dca_init_vlcs();
1296
1297 dsputil_init(&s->dsp, avctx);
1298 ff_mdct_init(&s->imdct, 6, 1);
1299
1300 for(i = 0; i < 6; i++)
1301 s->samples_chanptr[i] = s->samples + i * 256;
1302 avctx->sample_fmt = SAMPLE_FMT_S16;
1303
1304 if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
1305 s->add_bias = 385.0f;
1306 s->scale_bias = 1.0 / 32768.0;
1307 } else {
1308 s->add_bias = 0.0f;
1309 s->scale_bias = 1.0;
1310
1311 /* allow downmixing to stereo */
1312 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
1313 avctx->request_channels == 2) {
1314 avctx->channels = avctx->request_channels;
1315 }
1316 }
1317
1318
1319 return 0;
1320 }
1321
1322 static av_cold int dca_decode_end(AVCodecContext * avctx)
1323 {
1324 DCAContext *s = avctx->priv_data;
1325 ff_mdct_end(&s->imdct);
1326 return 0;
1327 }
1328
1329 AVCodec dca_decoder = {
1330 .name = "dca",
1331 .type = CODEC_TYPE_AUDIO,
1332 .id = CODEC_ID_DTS,
1333 .priv_data_size = sizeof(DCAContext),
1334 .init = dca_decode_init,
1335 .decode = dca_decode_frame,
1336 .close = dca_decode_end,
1337 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
1338 };
lucabe's unfinished and experimental patches for ffmpeg