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