Mercurial > libavcodec.hg
annotate qdm2.c @ 7351:1502ba3beb72 libavcodec
The codebook generator algorithm involves picking three
different codebook centroids ("high utility", "low
utility" and "closest to the low utility one"). This
change avoid the corner case of choosing two times the
same centroid.
author | vitor |
---|---|
date | Wed, 23 Jul 2008 03:54:31 +0000 |
parents | fe8a7f5905e4 |
children | 85ab7655ad4d |
rev | line source |
---|---|
2914 | 1 /* |
2 * QDM2 compatible decoder | |
3 * Copyright (c) 2003 Ewald Snel | |
4 * Copyright (c) 2005 Benjamin Larsson | |
5 * Copyright (c) 2005 Alex Beregszaszi | |
6 * Copyright (c) 2005 Roberto Togni | |
7 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3333
diff
changeset
|
8 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3333
diff
changeset
|
9 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3333
diff
changeset
|
10 * FFmpeg is free software; you can redistribute it and/or |
2914 | 11 * modify it under the terms of the GNU Lesser General Public |
12 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3333
diff
changeset
|
13 * version 2.1 of the License, or (at your option) any later version. |
2914 | 14 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3333
diff
changeset
|
15 * FFmpeg is distributed in the hope that it will be useful, |
2914 | 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 | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3333
diff
changeset
|
21 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2967
diff
changeset
|
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
2914 | 23 */ |
24 | |
25 /** | |
26 * @file qdm2.c | |
27 * QDM2 decoder | |
28 * @author Ewald Snel, Benjamin Larsson, Alex Beregszaszi, Roberto Togni | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
29 * The decoder is not perfect yet, there are still some distortions |
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
30 * especially on files encoded with 16 or 8 subbands. |
2914 | 31 */ |
32 | |
33 #include <math.h> | |
34 #include <stddef.h> | |
35 #include <stdio.h> | |
36 | |
37 #define ALT_BITSTREAM_READER_LE | |
38 #include "avcodec.h" | |
39 #include "bitstream.h" | |
40 #include "dsputil.h" | |
41 | |
42 #ifdef CONFIG_MPEGAUDIO_HP | |
43 #define USE_HIGHPRECISION | |
44 #endif | |
45 | |
46 #include "mpegaudio.h" | |
47 | |
48 #include "qdm2data.h" | |
49 | |
50 #undef NDEBUG | |
51 #include <assert.h> | |
52 | |
53 | |
54 #define SOFTCLIP_THRESHOLD 27600 | |
55 #define HARDCLIP_THRESHOLD 35716 | |
56 | |
57 | |
58 #define QDM2_LIST_ADD(list, size, packet) \ | |
59 do { \ | |
60 if (size > 0) { \ | |
61 list[size - 1].next = &list[size]; \ | |
62 } \ | |
63 list[size].packet = packet; \ | |
64 list[size].next = NULL; \ | |
65 size++; \ | |
66 } while(0) | |
67 | |
68 // Result is 8, 16 or 30 | |
69 #define QDM2_SB_USED(sub_sampling) (((sub_sampling) >= 2) ? 30 : 8 << (sub_sampling)) | |
70 | |
71 #define FIX_NOISE_IDX(noise_idx) \ | |
72 if ((noise_idx) >= 3840) \ | |
73 (noise_idx) -= 3840; \ | |
74 | |
75 #define SB_DITHERING_NOISE(sb,noise_idx) (noise_table[(noise_idx)++] * sb_noise_attenuation[(sb)]) | |
76 | |
77 #define BITS_LEFT(length,gb) ((length) - get_bits_count ((gb))) | |
78 | |
79 #define SAMPLES_NEEDED \ | |
80 av_log (NULL,AV_LOG_INFO,"This file triggers some untested code. Please contact the developers.\n"); | |
81 | |
82 #define SAMPLES_NEEDED_2(why) \ | |
83 av_log (NULL,AV_LOG_INFO,"This file triggers some missing code. Please contact the developers.\nPosition: %s\n",why); | |
84 | |
85 | |
86 typedef int8_t sb_int8_array[2][30][64]; | |
87 | |
88 /** | |
89 * Subpacket | |
90 */ | |
91 typedef struct { | |
92 int type; ///< subpacket type | |
93 unsigned int size; ///< subpacket size | |
94 const uint8_t *data; ///< pointer to subpacket data (points to input data buffer, it's not a private copy) | |
95 } QDM2SubPacket; | |
96 | |
97 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
98 * A node in the subpacket list |
2914 | 99 */ |
6122
61f95f3a62e0
Rename two structures, identifiers starting with _[A-Z] are reserved.
diego
parents:
5215
diff
changeset
|
100 typedef struct QDM2SubPNode { |
2914 | 101 QDM2SubPacket *packet; ///< packet |
6122
61f95f3a62e0
Rename two structures, identifiers starting with _[A-Z] are reserved.
diego
parents:
5215
diff
changeset
|
102 struct QDM2SubPNode *next; ///< pointer to next packet in the list, NULL if leaf node |
2914 | 103 } QDM2SubPNode; |
104 | |
105 typedef struct { | |
106 float level; | |
107 float *samples_im; | |
108 float *samples_re; | |
6273 | 109 const float *table; |
2914 | 110 int phase; |
111 int phase_shift; | |
112 int duration; | |
113 short time_index; | |
114 short cutoff; | |
115 } FFTTone; | |
116 | |
117 typedef struct { | |
118 int16_t sub_packet; | |
119 uint8_t channel; | |
120 int16_t offset; | |
121 int16_t exp; | |
122 uint8_t phase; | |
123 } FFTCoefficient; | |
124 | |
125 typedef struct { | |
126 float re; | |
127 float im; | |
128 } QDM2Complex; | |
129 | |
130 typedef struct { | |
5009 | 131 DECLARE_ALIGNED_16(QDM2Complex, complex[256 + 1]); |
2914 | 132 float samples_im[MPA_MAX_CHANNELS][256]; |
133 float samples_re[MPA_MAX_CHANNELS][256]; | |
134 } QDM2FFT; | |
135 | |
136 /** | |
137 * QDM2 decoder context | |
138 */ | |
139 typedef struct { | |
140 /// Parameters from codec header, do not change during playback | |
141 int nb_channels; ///< number of channels | |
142 int channels; ///< number of channels | |
143 int group_size; ///< size of frame group (16 frames per group) | |
144 int fft_size; ///< size of FFT, in complex numbers | |
145 int checksum_size; ///< size of data block, used also for checksum | |
146 | |
147 /// Parameters built from header parameters, do not change during playback | |
148 int group_order; ///< order of frame group | |
149 int fft_order; ///< order of FFT (actually fftorder+1) | |
150 int fft_frame_size; ///< size of fft frame, in components (1 comples = re + im) | |
151 int frame_size; ///< size of data frame | |
152 int frequency_range; | |
153 int sub_sampling; ///< subsampling: 0=25%, 1=50%, 2=100% */ | |
154 int coeff_per_sb_select; ///< selector for "num. of coeffs. per subband" tables. Can be 0, 1, 2 | |
155 int cm_table_select; ///< selector for "coding method" tables. Can be 0, 1 (from init: 0-4) | |
156 | |
157 /// Packets and packet lists | |
158 QDM2SubPacket sub_packets[16]; ///< the packets themselves | |
159 QDM2SubPNode sub_packet_list_A[16]; ///< list of all packets | |
160 QDM2SubPNode sub_packet_list_B[16]; ///< FFT packets B are on list | |
161 int sub_packets_B; ///< number of packets on 'B' list | |
162 QDM2SubPNode sub_packet_list_C[16]; ///< packets with errors? | |
163 QDM2SubPNode sub_packet_list_D[16]; ///< DCT packets | |
164 | |
165 /// FFT and tones | |
166 FFTTone fft_tones[1000]; | |
167 int fft_tone_start; | |
168 int fft_tone_end; | |
169 FFTCoefficient fft_coefs[1000]; | |
170 int fft_coefs_index; | |
171 int fft_coefs_min_index[5]; | |
172 int fft_coefs_max_index[5]; | |
173 int fft_level_exp[6]; | |
174 FFTContext fft_ctx; | |
175 FFTComplex exptab[128]; | |
176 QDM2FFT fft; | |
177 | |
178 /// I/O data | |
6273 | 179 const uint8_t *compressed_data; |
2914 | 180 int compressed_size; |
181 float output_buffer[1024]; | |
182 | |
183 /// Synthesis filter | |
5009 | 184 DECLARE_ALIGNED_16(MPA_INT, synth_buf[MPA_MAX_CHANNELS][512*2]); |
2914 | 185 int synth_buf_offset[MPA_MAX_CHANNELS]; |
5009 | 186 DECLARE_ALIGNED_16(int32_t, sb_samples[MPA_MAX_CHANNELS][128][SBLIMIT]); |
2914 | 187 |
188 /// Mixed temporary data used in decoding | |
189 float tone_level[MPA_MAX_CHANNELS][30][64]; | |
190 int8_t coding_method[MPA_MAX_CHANNELS][30][64]; | |
191 int8_t quantized_coeffs[MPA_MAX_CHANNELS][10][8]; | |
192 int8_t tone_level_idx_base[MPA_MAX_CHANNELS][30][8]; | |
193 int8_t tone_level_idx_hi1[MPA_MAX_CHANNELS][3][8][8]; | |
194 int8_t tone_level_idx_mid[MPA_MAX_CHANNELS][26][8]; | |
195 int8_t tone_level_idx_hi2[MPA_MAX_CHANNELS][26]; | |
196 int8_t tone_level_idx[MPA_MAX_CHANNELS][30][64]; | |
197 int8_t tone_level_idx_temp[MPA_MAX_CHANNELS][30][64]; | |
198 | |
199 // Flags | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
200 int has_errors; ///< packet has errors |
2914 | 201 int superblocktype_2_3; ///< select fft tables and some algorithm based on superblock type |
202 int do_synth_filter; ///< used to perform or skip synthesis filter | |
203 | |
204 int sub_packet; | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
205 int noise_idx; ///< index for dithering noise table |
2914 | 206 } QDM2Context; |
207 | |
208 | |
209 static uint8_t empty_buffer[FF_INPUT_BUFFER_PADDING_SIZE]; | |
210 | |
211 static VLC vlc_tab_level; | |
212 static VLC vlc_tab_diff; | |
213 static VLC vlc_tab_run; | |
214 static VLC fft_level_exp_alt_vlc; | |
215 static VLC fft_level_exp_vlc; | |
216 static VLC fft_stereo_exp_vlc; | |
217 static VLC fft_stereo_phase_vlc; | |
218 static VLC vlc_tab_tone_level_idx_hi1; | |
219 static VLC vlc_tab_tone_level_idx_mid; | |
220 static VLC vlc_tab_tone_level_idx_hi2; | |
221 static VLC vlc_tab_type30; | |
222 static VLC vlc_tab_type34; | |
223 static VLC vlc_tab_fft_tone_offset[5]; | |
224 | |
225 static uint16_t softclip_table[HARDCLIP_THRESHOLD - SOFTCLIP_THRESHOLD + 1]; | |
226 static float noise_table[4096]; | |
227 static uint8_t random_dequant_index[256][5]; | |
228 static uint8_t random_dequant_type24[128][3]; | |
229 static float noise_samples[128]; | |
230 | |
5009 | 231 static DECLARE_ALIGNED_16(MPA_INT, mpa_window[512]); |
2914 | 232 |
233 | |
3076 | 234 static void softclip_table_init(void) { |
2914 | 235 int i; |
236 double dfl = SOFTCLIP_THRESHOLD - 32767; | |
237 float delta = 1.0 / -dfl; | |
238 for (i = 0; i < HARDCLIP_THRESHOLD - SOFTCLIP_THRESHOLD + 1; i++) | |
239 softclip_table[i] = SOFTCLIP_THRESHOLD - ((int)(sin((float)i * delta) * dfl) & 0x0000FFFF); | |
240 } | |
241 | |
242 | |
243 // random generated table | |
3076 | 244 static void rnd_table_init(void) { |
2914 | 245 int i,j; |
246 uint32_t ldw,hdw; | |
247 uint64_t tmp64_1; | |
248 uint64_t random_seed = 0; | |
249 float delta = 1.0 / 16384.0; | |
250 for(i = 0; i < 4096 ;i++) { | |
251 random_seed = random_seed * 214013 + 2531011; | |
252 noise_table[i] = (delta * (float)(((int32_t)random_seed >> 16) & 0x00007FFF)- 1.0) * 1.3; | |
253 } | |
254 | |
255 for (i = 0; i < 256 ;i++) { | |
256 random_seed = 81; | |
257 ldw = i; | |
258 for (j = 0; j < 5 ;j++) { | |
259 random_dequant_index[i][j] = (uint8_t)((ldw / random_seed) & 0xFF); | |
260 ldw = (uint32_t)ldw % (uint32_t)random_seed; | |
261 tmp64_1 = (random_seed * 0x55555556); | |
262 hdw = (uint32_t)(tmp64_1 >> 32); | |
263 random_seed = (uint64_t)(hdw + (ldw >> 31)); | |
264 } | |
265 } | |
266 for (i = 0; i < 128 ;i++) { | |
267 random_seed = 25; | |
268 ldw = i; | |
269 for (j = 0; j < 3 ;j++) { | |
270 random_dequant_type24[i][j] = (uint8_t)((ldw / random_seed) & 0xFF); | |
271 ldw = (uint32_t)ldw % (uint32_t)random_seed; | |
272 tmp64_1 = (random_seed * 0x66666667); | |
273 hdw = (uint32_t)(tmp64_1 >> 33); | |
274 random_seed = hdw + (ldw >> 31); | |
275 } | |
276 } | |
277 } | |
278 | |
279 | |
3076 | 280 static void init_noise_samples(void) { |
2914 | 281 int i; |
282 int random_seed = 0; | |
283 float delta = 1.0 / 16384.0; | |
284 for (i = 0; i < 128;i++) { | |
285 random_seed = random_seed * 214013 + 2531011; | |
286 noise_samples[i] = (delta * (float)((random_seed >> 16) & 0x00007fff) - 1.0); | |
287 } | |
288 } | |
289 | |
290 | |
3076 | 291 static void qdm2_init_vlc(void) |
2914 | 292 { |
293 init_vlc (&vlc_tab_level, 8, 24, | |
294 vlc_tab_level_huffbits, 1, 1, | |
295 vlc_tab_level_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
296 | |
297 init_vlc (&vlc_tab_diff, 8, 37, | |
298 vlc_tab_diff_huffbits, 1, 1, | |
299 vlc_tab_diff_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
300 | |
301 init_vlc (&vlc_tab_run, 5, 6, | |
302 vlc_tab_run_huffbits, 1, 1, | |
303 vlc_tab_run_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
304 | |
305 init_vlc (&fft_level_exp_alt_vlc, 8, 28, | |
306 fft_level_exp_alt_huffbits, 1, 1, | |
307 fft_level_exp_alt_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
308 | |
309 init_vlc (&fft_level_exp_vlc, 8, 20, | |
310 fft_level_exp_huffbits, 1, 1, | |
311 fft_level_exp_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
312 | |
313 init_vlc (&fft_stereo_exp_vlc, 6, 7, | |
314 fft_stereo_exp_huffbits, 1, 1, | |
315 fft_stereo_exp_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
316 | |
317 init_vlc (&fft_stereo_phase_vlc, 6, 9, | |
318 fft_stereo_phase_huffbits, 1, 1, | |
319 fft_stereo_phase_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
320 | |
321 init_vlc (&vlc_tab_tone_level_idx_hi1, 8, 20, | |
322 vlc_tab_tone_level_idx_hi1_huffbits, 1, 1, | |
323 vlc_tab_tone_level_idx_hi1_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
324 | |
325 init_vlc (&vlc_tab_tone_level_idx_mid, 8, 24, | |
326 vlc_tab_tone_level_idx_mid_huffbits, 1, 1, | |
327 vlc_tab_tone_level_idx_mid_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
328 | |
329 init_vlc (&vlc_tab_tone_level_idx_hi2, 8, 24, | |
330 vlc_tab_tone_level_idx_hi2_huffbits, 1, 1, | |
331 vlc_tab_tone_level_idx_hi2_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
332 | |
333 init_vlc (&vlc_tab_type30, 6, 9, | |
334 vlc_tab_type30_huffbits, 1, 1, | |
335 vlc_tab_type30_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
336 | |
337 init_vlc (&vlc_tab_type34, 5, 10, | |
338 vlc_tab_type34_huffbits, 1, 1, | |
339 vlc_tab_type34_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
340 | |
341 init_vlc (&vlc_tab_fft_tone_offset[0], 8, 23, | |
342 vlc_tab_fft_tone_offset_0_huffbits, 1, 1, | |
343 vlc_tab_fft_tone_offset_0_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
344 | |
345 init_vlc (&vlc_tab_fft_tone_offset[1], 8, 28, | |
346 vlc_tab_fft_tone_offset_1_huffbits, 1, 1, | |
347 vlc_tab_fft_tone_offset_1_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
348 | |
349 init_vlc (&vlc_tab_fft_tone_offset[2], 8, 32, | |
350 vlc_tab_fft_tone_offset_2_huffbits, 1, 1, | |
351 vlc_tab_fft_tone_offset_2_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
352 | |
353 init_vlc (&vlc_tab_fft_tone_offset[3], 8, 35, | |
354 vlc_tab_fft_tone_offset_3_huffbits, 1, 1, | |
355 vlc_tab_fft_tone_offset_3_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
356 | |
357 init_vlc (&vlc_tab_fft_tone_offset[4], 8, 38, | |
358 vlc_tab_fft_tone_offset_4_huffbits, 1, 1, | |
359 vlc_tab_fft_tone_offset_4_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE); | |
360 } | |
361 | |
362 | |
363 /* for floating point to fixed point conversion */ | |
7129 | 364 static const float f2i_scale = (float) (1 << (FRAC_BITS - 15)); |
2914 | 365 |
366 | |
367 static int qdm2_get_vlc (GetBitContext *gb, VLC *vlc, int flag, int depth) | |
368 { | |
369 int value; | |
370 | |
371 value = get_vlc2(gb, vlc->table, vlc->bits, depth); | |
372 | |
373 /* stage-2, 3 bits exponent escape sequence */ | |
374 if (value-- == 0) | |
375 value = get_bits (gb, get_bits (gb, 3) + 1); | |
376 | |
377 /* stage-3, optional */ | |
378 if (flag) { | |
379 int tmp = vlc_stage3_values[value]; | |
380 | |
381 if ((value & ~3) > 0) | |
382 tmp += get_bits (gb, (value >> 2)); | |
383 value = tmp; | |
384 } | |
385 | |
386 return value; | |
387 } | |
388 | |
389 | |
390 static int qdm2_get_se_vlc (VLC *vlc, GetBitContext *gb, int depth) | |
391 { | |
392 int value = qdm2_get_vlc (gb, vlc, 0, depth); | |
393 | |
394 return (value & 1) ? ((value + 1) >> 1) : -(value >> 1); | |
395 } | |
396 | |
397 | |
398 /** | |
399 * QDM2 checksum | |
400 * | |
401 * @param data pointer to data to be checksum'ed | |
402 * @param length data length | |
403 * @param value checksum value | |
404 * | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
405 * @return 0 if checksum is OK |
2914 | 406 */ |
6273 | 407 static uint16_t qdm2_packet_checksum (const uint8_t *data, int length, int value) { |
2914 | 408 int i; |
409 | |
410 for (i=0; i < length; i++) | |
411 value -= data[i]; | |
412 | |
413 return (uint16_t)(value & 0xffff); | |
414 } | |
415 | |
416 | |
417 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
418 * Fills a QDM2SubPacket structure with packet type, size, and data pointer. |
2914 | 419 * |
420 * @param gb bitreader context | |
421 * @param sub_packet packet under analysis | |
422 */ | |
423 static void qdm2_decode_sub_packet_header (GetBitContext *gb, QDM2SubPacket *sub_packet) | |
424 { | |
425 sub_packet->type = get_bits (gb, 8); | |
426 | |
427 if (sub_packet->type == 0) { | |
428 sub_packet->size = 0; | |
429 sub_packet->data = NULL; | |
430 } else { | |
431 sub_packet->size = get_bits (gb, 8); | |
432 | |
433 if (sub_packet->type & 0x80) { | |
434 sub_packet->size <<= 8; | |
435 sub_packet->size |= get_bits (gb, 8); | |
436 sub_packet->type &= 0x7f; | |
437 } | |
438 | |
439 if (sub_packet->type == 0x7f) | |
440 sub_packet->type |= (get_bits (gb, 8) << 8); | |
441 | |
442 sub_packet->data = &gb->buffer[get_bits_count(gb) / 8]; // FIXME: this depends on bitreader internal data | |
443 } | |
444 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
445 av_log(NULL,AV_LOG_DEBUG,"Subpacket: type=%d size=%d start_offs=%x\n", |
2914 | 446 sub_packet->type, sub_packet->size, get_bits_count(gb) / 8); |
447 } | |
448 | |
449 | |
450 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
451 * Return node pointer to first packet of requested type in list. |
2914 | 452 * |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
453 * @param list list of subpackets to be scanned |
2914 | 454 * @param type type of searched subpacket |
455 * @return node pointer for subpacket if found, else NULL | |
456 */ | |
457 static QDM2SubPNode* qdm2_search_subpacket_type_in_list (QDM2SubPNode *list, int type) | |
458 { | |
459 while (list != NULL && list->packet != NULL) { | |
460 if (list->packet->type == type) | |
461 return list; | |
462 list = list->next; | |
463 } | |
464 return NULL; | |
465 } | |
466 | |
467 | |
468 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
469 * Replaces 8 elements with their average value. |
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
470 * Called by qdm2_decode_superblock before starting subblock decoding. |
2914 | 471 * |
472 * @param q context | |
473 */ | |
474 static void average_quantized_coeffs (QDM2Context *q) | |
475 { | |
476 int i, j, n, ch, sum; | |
477 | |
478 n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1; | |
479 | |
480 for (ch = 0; ch < q->nb_channels; ch++) | |
481 for (i = 0; i < n; i++) { | |
482 sum = 0; | |
483 | |
484 for (j = 0; j < 8; j++) | |
485 sum += q->quantized_coeffs[ch][i][j]; | |
486 | |
487 sum /= 8; | |
488 if (sum > 0) | |
489 sum--; | |
490 | |
491 for (j=0; j < 8; j++) | |
492 q->quantized_coeffs[ch][i][j] = sum; | |
493 } | |
494 } | |
495 | |
496 | |
497 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
498 * Build subband samples with noise weighted by q->tone_level. |
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
499 * Called by synthfilt_build_sb_samples. |
2914 | 500 * |
501 * @param q context | |
502 * @param sb subband index | |
503 */ | |
504 static void build_sb_samples_from_noise (QDM2Context *q, int sb) | |
505 { | |
506 int ch, j; | |
507 | |
508 FIX_NOISE_IDX(q->noise_idx); | |
509 | |
510 if (!q->nb_channels) | |
511 return; | |
512 | |
513 for (ch = 0; ch < q->nb_channels; ch++) | |
514 for (j = 0; j < 64; j++) { | |
515 q->sb_samples[ch][j * 2][sb] = (int32_t)(f2i_scale * SB_DITHERING_NOISE(sb,q->noise_idx) * q->tone_level[ch][sb][j] + .5); | |
516 q->sb_samples[ch][j * 2 + 1][sb] = (int32_t)(f2i_scale * SB_DITHERING_NOISE(sb,q->noise_idx) * q->tone_level[ch][sb][j] + .5); | |
517 } | |
518 } | |
519 | |
520 | |
521 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
522 * Called while processing data from subpackets 11 and 12. |
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
523 * Used after making changes to coding_method array. |
2914 | 524 * |
525 * @param sb subband index | |
526 * @param channels number of channels | |
527 * @param coding_method q->coding_method[0][0][0] | |
528 */ | |
3076 | 529 static void fix_coding_method_array (int sb, int channels, sb_int8_array coding_method) |
2914 | 530 { |
531 int j,k; | |
532 int ch; | |
533 int run, case_val; | |
534 int switchtable[23] = {0,5,1,5,5,5,5,5,2,5,5,5,5,5,5,5,3,5,5,5,5,5,4}; | |
535 | |
536 for (ch = 0; ch < channels; ch++) { | |
537 for (j = 0; j < 64; ) { | |
538 if((coding_method[ch][sb][j] - 8) > 22) { | |
539 run = 1; | |
540 case_val = 8; | |
541 } else { | |
3333 | 542 switch (switchtable[coding_method[ch][sb][j]-8]) { |
2914 | 543 case 0: run = 10; case_val = 10; break; |
544 case 1: run = 1; case_val = 16; break; | |
545 case 2: run = 5; case_val = 24; break; | |
546 case 3: run = 3; case_val = 30; break; | |
547 case 4: run = 1; case_val = 30; break; | |
548 case 5: run = 1; case_val = 8; break; | |
549 default: run = 1; case_val = 8; break; | |
550 } | |
551 } | |
552 for (k = 0; k < run; k++) | |
553 if (j + k < 128) | |
554 if (coding_method[ch][sb + (j + k) / 64][(j + k) % 64] > coding_method[ch][sb][j]) | |
555 if (k > 0) { | |
556 SAMPLES_NEEDED | |
557 //not debugged, almost never used | |
558 memset(&coding_method[ch][sb][j + k], case_val, k * sizeof(int8_t)); | |
559 memset(&coding_method[ch][sb][j + k], case_val, 3 * sizeof(int8_t)); | |
560 } | |
561 j += run; | |
562 } | |
563 } | |
564 } | |
565 | |
566 | |
567 /** | |
568 * Related to synthesis filter | |
569 * Called by process_subpacket_10 | |
570 * | |
571 * @param q context | |
572 * @param flag 1 if called after getting data from subpacket 10, 0 if no subpacket 10 | |
573 */ | |
574 static void fill_tone_level_array (QDM2Context *q, int flag) | |
575 { | |
576 int i, sb, ch, sb_used; | |
577 int tmp, tab; | |
578 | |
579 // This should never happen | |
580 if (q->nb_channels <= 0) | |
581 return; | |
582 | |
583 for (ch = 0; ch < q->nb_channels; ch++) | |
584 for (sb = 0; sb < 30; sb++) | |
585 for (i = 0; i < 8; i++) { | |
586 if ((tab=coeff_per_sb_for_dequant[q->coeff_per_sb_select][sb]) < (last_coeff[q->coeff_per_sb_select] - 1)) | |
587 tmp = q->quantized_coeffs[ch][tab + 1][i] * dequant_table[q->coeff_per_sb_select][tab + 1][sb]+ | |
588 q->quantized_coeffs[ch][tab][i] * dequant_table[q->coeff_per_sb_select][tab][sb]; | |
589 else | |
590 tmp = q->quantized_coeffs[ch][tab][i] * dequant_table[q->coeff_per_sb_select][tab][sb]; | |
591 if(tmp < 0) | |
592 tmp += 0xff; | |
593 q->tone_level_idx_base[ch][sb][i] = (tmp / 256) & 0xff; | |
594 } | |
595 | |
596 sb_used = QDM2_SB_USED(q->sub_sampling); | |
597 | |
598 if ((q->superblocktype_2_3 != 0) && !flag) { | |
599 for (sb = 0; sb < sb_used; sb++) | |
600 for (ch = 0; ch < q->nb_channels; ch++) | |
601 for (i = 0; i < 64; i++) { | |
602 q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8]; | |
603 if (q->tone_level_idx[ch][sb][i] < 0) | |
604 q->tone_level[ch][sb][i] = 0; | |
605 else | |
606 q->tone_level[ch][sb][i] = fft_tone_level_table[0][q->tone_level_idx[ch][sb][i] & 0x3f]; | |
607 } | |
608 } else { | |
609 tab = q->superblocktype_2_3 ? 0 : 1; | |
610 for (sb = 0; sb < sb_used; sb++) { | |
611 if ((sb >= 4) && (sb <= 23)) { | |
612 for (ch = 0; ch < q->nb_channels; ch++) | |
613 for (i = 0; i < 64; i++) { | |
614 tmp = q->tone_level_idx_base[ch][sb][i / 8] - | |
615 q->tone_level_idx_hi1[ch][sb / 8][i / 8][i % 8] - | |
616 q->tone_level_idx_mid[ch][sb - 4][i / 8] - | |
617 q->tone_level_idx_hi2[ch][sb - 4]; | |
618 q->tone_level_idx[ch][sb][i] = tmp & 0xff; | |
619 if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp)) | |
620 q->tone_level[ch][sb][i] = 0; | |
621 else | |
622 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f]; | |
623 } | |
624 } else { | |
625 if (sb > 4) { | |
626 for (ch = 0; ch < q->nb_channels; ch++) | |
627 for (i = 0; i < 64; i++) { | |
628 tmp = q->tone_level_idx_base[ch][sb][i / 8] - | |
629 q->tone_level_idx_hi1[ch][2][i / 8][i % 8] - | |
630 q->tone_level_idx_hi2[ch][sb - 4]; | |
631 q->tone_level_idx[ch][sb][i] = tmp & 0xff; | |
632 if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp)) | |
633 q->tone_level[ch][sb][i] = 0; | |
634 else | |
635 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f]; | |
636 } | |
637 } else { | |
638 for (ch = 0; ch < q->nb_channels; ch++) | |
639 for (i = 0; i < 64; i++) { | |
640 tmp = q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8]; | |
641 if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp)) | |
642 q->tone_level[ch][sb][i] = 0; | |
643 else | |
644 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f]; | |
645 } | |
646 } | |
647 } | |
648 } | |
649 } | |
650 | |
651 return; | |
652 } | |
653 | |
654 | |
655 /** | |
656 * Related to synthesis filter | |
657 * Called by process_subpacket_11 | |
658 * c is built with data from subpacket 11 | |
659 * Most of this function is used only if superblock_type_2_3 == 0, never seen it in samples | |
660 * | |
2967 | 661 * @param tone_level_idx |
2914 | 662 * @param tone_level_idx_temp |
663 * @param coding_method q->coding_method[0][0][0] | |
664 * @param nb_channels number of channels | |
665 * @param c coming from subpacket 11, passed as 8*c | |
666 * @param superblocktype_2_3 flag based on superblock packet type | |
667 * @param cm_table_select q->cm_table_select | |
668 */ | |
669 static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp, | |
670 sb_int8_array coding_method, int nb_channels, | |
671 int c, int superblocktype_2_3, int cm_table_select) | |
672 { | |
673 int ch, sb, j; | |
674 int tmp, acc, esp_40, comp; | |
675 int add1, add2, add3, add4; | |
676 int64_t multres; | |
677 | |
678 // This should never happen | |
679 if (nb_channels <= 0) | |
680 return; | |
681 | |
682 if (!superblocktype_2_3) { | |
683 /* This case is untested, no samples available */ | |
684 SAMPLES_NEEDED | |
685 for (ch = 0; ch < nb_channels; ch++) | |
686 for (sb = 0; sb < 30; sb++) { | |
7326
fe8a7f5905e4
Prevent the qdm2 code from overreading/overflowing. Fixes Coverity ID 112 run 2
banan
parents:
7323
diff
changeset
|
687 for (j = 1; j < 63; j++) { // The loop only iterates to 63 so the code doesn't overflow the buffer |
2914 | 688 add1 = tone_level_idx[ch][sb][j] - 10; |
689 if (add1 < 0) | |
690 add1 = 0; | |
691 add2 = add3 = add4 = 0; | |
692 if (sb > 1) { | |
693 add2 = tone_level_idx[ch][sb - 2][j] + tone_level_idx_offset_table[sb][0] - 6; | |
694 if (add2 < 0) | |
695 add2 = 0; | |
696 } | |
697 if (sb > 0) { | |
698 add3 = tone_level_idx[ch][sb - 1][j] + tone_level_idx_offset_table[sb][1] - 6; | |
699 if (add3 < 0) | |
700 add3 = 0; | |
701 } | |
702 if (sb < 29) { | |
703 add4 = tone_level_idx[ch][sb + 1][j] + tone_level_idx_offset_table[sb][3] - 6; | |
704 if (add4 < 0) | |
705 add4 = 0; | |
706 } | |
707 tmp = tone_level_idx[ch][sb][j + 1] * 2 - add4 - add3 - add2 - add1; | |
708 if (tmp < 0) | |
709 tmp = 0; | |
710 tone_level_idx_temp[ch][sb][j + 1] = tmp & 0xff; | |
711 } | |
712 tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1]; | |
713 } | |
714 acc = 0; | |
715 for (ch = 0; ch < nb_channels; ch++) | |
716 for (sb = 0; sb < 30; sb++) | |
717 for (j = 0; j < 64; j++) | |
718 acc += tone_level_idx_temp[ch][sb][j]; | |
719 if (acc) | |
720 tmp = c * 256 / (acc & 0xffff); | |
721 multres = 0x66666667 * (acc * 10); | |
722 esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31); | |
723 for (ch = 0; ch < nb_channels; ch++) | |
724 for (sb = 0; sb < 30; sb++) | |
725 for (j = 0; j < 64; j++) { | |
726 comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10; | |
727 if (comp < 0) | |
728 comp += 0xff; | |
729 comp /= 256; // signed shift | |
730 switch(sb) { | |
731 case 0: | |
732 if (comp < 30) | |
733 comp = 30; | |
734 comp += 15; | |
735 break; | |
736 case 1: | |
737 if (comp < 24) | |
738 comp = 24; | |
739 comp += 10; | |
740 break; | |
741 case 2: | |
742 case 3: | |
743 case 4: | |
744 if (comp < 16) | |
745 comp = 16; | |
746 } | |
747 if (comp <= 5) | |
748 tmp = 0; | |
749 else if (comp <= 10) | |
750 tmp = 10; | |
751 else if (comp <= 16) | |
752 tmp = 16; | |
753 else if (comp <= 24) | |
754 tmp = -1; | |
755 else | |
756 tmp = 0; | |
757 coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff; | |
758 } | |
759 for (sb = 0; sb < 30; sb++) | |
760 fix_coding_method_array(sb, nb_channels, coding_method); | |
761 for (ch = 0; ch < nb_channels; ch++) | |
762 for (sb = 0; sb < 30; sb++) | |
763 for (j = 0; j < 64; j++) | |
764 if (sb >= 10) { | |
765 if (coding_method[ch][sb][j] < 10) | |
766 coding_method[ch][sb][j] = 10; | |
767 } else { | |
768 if (sb >= 2) { | |
769 if (coding_method[ch][sb][j] < 16) | |
770 coding_method[ch][sb][j] = 16; | |
771 } else { | |
772 if (coding_method[ch][sb][j] < 30) | |
773 coding_method[ch][sb][j] = 30; | |
774 } | |
775 } | |
776 } else { // superblocktype_2_3 != 0 | |
777 for (ch = 0; ch < nb_channels; ch++) | |
778 for (sb = 0; sb < 30; sb++) | |
779 for (j = 0; j < 64; j++) | |
780 coding_method[ch][sb][j] = coding_method_table[cm_table_select][sb]; | |
781 } | |
782 | |
783 return; | |
784 } | |
785 | |
786 | |
787 /** | |
788 * | |
789 * Called by process_subpacket_11 to process more data from subpacket 11 with sb 0-8 | |
790 * Called by process_subpacket_12 to process data from subpacket 12 with sb 8-sb_used | |
791 * | |
792 * @param q context | |
793 * @param gb bitreader context | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
794 * @param length packet length in bits |
2914 | 795 * @param sb_min lower subband processed (sb_min included) |
796 * @param sb_max higher subband processed (sb_max excluded) | |
797 */ | |
798 static void synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max) | |
799 { | |
800 int sb, j, k, n, ch, run, channels; | |
801 int joined_stereo, zero_encoding, chs; | |
802 int type34_first; | |
803 float type34_div = 0; | |
804 float type34_predictor; | |
805 float samples[10], sign_bits[16]; | |
806 | |
807 if (length == 0) { | |
808 // If no data use noise | |
809 for (sb=sb_min; sb < sb_max; sb++) | |
810 build_sb_samples_from_noise (q, sb); | |
811 | |
812 return; | |
813 } | |
814 | |
815 for (sb = sb_min; sb < sb_max; sb++) { | |
816 FIX_NOISE_IDX(q->noise_idx); | |
817 | |
818 channels = q->nb_channels; | |
819 | |
820 if (q->nb_channels <= 1 || sb < 12) | |
821 joined_stereo = 0; | |
822 else if (sb >= 24) | |
823 joined_stereo = 1; | |
824 else | |
825 joined_stereo = (BITS_LEFT(length,gb) >= 1) ? get_bits1 (gb) : 0; | |
826 | |
827 if (joined_stereo) { | |
828 if (BITS_LEFT(length,gb) >= 16) | |
829 for (j = 0; j < 16; j++) | |
830 sign_bits[j] = get_bits1 (gb); | |
831 | |
832 for (j = 0; j < 64; j++) | |
833 if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j]) | |
834 q->coding_method[0][sb][j] = q->coding_method[1][sb][j]; | |
835 | |
836 fix_coding_method_array(sb, q->nb_channels, q->coding_method); | |
837 channels = 1; | |
838 } | |
839 | |
840 for (ch = 0; ch < channels; ch++) { | |
841 zero_encoding = (BITS_LEFT(length,gb) >= 1) ? get_bits1(gb) : 0; | |
842 type34_predictor = 0.0; | |
843 type34_first = 1; | |
844 | |
845 for (j = 0; j < 128; ) { | |
846 switch (q->coding_method[ch][sb][j / 2]) { | |
847 case 8: | |
848 if (BITS_LEFT(length,gb) >= 10) { | |
849 if (zero_encoding) { | |
850 for (k = 0; k < 5; k++) { | |
851 if ((j + 2 * k) >= 128) | |
852 break; | |
853 samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0; | |
854 } | |
855 } else { | |
856 n = get_bits(gb, 8); | |
857 for (k = 0; k < 5; k++) | |
858 samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]]; | |
859 } | |
860 for (k = 0; k < 5; k++) | |
861 samples[2 * k + 1] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
862 } else { | |
863 for (k = 0; k < 10; k++) | |
864 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
865 } | |
866 run = 10; | |
867 break; | |
868 | |
869 case 10: | |
870 if (BITS_LEFT(length,gb) >= 1) { | |
871 float f = 0.81; | |
872 | |
873 if (get_bits1(gb)) | |
874 f = -f; | |
875 f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0; | |
876 samples[0] = f; | |
877 } else { | |
878 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
879 } | |
880 run = 1; | |
881 break; | |
882 | |
883 case 16: | |
884 if (BITS_LEFT(length,gb) >= 10) { | |
885 if (zero_encoding) { | |
886 for (k = 0; k < 5; k++) { | |
887 if ((j + k) >= 128) | |
888 break; | |
889 samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)]; | |
890 } | |
891 } else { | |
892 n = get_bits (gb, 8); | |
893 for (k = 0; k < 5; k++) | |
894 samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]]; | |
895 } | |
896 } else { | |
897 for (k = 0; k < 5; k++) | |
898 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
899 } | |
900 run = 5; | |
901 break; | |
902 | |
903 case 24: | |
904 if (BITS_LEFT(length,gb) >= 7) { | |
905 n = get_bits(gb, 7); | |
906 for (k = 0; k < 3; k++) | |
907 samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5; | |
908 } else { | |
909 for (k = 0; k < 3; k++) | |
910 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
911 } | |
912 run = 3; | |
913 break; | |
914 | |
915 case 30: | |
916 if (BITS_LEFT(length,gb) >= 4) | |
917 samples[0] = type30_dequant[qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1)]; | |
918 else | |
919 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
2967 | 920 |
2914 | 921 run = 1; |
922 break; | |
923 | |
924 case 34: | |
925 if (BITS_LEFT(length,gb) >= 7) { | |
926 if (type34_first) { | |
927 type34_div = (float)(1 << get_bits(gb, 2)); | |
928 samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0; | |
929 type34_predictor = samples[0]; | |
930 type34_first = 0; | |
931 } else { | |
932 samples[0] = type34_delta[qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1)] / type34_div + type34_predictor; | |
933 type34_predictor = samples[0]; | |
934 } | |
935 } else { | |
936 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
937 } | |
938 run = 1; | |
939 break; | |
940 | |
941 default: | |
942 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx); | |
943 run = 1; | |
944 break; | |
945 } | |
946 | |
947 if (joined_stereo) { | |
948 float tmp[10][MPA_MAX_CHANNELS]; | |
949 | |
950 for (k = 0; k < run; k++) { | |
951 tmp[k][0] = samples[k]; | |
952 tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k]; | |
953 } | |
954 for (chs = 0; chs < q->nb_channels; chs++) | |
955 for (k = 0; k < run; k++) | |
956 if ((j + k) < 128) | |
957 q->sb_samples[chs][j + k][sb] = (int32_t)(f2i_scale * q->tone_level[chs][sb][((j + k)/2)] * tmp[k][chs] + .5); | |
958 } else { | |
959 for (k = 0; k < run; k++) | |
960 if ((j + k) < 128) | |
961 q->sb_samples[ch][j + k][sb] = (int32_t)(f2i_scale * q->tone_level[ch][sb][(j + k)/2] * samples[k] + .5); | |
962 } | |
963 | |
964 j += run; | |
965 } // j loop | |
966 } // channel loop | |
967 } // subband loop | |
968 } | |
969 | |
970 | |
971 /** | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
972 * Init the first element of a channel in quantized_coeffs with data from packet 10 (quantized_coeffs[ch][0]). |
2914 | 973 * This is similar to process_subpacket_9, but for a single channel and for element [0] |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
974 * same VLC tables as process_subpacket_9 are used. |
2914 | 975 * |
976 * @param q context | |
977 * @param quantized_coeffs pointer to quantized_coeffs[ch][0] | |
978 * @param gb bitreader context | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
979 * @param length packet length in bits |
2914 | 980 */ |
981 static void init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext *gb, int length) | |
982 { | |
983 int i, k, run, level, diff; | |
984 | |
985 if (BITS_LEFT(length,gb) < 16) | |
986 return; | |
987 level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2); | |
988 | |
989 quantized_coeffs[0] = level; | |
990 | |
991 for (i = 0; i < 7; ) { | |
992 if (BITS_LEFT(length,gb) < 16) | |
993 break; | |
994 run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1; | |
995 | |
996 if (BITS_LEFT(length,gb) < 16) | |
997 break; | |
998 diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2); | |
2967 | 999 |
2914 | 1000 for (k = 1; k <= run; k++) |
1001 quantized_coeffs[i + k] = (level + ((k * diff) / run)); | |
2967 | 1002 |
2914 | 1003 level += diff; |
1004 i += run; | |
1005 } | |
1006 } | |
1007 | |
1008 | |
1009 /** | |
1010 * Related to synthesis filter, process data from packet 10 | |
1011 * Init part of quantized_coeffs via function init_quantized_coeffs_elem0 | |
1012 * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with data from packet 10 | |
1013 * | |
1014 * @param q context | |
1015 * @param gb bitreader context | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1016 * @param length packet length in bits |
2914 | 1017 */ |
1018 static void init_tone_level_dequantization (QDM2Context *q, GetBitContext *gb, int length) | |
1019 { | |
1020 int sb, j, k, n, ch; | |
1021 | |
1022 for (ch = 0; ch < q->nb_channels; ch++) { | |
1023 init_quantized_coeffs_elem0(q->quantized_coeffs[ch][0], gb, length); | |
1024 | |
1025 if (BITS_LEFT(length,gb) < 16) { | |
1026 memset(q->quantized_coeffs[ch][0], 0, 8); | |
1027 break; | |
1028 } | |
1029 } | |
1030 | |
1031 n = q->sub_sampling + 1; | |
1032 | |
1033 for (sb = 0; sb < n; sb++) | |
1034 for (ch = 0; ch < q->nb_channels; ch++) | |
1035 for (j = 0; j < 8; j++) { | |
1036 if (BITS_LEFT(length,gb) < 1) | |
1037 break; | |
1038 if (get_bits1(gb)) { | |
1039 for (k=0; k < 8; k++) { | |
1040 if (BITS_LEFT(length,gb) < 16) | |
1041 break; | |
1042 q->tone_level_idx_hi1[ch][sb][j][k] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi1, 0, 2); | |
1043 } | |
1044 } else { | |
1045 for (k=0; k < 8; k++) | |
1046 q->tone_level_idx_hi1[ch][sb][j][k] = 0; | |
1047 } | |
1048 } | |
1049 | |
1050 n = QDM2_SB_USED(q->sub_sampling) - 4; | |
1051 | |
1052 for (sb = 0; sb < n; sb++) | |
1053 for (ch = 0; ch < q->nb_channels; ch++) { | |
1054 if (BITS_LEFT(length,gb) < 16) | |
1055 break; | |
1056 q->tone_level_idx_hi2[ch][sb] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi2, 0, 2); | |
1057 if (sb > 19) | |
1058 q->tone_level_idx_hi2[ch][sb] -= 16; | |
1059 else | |
1060 for (j = 0; j < 8; j++) | |
1061 q->tone_level_idx_mid[ch][sb][j] = -16; | |
1062 } | |
1063 | |
1064 n = QDM2_SB_USED(q->sub_sampling) - 5; | |
1065 | |
1066 for (sb = 0; sb < n; sb++) | |
1067 for (ch = 0; ch < q->nb_channels; ch++) | |
1068 for (j = 0; j < 8; j++) { | |
1069 if (BITS_LEFT(length,gb) < 16) | |
1070 break; | |
1071 q->tone_level_idx_mid[ch][sb][j] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_mid, 0, 2) - 32; | |
1072 } | |
1073 } | |
1074 | |
1075 /** | |
1076 * Process subpacket 9, init quantized_coeffs with data from it | |
1077 * | |
1078 * @param q context | |
1079 * @param node pointer to node with packet | |
1080 */ | |
1081 static void process_subpacket_9 (QDM2Context *q, QDM2SubPNode *node) | |
1082 { | |
1083 GetBitContext gb; | |
1084 int i, j, k, n, ch, run, level, diff; | |
1085 | |
2916 | 1086 init_get_bits(&gb, node->packet->data, node->packet->size*8); |
2914 | 1087 |
1088 n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1; // same as averagesomething function | |
1089 | |
1090 for (i = 1; i < n; i++) | |
1091 for (ch=0; ch < q->nb_channels; ch++) { | |
1092 level = qdm2_get_vlc(&gb, &vlc_tab_level, 0, 2); | |
1093 q->quantized_coeffs[ch][i][0] = level; | |
1094 | |
1095 for (j = 0; j < (8 - 1); ) { | |
1096 run = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1; | |
1097 diff = qdm2_get_se_vlc(&vlc_tab_diff, &gb, 2); | |
1098 | |
1099 for (k = 1; k <= run; k++) | |
1100 q->quantized_coeffs[ch][i][j + k] = (level + ((k*diff) / run)); | |
1101 | |
1102 level += diff; | |
1103 j += run; | |
1104 } | |
1105 } | |
1106 | |
1107 for (ch = 0; ch < q->nb_channels; ch++) | |
1108 for (i = 0; i < 8; i++) | |
1109 q->quantized_coeffs[ch][0][i] = 0; | |
1110 } | |
1111 | |
1112 | |
1113 /** | |
1114 * Process subpacket 10 if not null, else | |
1115 * | |
1116 * @param q context | |
1117 * @param node pointer to node with packet | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1118 * @param length packet length in bits |
2914 | 1119 */ |
1120 static void process_subpacket_10 (QDM2Context *q, QDM2SubPNode *node, int length) | |
1121 { | |
1122 GetBitContext gb; | |
1123 | |
2916 | 1124 init_get_bits(&gb, ((node == NULL) ? empty_buffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8)); |
2914 | 1125 |
1126 if (length != 0) { | |
1127 init_tone_level_dequantization(q, &gb, length); | |
1128 fill_tone_level_array(q, 1); | |
1129 } else { | |
1130 fill_tone_level_array(q, 0); | |
1131 } | |
1132 } | |
1133 | |
1134 | |
1135 /** | |
1136 * Process subpacket 11 | |
1137 * | |
1138 * @param q context | |
1139 * @param node pointer to node with packet | |
1140 * @param length packet length in bit | |
1141 */ | |
1142 static void process_subpacket_11 (QDM2Context *q, QDM2SubPNode *node, int length) | |
1143 { | |
1144 GetBitContext gb; | |
1145 | |
2916 | 1146 init_get_bits(&gb, ((node == NULL) ? empty_buffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8)); |
2914 | 1147 if (length >= 32) { |
1148 int c = get_bits (&gb, 13); | |
1149 | |
1150 if (c > 3) | |
1151 fill_coding_method_array (q->tone_level_idx, q->tone_level_idx_temp, q->coding_method, | |
1152 q->nb_channels, 8*c, q->superblocktype_2_3, q->cm_table_select); | |
1153 } | |
1154 | |
1155 synthfilt_build_sb_samples(q, &gb, length, 0, 8); | |
1156 } | |
1157 | |
1158 | |
1159 /** | |
1160 * Process subpacket 12 | |
1161 * | |
1162 * @param q context | |
1163 * @param node pointer to node with packet | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1164 * @param length packet length in bits |
2914 | 1165 */ |
1166 static void process_subpacket_12 (QDM2Context *q, QDM2SubPNode *node, int length) | |
1167 { | |
1168 GetBitContext gb; | |
1169 | |
2916 | 1170 init_get_bits(&gb, ((node == NULL) ? empty_buffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8)); |
2914 | 1171 synthfilt_build_sb_samples(q, &gb, length, 8, QDM2_SB_USED(q->sub_sampling)); |
1172 } | |
1173 | |
1174 /* | |
1175 * Process new subpackets for synthesis filter | |
1176 * | |
1177 * @param q context | |
1178 * @param list list with synthesis filter packets (list D) | |
1179 */ | |
1180 static void process_synthesis_subpackets (QDM2Context *q, QDM2SubPNode *list) | |
1181 { | |
1182 QDM2SubPNode *nodes[4]; | |
1183 | |
1184 nodes[0] = qdm2_search_subpacket_type_in_list(list, 9); | |
1185 if (nodes[0] != NULL) | |
1186 process_subpacket_9(q, nodes[0]); | |
1187 | |
1188 nodes[1] = qdm2_search_subpacket_type_in_list(list, 10); | |
1189 if (nodes[1] != NULL) | |
1190 process_subpacket_10(q, nodes[1], nodes[1]->packet->size << 3); | |
1191 else | |
1192 process_subpacket_10(q, NULL, 0); | |
1193 | |
1194 nodes[2] = qdm2_search_subpacket_type_in_list(list, 11); | |
1195 if (nodes[0] != NULL && nodes[1] != NULL && nodes[2] != NULL) | |
1196 process_subpacket_11(q, nodes[2], (nodes[2]->packet->size << 3)); | |
1197 else | |
1198 process_subpacket_11(q, NULL, 0); | |
1199 | |
1200 nodes[3] = qdm2_search_subpacket_type_in_list(list, 12); | |
1201 if (nodes[0] != NULL && nodes[1] != NULL && nodes[3] != NULL) | |
1202 process_subpacket_12(q, nodes[3], (nodes[3]->packet->size << 3)); | |
1203 else | |
1204 process_subpacket_12(q, NULL, 0); | |
1205 } | |
1206 | |
1207 | |
1208 /* | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1209 * Decode superblock, fill packet lists. |
2914 | 1210 * |
1211 * @param q context | |
1212 */ | |
1213 static void qdm2_decode_super_block (QDM2Context *q) | |
1214 { | |
1215 GetBitContext gb; | |
1216 QDM2SubPacket header, *packet; | |
1217 int i, packet_bytes, sub_packet_size, sub_packets_D; | |
1218 unsigned int next_index = 0; | |
1219 | |
1220 memset(q->tone_level_idx_hi1, 0, sizeof(q->tone_level_idx_hi1)); | |
1221 memset(q->tone_level_idx_mid, 0, sizeof(q->tone_level_idx_mid)); | |
1222 memset(q->tone_level_idx_hi2, 0, sizeof(q->tone_level_idx_hi2)); | |
1223 | |
1224 q->sub_packets_B = 0; | |
1225 sub_packets_D = 0; | |
1226 | |
1227 average_quantized_coeffs(q); // average elements in quantized_coeffs[max_ch][10][8] | |
1228 | |
2916 | 1229 init_get_bits(&gb, q->compressed_data, q->compressed_size*8); |
2914 | 1230 qdm2_decode_sub_packet_header(&gb, &header); |
1231 | |
1232 if (header.type < 2 || header.type >= 8) { | |
1233 q->has_errors = 1; | |
1234 av_log(NULL,AV_LOG_ERROR,"bad superblock type\n"); | |
1235 return; | |
1236 } | |
1237 | |
1238 q->superblocktype_2_3 = (header.type == 2 || header.type == 3); | |
1239 packet_bytes = (q->compressed_size - get_bits_count(&gb) / 8); | |
1240 | |
2916 | 1241 init_get_bits(&gb, header.data, header.size*8); |
2914 | 1242 |
1243 if (header.type == 2 || header.type == 4 || header.type == 5) { | |
1244 int csum = 257 * get_bits(&gb, 8) + 2 * get_bits(&gb, 8); | |
1245 | |
1246 csum = qdm2_packet_checksum(q->compressed_data, q->checksum_size, csum); | |
1247 | |
1248 if (csum != 0) { | |
1249 q->has_errors = 1; | |
1250 av_log(NULL,AV_LOG_ERROR,"bad packet checksum\n"); | |
1251 return; | |
1252 } | |
1253 } | |
1254 | |
1255 q->sub_packet_list_B[0].packet = NULL; | |
1256 q->sub_packet_list_D[0].packet = NULL; | |
1257 | |
1258 for (i = 0; i < 6; i++) | |
1259 if (--q->fft_level_exp[i] < 0) | |
1260 q->fft_level_exp[i] = 0; | |
1261 | |
1262 for (i = 0; packet_bytes > 0; i++) { | |
1263 int j; | |
1264 | |
1265 q->sub_packet_list_A[i].next = NULL; | |
1266 | |
1267 if (i > 0) { | |
1268 q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i]; | |
1269 | |
1270 /* seek to next block */ | |
2916 | 1271 init_get_bits(&gb, header.data, header.size*8); |
2914 | 1272 skip_bits(&gb, next_index*8); |
1273 | |
1274 if (next_index >= header.size) | |
1275 break; | |
1276 } | |
1277 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1278 /* decode subpacket */ |
2914 | 1279 packet = &q->sub_packets[i]; |
1280 qdm2_decode_sub_packet_header(&gb, packet); | |
1281 next_index = packet->size + get_bits_count(&gb) / 8; | |
1282 sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2; | |
1283 | |
1284 if (packet->type == 0) | |
1285 break; | |
1286 | |
1287 if (sub_packet_size > packet_bytes) { | |
1288 if (packet->type != 10 && packet->type != 11 && packet->type != 12) | |
1289 break; | |
1290 packet->size += packet_bytes - sub_packet_size; | |
1291 } | |
1292 | |
1293 packet_bytes -= sub_packet_size; | |
1294 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1295 /* add subpacket to 'all subpackets' list */ |
2914 | 1296 q->sub_packet_list_A[i].packet = packet; |
1297 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1298 /* add subpacket to related list */ |
2914 | 1299 if (packet->type == 8) { |
1300 SAMPLES_NEEDED_2("packet type 8"); | |
1301 return; | |
1302 } else if (packet->type >= 9 && packet->type <= 12) { | |
1303 /* packets for MPEG Audio like Synthesis Filter */ | |
1304 QDM2_LIST_ADD(q->sub_packet_list_D, sub_packets_D, packet); | |
1305 } else if (packet->type == 13) { | |
1306 for (j = 0; j < 6; j++) | |
1307 q->fft_level_exp[j] = get_bits(&gb, 6); | |
1308 } else if (packet->type == 14) { | |
1309 for (j = 0; j < 6; j++) | |
1310 q->fft_level_exp[j] = qdm2_get_vlc(&gb, &fft_level_exp_vlc, 0, 2); | |
1311 } else if (packet->type == 15) { | |
1312 SAMPLES_NEEDED_2("packet type 15") | |
1313 return; | |
1314 } else if (packet->type >= 16 && packet->type < 48 && !fft_subpackets[packet->type - 16]) { | |
1315 /* packets for FFT */ | |
1316 QDM2_LIST_ADD(q->sub_packet_list_B, q->sub_packets_B, packet); | |
1317 } | |
1318 } // Packet bytes loop | |
1319 | |
1320 /* **************************************************************** */ | |
1321 if (q->sub_packet_list_D[0].packet != NULL) { | |
1322 process_synthesis_subpackets(q, q->sub_packet_list_D); | |
1323 q->do_synth_filter = 1; | |
1324 } else if (q->do_synth_filter) { | |
1325 process_subpacket_10(q, NULL, 0); | |
1326 process_subpacket_11(q, NULL, 0); | |
1327 process_subpacket_12(q, NULL, 0); | |
1328 } | |
1329 /* **************************************************************** */ | |
1330 } | |
1331 | |
1332 | |
1333 static void qdm2_fft_init_coefficient (QDM2Context *q, int sub_packet, | |
1334 int offset, int duration, int channel, | |
1335 int exp, int phase) | |
1336 { | |
1337 if (q->fft_coefs_min_index[duration] < 0) | |
1338 q->fft_coefs_min_index[duration] = q->fft_coefs_index; | |
1339 | |
1340 q->fft_coefs[q->fft_coefs_index].sub_packet = ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet); | |
1341 q->fft_coefs[q->fft_coefs_index].channel = channel; | |
1342 q->fft_coefs[q->fft_coefs_index].offset = offset; | |
1343 q->fft_coefs[q->fft_coefs_index].exp = exp; | |
1344 q->fft_coefs[q->fft_coefs_index].phase = phase; | |
1345 q->fft_coefs_index++; | |
1346 } | |
1347 | |
1348 | |
1349 static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *gb, int b) | |
1350 { | |
1351 int channel, stereo, phase, exp; | |
1352 int local_int_4, local_int_8, stereo_phase, local_int_10; | |
1353 int local_int_14, stereo_exp, local_int_20, local_int_28; | |
1354 int n, offset; | |
1355 | |
1356 local_int_4 = 0; | |
1357 local_int_28 = 0; | |
1358 local_int_20 = 2; | |
1359 local_int_8 = (4 - duration); | |
1360 local_int_10 = 1 << (q->group_order - duration - 1); | |
1361 offset = 1; | |
1362 | |
1363 while (1) { | |
1364 if (q->superblocktype_2_3) { | |
1365 while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) { | |
1366 offset = 1; | |
1367 if (n == 0) { | |
1368 local_int_4 += local_int_10; | |
1369 local_int_28 += (1 << local_int_8); | |
1370 } else { | |
1371 local_int_4 += 8*local_int_10; | |
1372 local_int_28 += (8 << local_int_8); | |
1373 } | |
1374 } | |
1375 offset += (n - 2); | |
1376 } else { | |
1377 offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2); | |
1378 while (offset >= (local_int_10 - 1)) { | |
1379 offset += (1 - (local_int_10 - 1)); | |
1380 local_int_4 += local_int_10; | |
1381 local_int_28 += (1 << local_int_8); | |
1382 } | |
1383 } | |
1384 | |
1385 if (local_int_4 >= q->group_size) | |
1386 return; | |
1387 | |
1388 local_int_14 = (offset >> local_int_8); | |
1389 | |
1390 if (q->nb_channels > 1) { | |
1391 channel = get_bits1(gb); | |
1392 stereo = get_bits1(gb); | |
1393 } else { | |
1394 channel = 0; | |
1395 stereo = 0; | |
1396 } | |
1397 | |
1398 exp = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2); | |
1399 exp += q->fft_level_exp[fft_level_index_table[local_int_14]]; | |
1400 exp = (exp < 0) ? 0 : exp; | |
1401 | |
1402 phase = get_bits(gb, 3); | |
1403 stereo_exp = 0; | |
1404 stereo_phase = 0; | |
1405 | |
1406 if (stereo) { | |
1407 stereo_exp = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1)); | |
1408 stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1)); | |
1409 if (stereo_phase < 0) | |
1410 stereo_phase += 8; | |
1411 } | |
1412 | |
1413 if (q->frequency_range > (local_int_14 + 1)) { | |
1414 int sub_packet = (local_int_20 + local_int_28); | |
1415 | |
1416 qdm2_fft_init_coefficient(q, sub_packet, offset, duration, channel, exp, phase); | |
1417 if (stereo) | |
1418 qdm2_fft_init_coefficient(q, sub_packet, offset, duration, (1 - channel), stereo_exp, stereo_phase); | |
1419 } | |
1420 | |
1421 offset++; | |
1422 } | |
1423 } | |
1424 | |
1425 | |
1426 static void qdm2_decode_fft_packets (QDM2Context *q) | |
1427 { | |
1428 int i, j, min, max, value, type, unknown_flag; | |
1429 GetBitContext gb; | |
1430 | |
1431 if (q->sub_packet_list_B[0].packet == NULL) | |
1432 return; | |
1433 | |
6903 | 1434 /* reset minimum indexes for FFT coefficients */ |
2914 | 1435 q->fft_coefs_index = 0; |
1436 for (i=0; i < 5; i++) | |
1437 q->fft_coefs_min_index[i] = -1; | |
1438 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1439 /* process subpackets ordered by type, largest type first */ |
2914 | 1440 for (i = 0, max = 256; i < q->sub_packets_B; i++) { |
7306 | 1441 QDM2SubPacket *packet= NULL; |
2914 | 1442 |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1443 /* find subpacket with largest type less than max */ |
7306 | 1444 for (j = 0, min = 0; j < q->sub_packets_B; j++) { |
2914 | 1445 value = q->sub_packet_list_B[j].packet->type; |
1446 if (value > min && value < max) { | |
1447 min = value; | |
1448 packet = q->sub_packet_list_B[j].packet; | |
1449 } | |
1450 } | |
1451 | |
1452 max = min; | |
1453 | |
1454 /* check for errors (?) */ | |
7323
5d6c51a125d0
Fix for possible null pointer dereferencing, closes Coverity report 68 run 2.
banan
parents:
7306
diff
changeset
|
1455 if (!packet) |
5d6c51a125d0
Fix for possible null pointer dereferencing, closes Coverity report 68 run 2.
banan
parents:
7306
diff
changeset
|
1456 return; |
5d6c51a125d0
Fix for possible null pointer dereferencing, closes Coverity report 68 run 2.
banan
parents:
7306
diff
changeset
|
1457 |
2914 | 1458 if (i == 0 && (packet->type < 16 || packet->type >= 48 || fft_subpackets[packet->type - 16])) |
1459 return; | |
1460 | |
1461 /* decode FFT tones */ | |
2916 | 1462 init_get_bits (&gb, packet->data, packet->size*8); |
2914 | 1463 |
1464 if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16]) | |
1465 unknown_flag = 1; | |
1466 else | |
1467 unknown_flag = 0; | |
1468 | |
1469 type = packet->type; | |
1470 | |
1471 if ((type >= 17 && type < 24) || (type >= 33 && type < 40)) { | |
1472 int duration = q->sub_sampling + 5 - (type & 15); | |
1473 | |
1474 if (duration >= 0 && duration < 4) | |
1475 qdm2_fft_decode_tones(q, duration, &gb, unknown_flag); | |
1476 } else if (type == 31) { | |
3320 | 1477 for (j=0; j < 4; j++) |
1478 qdm2_fft_decode_tones(q, j, &gb, unknown_flag); | |
2914 | 1479 } else if (type == 46) { |
3320 | 1480 for (j=0; j < 6; j++) |
1481 q->fft_level_exp[j] = get_bits(&gb, 6); | |
1482 for (j=0; j < 4; j++) | |
1483 qdm2_fft_decode_tones(q, j, &gb, unknown_flag); | |
2914 | 1484 } |
1485 } // Loop on B packets | |
1486 | |
6903 | 1487 /* calculate maximum indexes for FFT coefficients */ |
2914 | 1488 for (i = 0, j = -1; i < 5; i++) |
1489 if (q->fft_coefs_min_index[i] >= 0) { | |
1490 if (j >= 0) | |
1491 q->fft_coefs_max_index[j] = q->fft_coefs_min_index[i]; | |
1492 j = i; | |
1493 } | |
1494 if (j >= 0) | |
1495 q->fft_coefs_max_index[j] = q->fft_coefs_index; | |
1496 } | |
1497 | |
1498 | |
1499 static void qdm2_fft_generate_tone (QDM2Context *q, FFTTone *tone) | |
1500 { | |
1501 float level, f[6]; | |
1502 int i; | |
1503 QDM2Complex c; | |
1504 const double iscale = 2.0*M_PI / 512.0; | |
1505 | |
1506 tone->phase += tone->phase_shift; | |
1507 | |
1508 /* calculate current level (maximum amplitude) of tone */ | |
1509 level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level; | |
1510 c.im = level * sin(tone->phase*iscale); | |
1511 c.re = level * cos(tone->phase*iscale); | |
1512 | |
1513 /* generate FFT coefficients for tone */ | |
1514 if (tone->duration >= 3 || tone->cutoff >= 3) { | |
1515 tone->samples_im[0] += c.im; | |
1516 tone->samples_re[0] += c.re; | |
1517 tone->samples_im[1] -= c.im; | |
1518 tone->samples_re[1] -= c.re; | |
1519 } else { | |
1520 f[1] = -tone->table[4]; | |
1521 f[0] = tone->table[3] - tone->table[0]; | |
1522 f[2] = 1.0 - tone->table[2] - tone->table[3]; | |
1523 f[3] = tone->table[1] + tone->table[4] - 1.0; | |
1524 f[4] = tone->table[0] - tone->table[1]; | |
1525 f[5] = tone->table[2]; | |
1526 for (i = 0; i < 2; i++) { | |
1527 tone->samples_re[fft_cutoff_index_table[tone->cutoff][i]] += c.re * f[i]; | |
1528 tone->samples_im[fft_cutoff_index_table[tone->cutoff][i]] += c.im *((tone->cutoff <= i) ? -f[i] : f[i]); | |
1529 } | |
1530 for (i = 0; i < 4; i++) { | |
1531 tone->samples_re[i] += c.re * f[i+2]; | |
1532 tone->samples_im[i] += c.im * f[i+2]; | |
1533 } | |
1534 } | |
1535 | |
1536 /* copy the tone if it has not yet died out */ | |
1537 if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) { | |
1538 memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone)); | |
1539 q->fft_tone_end = (q->fft_tone_end + 1) % 1000; | |
1540 } | |
1541 } | |
1542 | |
1543 | |
1544 static void qdm2_fft_tone_synthesizer (QDM2Context *q, int sub_packet) | |
1545 { | |
1546 int i, j, ch; | |
1547 const double iscale = 0.25 * M_PI; | |
1548 | |
1549 for (ch = 0; ch < q->channels; ch++) { | |
1550 memset(q->fft.samples_im[ch], 0, q->fft_size * sizeof(float)); | |
1551 memset(q->fft.samples_re[ch], 0, q->fft_size * sizeof(float)); | |
1552 } | |
1553 | |
1554 | |
1555 /* apply FFT tones with duration 4 (1 FFT period) */ | |
1556 if (q->fft_coefs_min_index[4] >= 0) | |
1557 for (i = q->fft_coefs_min_index[4]; i < q->fft_coefs_max_index[4]; i++) { | |
1558 float level; | |
1559 QDM2Complex c; | |
1560 | |
1561 if (q->fft_coefs[i].sub_packet != sub_packet) | |
1562 break; | |
1563 | |
1564 ch = (q->channels == 1) ? 0 : q->fft_coefs[i].channel; | |
1565 level = (q->fft_coefs[i].exp < 0) ? 0.0 : fft_tone_level_table[q->superblocktype_2_3 ? 0 : 1][q->fft_coefs[i].exp & 63]; | |
1566 | |
1567 c.re = level * cos(q->fft_coefs[i].phase * iscale); | |
1568 c.im = level * sin(q->fft_coefs[i].phase * iscale); | |
1569 q->fft.samples_re[ch][q->fft_coefs[i].offset + 0] += c.re; | |
1570 q->fft.samples_im[ch][q->fft_coefs[i].offset + 0] += c.im; | |
1571 q->fft.samples_re[ch][q->fft_coefs[i].offset + 1] -= c.re; | |
1572 q->fft.samples_im[ch][q->fft_coefs[i].offset + 1] -= c.im; | |
1573 } | |
1574 | |
1575 /* generate existing FFT tones */ | |
1576 for (i = q->fft_tone_end; i != q->fft_tone_start; ) { | |
1577 qdm2_fft_generate_tone(q, &q->fft_tones[q->fft_tone_start]); | |
1578 q->fft_tone_start = (q->fft_tone_start + 1) % 1000; | |
1579 } | |
1580 | |
1581 /* create and generate new FFT tones with duration 0 (long) to 3 (short) */ | |
1582 for (i = 0; i < 4; i++) | |
1583 if (q->fft_coefs_min_index[i] >= 0) { | |
1584 for (j = q->fft_coefs_min_index[i]; j < q->fft_coefs_max_index[i]; j++) { | |
1585 int offset, four_i; | |
1586 FFTTone tone; | |
1587 | |
1588 if (q->fft_coefs[j].sub_packet != sub_packet) | |
1589 break; | |
1590 | |
1591 four_i = (4 - i); | |
1592 offset = q->fft_coefs[j].offset >> four_i; | |
1593 ch = (q->channels == 1) ? 0 : q->fft_coefs[j].channel; | |
1594 | |
1595 if (offset < q->frequency_range) { | |
1596 if (offset < 2) | |
1597 tone.cutoff = offset; | |
1598 else | |
1599 tone.cutoff = (offset >= 60) ? 3 : 2; | |
1600 | |
1601 tone.level = (q->fft_coefs[j].exp < 0) ? 0.0 : fft_tone_level_table[q->superblocktype_2_3 ? 0 : 1][q->fft_coefs[j].exp & 63]; | |
1602 tone.samples_im = &q->fft.samples_im[ch][offset]; | |
1603 tone.samples_re = &q->fft.samples_re[ch][offset]; | |
6273 | 1604 tone.table = fft_tone_sample_table[i][q->fft_coefs[j].offset - (offset << four_i)]; |
2914 | 1605 tone.phase = 64 * q->fft_coefs[j].phase - (offset << 8) - 128; |
1606 tone.phase_shift = (2 * q->fft_coefs[j].offset + 1) << (7 - four_i); | |
1607 tone.duration = i; | |
1608 tone.time_index = 0; | |
1609 | |
1610 qdm2_fft_generate_tone(q, &tone); | |
1611 } | |
1612 } | |
1613 q->fft_coefs_min_index[i] = j; | |
1614 } | |
1615 } | |
1616 | |
1617 | |
1618 static void qdm2_calculate_fft (QDM2Context *q, int channel, int sub_packet) | |
1619 { | |
1620 const int n = 1 << (q->fft_order - 1); | |
1621 const int n2 = n >> 1; | |
1622 const float gain = (q->channels == 1 && q->nb_channels == 2) ? 0.25f : 0.50f; | |
1623 float c, s, f0, f1, f2, f3; | |
1624 int i, j; | |
1625 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1626 /* prerotation (or something like that) */ |
2914 | 1627 for (i=1; i < n2; i++) { |
1628 j = (n - i); | |
1629 c = q->exptab[i].re; | |
1630 s = -q->exptab[i].im; | |
1631 f0 = (q->fft.samples_re[channel][i] - q->fft.samples_re[channel][j]) * gain; | |
1632 f1 = (q->fft.samples_im[channel][i] + q->fft.samples_im[channel][j]) * gain; | |
1633 f2 = (q->fft.samples_re[channel][i] + q->fft.samples_re[channel][j]) * gain; | |
1634 f3 = (q->fft.samples_im[channel][i] - q->fft.samples_im[channel][j]) * gain; | |
1635 q->fft.complex[i].re = s * f0 - c * f1 + f2; | |
1636 q->fft.complex[i].im = c * f0 + s * f1 + f3; | |
1637 q->fft.complex[j].re = -s * f0 + c * f1 + f2; | |
1638 q->fft.complex[j].im = c * f0 + s * f1 - f3; | |
1639 } | |
1640 | |
1641 q->fft.complex[ 0].re = q->fft.samples_re[channel][ 0] * gain * 2.0; | |
1642 q->fft.complex[ 0].im = q->fft.samples_re[channel][ 0] * gain * 2.0; | |
1643 q->fft.complex[n2].re = q->fft.samples_re[channel][n2] * gain * 2.0; | |
1644 q->fft.complex[n2].im = -q->fft.samples_im[channel][n2] * gain * 2.0; | |
1645 | |
1646 ff_fft_permute(&q->fft_ctx, (FFTComplex *) q->fft.complex); | |
1647 ff_fft_calc (&q->fft_ctx, (FFTComplex *) q->fft.complex); | |
1648 /* add samples to output buffer */ | |
1649 for (i = 0; i < ((q->fft_frame_size + 15) & ~15); i++) | |
1650 q->output_buffer[q->channels * i + channel] += ((float *) q->fft.complex)[i]; | |
1651 } | |
1652 | |
1653 | |
1654 /** | |
1655 * @param q context | |
1656 * @param index subpacket number | |
1657 */ | |
1658 static void qdm2_synthesis_filter (QDM2Context *q, int index) | |
1659 { | |
1660 OUT_INT samples[MPA_MAX_CHANNELS * MPA_FRAME_SIZE]; | |
1661 int i, k, ch, sb_used, sub_sampling, dither_state = 0; | |
1662 | |
1663 /* copy sb_samples */ | |
1664 sb_used = QDM2_SB_USED(q->sub_sampling); | |
1665 | |
1666 for (ch = 0; ch < q->channels; ch++) | |
1667 for (i = 0; i < 8; i++) | |
1668 for (k=sb_used; k < SBLIMIT; k++) | |
1669 q->sb_samples[ch][(8 * index) + i][k] = 0; | |
1670 | |
1671 for (ch = 0; ch < q->nb_channels; ch++) { | |
1672 OUT_INT *samples_ptr = samples + ch; | |
1673 | |
1674 for (i = 0; i < 8; i++) { | |
1675 ff_mpa_synth_filter(q->synth_buf[ch], &(q->synth_buf_offset[ch]), | |
1676 mpa_window, &dither_state, | |
1677 samples_ptr, q->nb_channels, | |
1678 q->sb_samples[ch][(8 * index) + i]); | |
1679 samples_ptr += 32 * q->nb_channels; | |
1680 } | |
1681 } | |
1682 | |
1683 /* add samples to output buffer */ | |
1684 sub_sampling = (4 >> q->sub_sampling); | |
1685 | |
1686 for (ch = 0; ch < q->channels; ch++) | |
1687 for (i = 0; i < q->frame_size; i++) | |
1688 q->output_buffer[q->channels * i + ch] += (float)(samples[q->nb_channels * sub_sampling * i + ch] >> (sizeof(OUT_INT)*8-16)); | |
1689 } | |
1690 | |
1691 | |
1692 /** | |
1693 * Init static data (does not depend on specific file) | |
1694 * | |
1695 * @param q context | |
1696 */ | |
3076 | 1697 static void qdm2_init(QDM2Context *q) { |
6350 | 1698 static int initialized = 0; |
2914 | 1699 |
6350 | 1700 if (initialized != 0) |
2914 | 1701 return; |
6350 | 1702 initialized = 1; |
2914 | 1703 |
1704 qdm2_init_vlc(); | |
1705 ff_mpa_synth_init(mpa_window); | |
1706 softclip_table_init(); | |
1707 rnd_table_init(); | |
1708 init_noise_samples(); | |
1709 | |
1710 av_log(NULL, AV_LOG_DEBUG, "init done\n"); | |
1711 } | |
1712 | |
1713 | |
1714 #if 0 | |
1715 static void dump_context(QDM2Context *q) | |
1716 { | |
1717 int i; | |
1718 #define PRINT(a,b) av_log(NULL,AV_LOG_DEBUG," %s = %d\n", a, b); | |
1719 PRINT("compressed_data",q->compressed_data); | |
1720 PRINT("compressed_size",q->compressed_size); | |
1721 PRINT("frame_size",q->frame_size); | |
1722 PRINT("checksum_size",q->checksum_size); | |
1723 PRINT("channels",q->channels); | |
1724 PRINT("nb_channels",q->nb_channels); | |
1725 PRINT("fft_frame_size",q->fft_frame_size); | |
1726 PRINT("fft_size",q->fft_size); | |
1727 PRINT("sub_sampling",q->sub_sampling); | |
1728 PRINT("fft_order",q->fft_order); | |
1729 PRINT("group_order",q->group_order); | |
1730 PRINT("group_size",q->group_size); | |
1731 PRINT("sub_packet",q->sub_packet); | |
1732 PRINT("frequency_range",q->frequency_range); | |
1733 PRINT("has_errors",q->has_errors); | |
1734 PRINT("fft_tone_end",q->fft_tone_end); | |
1735 PRINT("fft_tone_start",q->fft_tone_start); | |
1736 PRINT("fft_coefs_index",q->fft_coefs_index); | |
1737 PRINT("coeff_per_sb_select",q->coeff_per_sb_select); | |
1738 PRINT("cm_table_select",q->cm_table_select); | |
1739 PRINT("noise_idx",q->noise_idx); | |
1740 | |
1741 for (i = q->fft_tone_start; i < q->fft_tone_end; i++) | |
1742 { | |
1743 FFTTone *t = &q->fft_tones[i]; | |
2967 | 1744 |
2914 | 1745 av_log(NULL,AV_LOG_DEBUG,"Tone (%d) dump:\n", i); |
1746 av_log(NULL,AV_LOG_DEBUG," level = %f\n", t->level); | |
1747 // PRINT(" level", t->level); | |
1748 PRINT(" phase", t->phase); | |
1749 PRINT(" phase_shift", t->phase_shift); | |
1750 PRINT(" duration", t->duration); | |
1751 PRINT(" samples_im", t->samples_im); | |
1752 PRINT(" samples_re", t->samples_re); | |
1753 PRINT(" table", t->table); | |
1754 } | |
1755 | |
1756 } | |
1757 #endif | |
1758 | |
1759 | |
1760 /** | |
1761 * Init parameters from codec extradata | |
1762 */ | |
1763 static int qdm2_decode_init(AVCodecContext *avctx) | |
1764 { | |
1765 QDM2Context *s = avctx->priv_data; | |
1766 uint8_t *extradata; | |
1767 int extradata_size; | |
1768 int tmp_val, tmp, size; | |
1769 int i; | |
1770 float alpha; | |
2967 | 1771 |
2914 | 1772 /* extradata parsing |
2967 | 1773 |
2914 | 1774 Structure: |
1775 wave { | |
1776 frma (QDM2) | |
1777 QDCA | |
1778 QDCP | |
1779 } | |
2967 | 1780 |
2914 | 1781 32 size (including this field) |
1782 32 tag (=frma) | |
1783 32 type (=QDM2 or QDMC) | |
2967 | 1784 |
2914 | 1785 32 size (including this field, in bytes) |
1786 32 tag (=QDCA) // maybe mandatory parameters | |
1787 32 unknown (=1) | |
1788 32 channels (=2) | |
1789 32 samplerate (=44100) | |
1790 32 bitrate (=96000) | |
1791 32 block size (=4096) | |
1792 32 frame size (=256) (for one channel) | |
1793 32 packet size (=1300) | |
2967 | 1794 |
2914 | 1795 32 size (including this field, in bytes) |
1796 32 tag (=QDCP) // maybe some tuneable parameters | |
1797 32 float1 (=1.0) | |
1798 32 zero ? | |
1799 32 float2 (=1.0) | |
1800 32 float3 (=1.0) | |
1801 32 unknown (27) | |
1802 32 unknown (8) | |
1803 32 zero ? | |
1804 */ | |
1805 | |
1806 if (!avctx->extradata || (avctx->extradata_size < 48)) { | |
1807 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n"); | |
1808 return -1; | |
1809 } | |
1810 | |
1811 extradata = avctx->extradata; | |
1812 extradata_size = avctx->extradata_size; | |
1813 | |
1814 while (extradata_size > 7) { | |
1815 if (!memcmp(extradata, "frmaQDM", 7)) | |
1816 break; | |
1817 extradata++; | |
1818 extradata_size--; | |
1819 } | |
1820 | |
1821 if (extradata_size < 12) { | |
1822 av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n", | |
1823 extradata_size); | |
1824 return -1; | |
1825 } | |
1826 | |
1827 if (memcmp(extradata, "frmaQDM", 7)) { | |
1828 av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n"); | |
1829 return -1; | |
1830 } | |
1831 | |
1832 if (extradata[7] == 'C') { | |
1833 // s->is_qdmc = 1; | |
1834 av_log(avctx, AV_LOG_ERROR, "stream is QDMC version 1, which is not supported\n"); | |
1835 return -1; | |
1836 } | |
1837 | |
1838 extradata += 8; | |
1839 extradata_size -= 8; | |
1840 | |
4364 | 1841 size = AV_RB32(extradata); |
2914 | 1842 |
1843 if(size > extradata_size){ | |
1844 av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n", | |
1845 extradata_size, size); | |
1846 return -1; | |
1847 } | |
1848 | |
1849 extradata += 4; | |
1850 av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size); | |
4364 | 1851 if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) { |
2914 | 1852 av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n"); |
1853 return -1; | |
1854 } | |
1855 | |
1856 extradata += 8; | |
1857 | |
4364 | 1858 avctx->channels = s->nb_channels = s->channels = AV_RB32(extradata); |
2914 | 1859 extradata += 4; |
1860 | |
4364 | 1861 avctx->sample_rate = AV_RB32(extradata); |
2914 | 1862 extradata += 4; |
1863 | |
4364 | 1864 avctx->bit_rate = AV_RB32(extradata); |
2914 | 1865 extradata += 4; |
1866 | |
4364 | 1867 s->group_size = AV_RB32(extradata); |
2914 | 1868 extradata += 4; |
1869 | |
4364 | 1870 s->fft_size = AV_RB32(extradata); |
2914 | 1871 extradata += 4; |
1872 | |
4364 | 1873 s->checksum_size = AV_RB32(extradata); |
2914 | 1874 extradata += 4; |
1875 | |
1876 s->fft_order = av_log2(s->fft_size) + 1; | |
1877 s->fft_frame_size = 2 * s->fft_size; // complex has two floats | |
1878 | |
1879 // something like max decodable tones | |
1880 s->group_order = av_log2(s->group_size) + 1; | |
1881 s->frame_size = s->group_size / 16; // 16 iterations per super block | |
1882 | |
2954 | 1883 s->sub_sampling = s->fft_order - 7; |
2914 | 1884 s->frequency_range = 255 / (1 << (2 - s->sub_sampling)); |
2967 | 1885 |
2914 | 1886 switch ((s->sub_sampling * 2 + s->channels - 1)) { |
1887 case 0: tmp = 40; break; | |
1888 case 1: tmp = 48; break; | |
1889 case 2: tmp = 56; break; | |
1890 case 3: tmp = 72; break; | |
1891 case 4: tmp = 80; break; | |
1892 case 5: tmp = 100;break; | |
1893 default: tmp=s->sub_sampling; break; | |
1894 } | |
1895 tmp_val = 0; | |
1896 if ((tmp * 1000) < avctx->bit_rate) tmp_val = 1; | |
1897 if ((tmp * 1440) < avctx->bit_rate) tmp_val = 2; | |
1898 if ((tmp * 1760) < avctx->bit_rate) tmp_val = 3; | |
1899 if ((tmp * 2240) < avctx->bit_rate) tmp_val = 4; | |
1900 s->cm_table_select = tmp_val; | |
1901 | |
1902 if (s->sub_sampling == 0) | |
2954 | 1903 tmp = 7999; |
2914 | 1904 else |
1905 tmp = ((-(s->sub_sampling -1)) & 8000) + 20000; | |
1906 /* | |
2954 | 1907 0: 7999 -> 0 |
2914 | 1908 1: 20000 -> 2 |
1909 2: 28000 -> 2 | |
1910 */ | |
1911 if (tmp < 8000) | |
1912 s->coeff_per_sb_select = 0; | |
1913 else if (tmp <= 16000) | |
1914 s->coeff_per_sb_select = 1; | |
1915 else | |
1916 s->coeff_per_sb_select = 2; | |
1917 | |
2954 | 1918 // Fail on unknown fft order, if it's > 9 it can overflow s->exptab[] |
1919 if ((s->fft_order < 7) || (s->fft_order > 9)) { | |
2914 | 1920 av_log(avctx, AV_LOG_ERROR, "Unknown FFT order (%d), contact the developers!\n", s->fft_order); |
2954 | 1921 return -1; |
1922 } | |
2914 | 1923 |
1924 ff_fft_init(&s->fft_ctx, s->fft_order - 1, 1); | |
1925 | |
1926 for (i = 1; i < (1 << (s->fft_order - 2)); i++) { | |
1927 alpha = 2 * M_PI * (float)i / (float)(1 << (s->fft_order - 1)); | |
1928 s->exptab[i].re = cos(alpha); | |
1929 s->exptab[i].im = sin(alpha); | |
1930 } | |
1931 | |
1932 qdm2_init(s); | |
2967 | 1933 |
2914 | 1934 // dump_context(s); |
1935 return 0; | |
1936 } | |
1937 | |
1938 | |
1939 static int qdm2_decode_close(AVCodecContext *avctx) | |
1940 { | |
1941 QDM2Context *s = avctx->priv_data; | |
1942 | |
1943 ff_fft_end(&s->fft_ctx); | |
2967 | 1944 |
2914 | 1945 return 0; |
1946 } | |
1947 | |
1948 | |
6273 | 1949 static void qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out) |
2914 | 1950 { |
1951 int ch, i; | |
1952 const int frame_size = (q->frame_size * q->channels); | |
2967 | 1953 |
2914 | 1954 /* select input buffer */ |
1955 q->compressed_data = in; | |
1956 q->compressed_size = q->checksum_size; | |
1957 | |
1958 // dump_context(q); | |
1959 | |
1960 /* copy old block, clear new block of output samples */ | |
1961 memmove(q->output_buffer, &q->output_buffer[frame_size], frame_size * sizeof(float)); | |
1962 memset(&q->output_buffer[frame_size], 0, frame_size * sizeof(float)); | |
1963 | |
1964 /* decode block of QDM2 compressed data */ | |
1965 if (q->sub_packet == 0) { | |
1966 q->has_errors = 0; // zero it for a new super block | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1967 av_log(NULL,AV_LOG_DEBUG,"Superblock follows\n"); |
2914 | 1968 qdm2_decode_super_block(q); |
1969 } | |
1970 | |
3043
583020ce54a8
Fix a bunch of spelling/grammar mistakes in doxygen comments and output.
diego
parents:
3036
diff
changeset
|
1971 /* parse subpackets */ |
2914 | 1972 if (!q->has_errors) { |
1973 if (q->sub_packet == 2) | |
1974 qdm2_decode_fft_packets(q); | |
1975 | |
1976 qdm2_fft_tone_synthesizer(q, q->sub_packet); | |
1977 } | |
1978 | |
1979 /* sound synthesis stage 1 (FFT) */ | |
1980 for (ch = 0; ch < q->channels; ch++) { | |
1981 qdm2_calculate_fft(q, ch, q->sub_packet); | |
1982 | |
1983 if (!q->has_errors && q->sub_packet_list_C[0].packet != NULL) { | |
1984 SAMPLES_NEEDED_2("has errors, and C list is not empty") | |
1985 return; | |
1986 } | |
1987 } | |
1988 | |
1989 /* sound synthesis stage 2 (MPEG audio like synthesis filter) */ | |
1990 if (!q->has_errors && q->do_synth_filter) | |
1991 qdm2_synthesis_filter(q, q->sub_packet); | |
1992 | |
1993 q->sub_packet = (q->sub_packet + 1) % 16; | |
1994 | |
1995 /* clip and convert output float[] to 16bit signed samples */ | |
1996 for (i = 0; i < frame_size; i++) { | |
1997 int value = (int)q->output_buffer[i]; | |
1998 | |
1999 if (value > SOFTCLIP_THRESHOLD) | |
2000 value = (value > HARDCLIP_THRESHOLD) ? 32767 : softclip_table[ value - SOFTCLIP_THRESHOLD]; | |
2001 else if (value < -SOFTCLIP_THRESHOLD) | |
2002 value = (value < -HARDCLIP_THRESHOLD) ? -32767 : -softclip_table[-value - SOFTCLIP_THRESHOLD]; | |
2003 | |
2004 out[i] = value; | |
2005 } | |
2006 } | |
2007 | |
2008 | |
2009 static int qdm2_decode_frame(AVCodecContext *avctx, | |
2010 void *data, int *data_size, | |
6273 | 2011 const uint8_t *buf, int buf_size) |
2914 | 2012 { |
2013 QDM2Context *s = avctx->priv_data; | |
2014 | |
3158 | 2015 if(!buf) |
2914 | 2016 return 0; |
3158 | 2017 if(buf_size < s->checksum_size) |
2018 return -1; | |
2914 | 2019 |
2020 *data_size = s->channels * s->frame_size * sizeof(int16_t); | |
2021 | |
2022 av_log(avctx, AV_LOG_DEBUG, "decode(%d): %p[%d] -> %p[%d]\n", | |
2023 buf_size, buf, s->checksum_size, data, *data_size); | |
2024 | |
2025 qdm2_decode(s, buf, data); | |
2026 | |
2027 // reading only when next superblock found | |
2028 if (s->sub_packet == 0) { | |
2029 return s->checksum_size; | |
2030 } | |
2031 | |
2032 return 0; | |
2033 } | |
2034 | |
2035 AVCodec qdm2_decoder = | |
2036 { | |
2037 .name = "qdm2", | |
2038 .type = CODEC_TYPE_AUDIO, | |
2039 .id = CODEC_ID_QDM2, | |
2040 .priv_data_size = sizeof(QDM2Context), | |
2041 .init = qdm2_decode_init, | |
2042 .close = qdm2_decode_close, | |
2043 .decode = qdm2_decode_frame, | |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6903
diff
changeset
|
2044 .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"), |
2914 | 2045 }; |