diff options
Diffstat (limited to 'apps/codecs/libwmapro/wma.c')
-rw-r--r-- | apps/codecs/libwmapro/wma.c | 523 |
1 files changed, 523 insertions, 0 deletions
diff --git a/apps/codecs/libwmapro/wma.c b/apps/codecs/libwmapro/wma.c new file mode 100644 index 0000000000..65780459aa --- /dev/null +++ b/apps/codecs/libwmapro/wma.c | |||
@@ -0,0 +1,523 @@ | |||
1 | /* | ||
2 | * WMA compatible codec | ||
3 | * Copyright (c) 2002-2007 The FFmpeg Project | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | #include "avcodec.h" | ||
23 | #include "wma.h" | ||
24 | #include "wmadata.h" | ||
25 | |||
26 | #undef NDEBUG | ||
27 | #include <assert.h> | ||
28 | |||
29 | /* XXX: use same run/length optimization as mpeg decoders */ | ||
30 | //FIXME maybe split decode / encode or pass flag | ||
31 | static void init_coef_vlc(VLC *vlc, uint16_t **prun_table, | ||
32 | float **plevel_table, uint16_t **pint_table, | ||
33 | const CoefVLCTable *vlc_table) | ||
34 | { | ||
35 | int n = vlc_table->n; | ||
36 | const uint8_t *table_bits = vlc_table->huffbits; | ||
37 | const uint32_t *table_codes = vlc_table->huffcodes; | ||
38 | const uint16_t *levels_table = vlc_table->levels; | ||
39 | uint16_t *run_table, *level_table, *int_table; | ||
40 | float *flevel_table; | ||
41 | int i, l, j, k, level; | ||
42 | |||
43 | init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); | ||
44 | |||
45 | run_table = av_malloc(n * sizeof(uint16_t)); | ||
46 | level_table = av_malloc(n * sizeof(uint16_t)); | ||
47 | flevel_table= av_malloc(n * sizeof(*flevel_table)); | ||
48 | int_table = av_malloc(n * sizeof(uint16_t)); | ||
49 | i = 2; | ||
50 | level = 1; | ||
51 | k = 0; | ||
52 | while (i < n) { | ||
53 | int_table[k] = i; | ||
54 | l = levels_table[k++]; | ||
55 | for (j = 0; j < l; j++) { | ||
56 | run_table[i] = j; | ||
57 | level_table[i] = level; | ||
58 | flevel_table[i]= level; | ||
59 | i++; | ||
60 | } | ||
61 | level++; | ||
62 | } | ||
63 | *prun_table = run_table; | ||
64 | *plevel_table = flevel_table; | ||
65 | *pint_table = int_table; | ||
66 | av_free(level_table); | ||
67 | } | ||
68 | |||
69 | /** | ||
70 | *@brief Get the samples per frame for this stream. | ||
71 | *@param sample_rate output sample_rate | ||
72 | *@param version wma version | ||
73 | *@param decode_flags codec compression features | ||
74 | *@return log2 of the number of output samples per frame | ||
75 | */ | ||
76 | int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version, | ||
77 | unsigned int decode_flags) | ||
78 | { | ||
79 | |||
80 | int frame_len_bits; | ||
81 | |||
82 | if (sample_rate <= 16000) { | ||
83 | frame_len_bits = 9; | ||
84 | } else if (sample_rate <= 22050 || | ||
85 | (sample_rate <= 32000 && version == 1)) { | ||
86 | frame_len_bits = 10; | ||
87 | } else if (sample_rate <= 48000) { | ||
88 | frame_len_bits = 11; | ||
89 | } else if (sample_rate <= 96000) { | ||
90 | frame_len_bits = 12; | ||
91 | } else { | ||
92 | frame_len_bits = 13; | ||
93 | } | ||
94 | |||
95 | if (version == 3) { | ||
96 | int tmp = decode_flags & 0x6; | ||
97 | if (tmp == 0x2) { | ||
98 | ++frame_len_bits; | ||
99 | } else if (tmp == 0x4) { | ||
100 | --frame_len_bits; | ||
101 | } else if (tmp == 0x6) { | ||
102 | frame_len_bits -= 2; | ||
103 | } | ||
104 | } | ||
105 | |||
106 | return frame_len_bits; | ||
107 | } | ||
108 | |||
109 | int ff_wma_init(AVCodecContext *avctx, int flags2) | ||
110 | { | ||
111 | WMACodecContext *s = avctx->priv_data; | ||
112 | int i; | ||
113 | float bps1, high_freq; | ||
114 | volatile float bps; | ||
115 | int sample_rate1; | ||
116 | int coef_vlc_table; | ||
117 | |||
118 | if ( avctx->sample_rate <= 0 || avctx->sample_rate > 50000 | ||
119 | || avctx->channels <= 0 || avctx->channels > 8 | ||
120 | || avctx->bit_rate <= 0) | ||
121 | return -1; | ||
122 | |||
123 | s->sample_rate = avctx->sample_rate; | ||
124 | s->nb_channels = avctx->channels; | ||
125 | s->bit_rate = avctx->bit_rate; | ||
126 | s->block_align = avctx->block_align; | ||
127 | |||
128 | dsputil_init(&s->dsp, avctx); | ||
129 | |||
130 | if (avctx->codec->id == CODEC_ID_WMAV1) { | ||
131 | s->version = 1; | ||
132 | } else { | ||
133 | s->version = 2; | ||
134 | } | ||
135 | |||
136 | /* compute MDCT block size */ | ||
137 | s->frame_len_bits = ff_wma_get_frame_len_bits(s->sample_rate, s->version, 0); | ||
138 | |||
139 | s->frame_len = 1 << s->frame_len_bits; | ||
140 | if (s->use_variable_block_len) { | ||
141 | int nb_max, nb; | ||
142 | nb = ((flags2 >> 3) & 3) + 1; | ||
143 | if ((s->bit_rate / s->nb_channels) >= 32000) | ||
144 | nb += 2; | ||
145 | nb_max = s->frame_len_bits - BLOCK_MIN_BITS; | ||
146 | if (nb > nb_max) | ||
147 | nb = nb_max; | ||
148 | s->nb_block_sizes = nb + 1; | ||
149 | } else { | ||
150 | s->nb_block_sizes = 1; | ||
151 | } | ||
152 | |||
153 | /* init rate dependent parameters */ | ||
154 | s->use_noise_coding = 1; | ||
155 | high_freq = s->sample_rate * 0.5; | ||
156 | |||
157 | /* if version 2, then the rates are normalized */ | ||
158 | sample_rate1 = s->sample_rate; | ||
159 | if (s->version == 2) { | ||
160 | if (sample_rate1 >= 44100) { | ||
161 | sample_rate1 = 44100; | ||
162 | } else if (sample_rate1 >= 22050) { | ||
163 | sample_rate1 = 22050; | ||
164 | } else if (sample_rate1 >= 16000) { | ||
165 | sample_rate1 = 16000; | ||
166 | } else if (sample_rate1 >= 11025) { | ||
167 | sample_rate1 = 11025; | ||
168 | } else if (sample_rate1 >= 8000) { | ||
169 | sample_rate1 = 8000; | ||
170 | } | ||
171 | } | ||
172 | |||
173 | bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate); | ||
174 | s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; | ||
175 | |||
176 | /* compute high frequency value and choose if noise coding should | ||
177 | be activated */ | ||
178 | bps1 = bps; | ||
179 | if (s->nb_channels == 2) | ||
180 | bps1 = bps * 1.6; | ||
181 | if (sample_rate1 == 44100) { | ||
182 | if (bps1 >= 0.61) { | ||
183 | s->use_noise_coding = 0; | ||
184 | } else { | ||
185 | high_freq = high_freq * 0.4; | ||
186 | } | ||
187 | } else if (sample_rate1 == 22050) { | ||
188 | if (bps1 >= 1.16) { | ||
189 | s->use_noise_coding = 0; | ||
190 | } else if (bps1 >= 0.72) { | ||
191 | high_freq = high_freq * 0.7; | ||
192 | } else { | ||
193 | high_freq = high_freq * 0.6; | ||
194 | } | ||
195 | } else if (sample_rate1 == 16000) { | ||
196 | if (bps > 0.5) { | ||
197 | high_freq = high_freq * 0.5; | ||
198 | } else { | ||
199 | high_freq = high_freq * 0.3; | ||
200 | } | ||
201 | } else if (sample_rate1 == 11025) { | ||
202 | high_freq = high_freq * 0.7; | ||
203 | } else if (sample_rate1 == 8000) { | ||
204 | if (bps <= 0.625) { | ||
205 | high_freq = high_freq * 0.5; | ||
206 | } else if (bps > 0.75) { | ||
207 | s->use_noise_coding = 0; | ||
208 | } else { | ||
209 | high_freq = high_freq * 0.65; | ||
210 | } | ||
211 | } else { | ||
212 | if (bps >= 0.8) { | ||
213 | high_freq = high_freq * 0.75; | ||
214 | } else if (bps >= 0.6) { | ||
215 | high_freq = high_freq * 0.6; | ||
216 | } else { | ||
217 | high_freq = high_freq * 0.5; | ||
218 | } | ||
219 | } | ||
220 | dprintf(s->avctx, "flags2=0x%x\n", flags2); | ||
221 | dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", | ||
222 | s->version, s->nb_channels, s->sample_rate, s->bit_rate, | ||
223 | s->block_align); | ||
224 | dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n", | ||
225 | bps, bps1, high_freq, s->byte_offset_bits); | ||
226 | dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", | ||
227 | s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); | ||
228 | |||
229 | /* compute the scale factor band sizes for each MDCT block size */ | ||
230 | { | ||
231 | int a, b, pos, lpos, k, block_len, i, j, n; | ||
232 | const uint8_t *table; | ||
233 | |||
234 | if (s->version == 1) { | ||
235 | s->coefs_start = 3; | ||
236 | } else { | ||
237 | s->coefs_start = 0; | ||
238 | } | ||
239 | for (k = 0; k < s->nb_block_sizes; k++) { | ||
240 | block_len = s->frame_len >> k; | ||
241 | |||
242 | if (s->version == 1) { | ||
243 | lpos = 0; | ||
244 | for (i = 0; i < 25; i++) { | ||
245 | a = ff_wma_critical_freqs[i]; | ||
246 | b = s->sample_rate; | ||
247 | pos = ((block_len * 2 * a) + (b >> 1)) / b; | ||
248 | if (pos > block_len) | ||
249 | pos = block_len; | ||
250 | s->exponent_bands[0][i] = pos - lpos; | ||
251 | if (pos >= block_len) { | ||
252 | i++; | ||
253 | break; | ||
254 | } | ||
255 | lpos = pos; | ||
256 | } | ||
257 | s->exponent_sizes[0] = i; | ||
258 | } else { | ||
259 | /* hardcoded tables */ | ||
260 | table = NULL; | ||
261 | a = s->frame_len_bits - BLOCK_MIN_BITS - k; | ||
262 | if (a < 3) { | ||
263 | if (s->sample_rate >= 44100) { | ||
264 | table = exponent_band_44100[a]; | ||
265 | } else if (s->sample_rate >= 32000) { | ||
266 | table = exponent_band_32000[a]; | ||
267 | } else if (s->sample_rate >= 22050) { | ||
268 | table = exponent_band_22050[a]; | ||
269 | } | ||
270 | } | ||
271 | if (table) { | ||
272 | n = *table++; | ||
273 | for (i = 0; i < n; i++) | ||
274 | s->exponent_bands[k][i] = table[i]; | ||
275 | s->exponent_sizes[k] = n; | ||
276 | } else { | ||
277 | j = 0; | ||
278 | lpos = 0; | ||
279 | for (i = 0; i < 25; i++) { | ||
280 | a = ff_wma_critical_freqs[i]; | ||
281 | b = s->sample_rate; | ||
282 | pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); | ||
283 | pos <<= 2; | ||
284 | if (pos > block_len) | ||
285 | pos = block_len; | ||
286 | if (pos > lpos) | ||
287 | s->exponent_bands[k][j++] = pos - lpos; | ||
288 | if (pos >= block_len) | ||
289 | break; | ||
290 | lpos = pos; | ||
291 | } | ||
292 | s->exponent_sizes[k] = j; | ||
293 | } | ||
294 | } | ||
295 | |||
296 | /* max number of coefs */ | ||
297 | s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; | ||
298 | /* high freq computation */ | ||
299 | s->high_band_start[k] = (int)((block_len * 2 * high_freq) / | ||
300 | s->sample_rate + 0.5); | ||
301 | n = s->exponent_sizes[k]; | ||
302 | j = 0; | ||
303 | pos = 0; | ||
304 | for (i = 0; i < n; i++) { | ||
305 | int start, end; | ||
306 | start = pos; | ||
307 | pos += s->exponent_bands[k][i]; | ||
308 | end = pos; | ||
309 | if (start < s->high_band_start[k]) | ||
310 | start = s->high_band_start[k]; | ||
311 | if (end > s->coefs_end[k]) | ||
312 | end = s->coefs_end[k]; | ||
313 | if (end > start) | ||
314 | s->exponent_high_bands[k][j++] = end - start; | ||
315 | } | ||
316 | s->exponent_high_sizes[k] = j; | ||
317 | #if 0 | ||
318 | tprintf(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ", | ||
319 | s->frame_len >> k, | ||
320 | s->coefs_end[k], | ||
321 | s->high_band_start[k], | ||
322 | s->exponent_high_sizes[k]); | ||
323 | for (j = 0; j < s->exponent_high_sizes[k]; j++) | ||
324 | tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]); | ||
325 | tprintf(s->avctx, "\n"); | ||
326 | #endif | ||
327 | } | ||
328 | } | ||
329 | |||
330 | #ifdef TRACE | ||
331 | { | ||
332 | int i, j; | ||
333 | for (i = 0; i < s->nb_block_sizes; i++) { | ||
334 | tprintf(s->avctx, "%5d: n=%2d:", | ||
335 | s->frame_len >> i, | ||
336 | s->exponent_sizes[i]); | ||
337 | for (j = 0; j < s->exponent_sizes[i]; j++) | ||
338 | tprintf(s->avctx, " %d", s->exponent_bands[i][j]); | ||
339 | tprintf(s->avctx, "\n"); | ||
340 | } | ||
341 | } | ||
342 | #endif | ||
343 | |||
344 | /* init MDCT windows : simple sinus window */ | ||
345 | for (i = 0; i < s->nb_block_sizes; i++) { | ||
346 | ff_init_ff_sine_windows(s->frame_len_bits - i); | ||
347 | s->windows[i] = ff_sine_windows[s->frame_len_bits - i]; | ||
348 | } | ||
349 | |||
350 | s->reset_block_lengths = 1; | ||
351 | |||
352 | if (s->use_noise_coding) { | ||
353 | |||
354 | /* init the noise generator */ | ||
355 | if (s->use_exp_vlc) { | ||
356 | s->noise_mult = 0.02; | ||
357 | } else { | ||
358 | s->noise_mult = 0.04; | ||
359 | } | ||
360 | |||
361 | #ifdef TRACE | ||
362 | for (i = 0; i < NOISE_TAB_SIZE; i++) | ||
363 | s->noise_table[i] = 1.0 * s->noise_mult; | ||
364 | #else | ||
365 | { | ||
366 | unsigned int seed; | ||
367 | float norm; | ||
368 | seed = 1; | ||
369 | norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; | ||
370 | for (i = 0; i < NOISE_TAB_SIZE; i++) { | ||
371 | seed = seed * 314159 + 1; | ||
372 | s->noise_table[i] = (float)((int)seed) * norm; | ||
373 | } | ||
374 | } | ||
375 | #endif | ||
376 | } | ||
377 | |||
378 | /* choose the VLC tables for the coefficients */ | ||
379 | coef_vlc_table = 2; | ||
380 | if (s->sample_rate >= 32000) { | ||
381 | if (bps1 < 0.72) { | ||
382 | coef_vlc_table = 0; | ||
383 | } else if (bps1 < 1.16) { | ||
384 | coef_vlc_table = 1; | ||
385 | } | ||
386 | } | ||
387 | s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; | ||
388 | s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; | ||
389 | init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0], | ||
390 | s->coef_vlcs[0]); | ||
391 | init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1], | ||
392 | s->coef_vlcs[1]); | ||
393 | |||
394 | return 0; | ||
395 | } | ||
396 | |||
397 | int ff_wma_total_gain_to_bits(int total_gain) | ||
398 | { | ||
399 | if (total_gain < 15) return 13; | ||
400 | else if (total_gain < 32) return 12; | ||
401 | else if (total_gain < 40) return 11; | ||
402 | else if (total_gain < 45) return 10; | ||
403 | else return 9; | ||
404 | } | ||
405 | |||
406 | int ff_wma_end(AVCodecContext *avctx) | ||
407 | { | ||
408 | WMACodecContext *s = avctx->priv_data; | ||
409 | int i; | ||
410 | |||
411 | for (i = 0; i < s->nb_block_sizes; i++) | ||
412 | ff_mdct_end(&s->mdct_ctx[i]); | ||
413 | |||
414 | if (s->use_exp_vlc) { | ||
415 | free_vlc(&s->exp_vlc); | ||
416 | } | ||
417 | if (s->use_noise_coding) { | ||
418 | free_vlc(&s->hgain_vlc); | ||
419 | } | ||
420 | for (i = 0; i < 2; i++) { | ||
421 | free_vlc(&s->coef_vlc[i]); | ||
422 | av_free(s->run_table[i]); | ||
423 | av_free(s->level_table[i]); | ||
424 | av_free(s->int_table[i]); | ||
425 | } | ||
426 | |||
427 | return 0; | ||
428 | } | ||
429 | |||
430 | /** | ||
431 | * Decode an uncompressed coefficient. | ||
432 | * @param s codec context | ||
433 | * @return the decoded coefficient | ||
434 | */ | ||
435 | unsigned int ff_wma_get_large_val(GetBitContext* gb) | ||
436 | { | ||
437 | /** consumes up to 34 bits */ | ||
438 | int n_bits = 8; | ||
439 | /** decode length */ | ||
440 | if (get_bits1(gb)) { | ||
441 | n_bits += 8; | ||
442 | if (get_bits1(gb)) { | ||
443 | n_bits += 8; | ||
444 | if (get_bits1(gb)) { | ||
445 | n_bits += 7; | ||
446 | } | ||
447 | } | ||
448 | } | ||
449 | return get_bits_long(gb, n_bits); | ||
450 | } | ||
451 | |||
452 | /** | ||
453 | * Decode run level compressed coefficients. | ||
454 | * @param avctx codec context | ||
455 | * @param gb bitstream reader context | ||
456 | * @param vlc vlc table for get_vlc2 | ||
457 | * @param level_table level codes | ||
458 | * @param run_table run codes | ||
459 | * @param version 0 for wma1,2 1 for wmapro | ||
460 | * @param ptr output buffer | ||
461 | * @param offset offset in the output buffer | ||
462 | * @param num_coefs number of input coefficents | ||
463 | * @param block_len input buffer length (2^n) | ||
464 | * @param frame_len_bits number of bits for escaped run codes | ||
465 | * @param coef_nb_bits number of bits for escaped level codes | ||
466 | * @return 0 on success, -1 otherwise | ||
467 | */ | ||
468 | int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb, | ||
469 | VLC *vlc, | ||
470 | const float *level_table, const uint16_t *run_table, | ||
471 | int version, WMACoef *ptr, int offset, | ||
472 | int num_coefs, int block_len, int frame_len_bits, | ||
473 | int coef_nb_bits) | ||
474 | { | ||
475 | int code, level, sign; | ||
476 | const uint32_t *ilvl = (const uint32_t*)level_table; | ||
477 | uint32_t *iptr = (uint32_t*)ptr; | ||
478 | const unsigned int coef_mask = block_len - 1; | ||
479 | for (; offset < num_coefs; offset++) { | ||
480 | code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX); | ||
481 | if (code > 1) { | ||
482 | /** normal code */ | ||
483 | offset += run_table[code]; | ||
484 | sign = get_bits1(gb) - 1; | ||
485 | iptr[offset & coef_mask] = ilvl[code] ^ sign<<31; | ||
486 | } else if (code == 1) { | ||
487 | /** EOB */ | ||
488 | break; | ||
489 | } else { | ||
490 | /** escape */ | ||
491 | if (!version) { | ||
492 | level = get_bits(gb, coef_nb_bits); | ||
493 | /** NOTE: this is rather suboptimal. reading | ||
494 | block_len_bits would be better */ | ||
495 | offset += get_bits(gb, frame_len_bits); | ||
496 | } else { | ||
497 | level = ff_wma_get_large_val(gb); | ||
498 | /** escape decode */ | ||
499 | if (get_bits1(gb)) { | ||
500 | if (get_bits1(gb)) { | ||
501 | if (get_bits1(gb)) { | ||
502 | av_log(avctx,AV_LOG_ERROR, | ||
503 | "broken escape sequence\n"); | ||
504 | return -1; | ||
505 | } else | ||
506 | offset += get_bits(gb, frame_len_bits) + 4; | ||
507 | } else | ||
508 | offset += get_bits(gb, 2) + 1; | ||
509 | } | ||
510 | } | ||
511 | sign = get_bits1(gb) - 1; | ||
512 | ptr[offset & coef_mask] = (level^sign) - sign; | ||
513 | } | ||
514 | } | ||
515 | /** NOTE: EOB can be omitted */ | ||
516 | if (offset > num_coefs) { | ||
517 | av_log(avctx, AV_LOG_ERROR, "overflow in spectral RLE, ignoring\n"); | ||
518 | return -1; | ||
519 | } | ||
520 | |||
521 | return 0; | ||
522 | } | ||
523 | |||