Mercurial > libavcodec.hg

comparison wmadec.c @ 3176:babf844e1308 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Init simplification and 2% faster wma_decode_block on amd64 with tables use instead of pow().
author banan
date Wed, 08 Mar 2006 09:26:57 +0000
parents ab01ee59324f
children 10cda832bd0f
comparison
equal deleted inserted replaced
3175:c20c181e0eca 3176:babf844e1308
128 /* lsp_to_curve tables */ 128 /* lsp_to_curve tables */
129 float lsp_cos_table[BLOCK_MAX_SIZE]; 129 float lsp_cos_table[BLOCK_MAX_SIZE];
130 float lsp_pow_e_table[256]; 130 float lsp_pow_e_table[256];
131 float lsp_pow_m_table1[(1 << LSP_POW_BITS)]; 131 float lsp_pow_m_table1[(1 << LSP_POW_BITS)];
132 float lsp_pow_m_table2[(1 << LSP_POW_BITS)]; 132 float lsp_pow_m_table2[(1 << LSP_POW_BITS)];
133 /* pow tables */
134 float pow_005_10[121];
135 float pow_00625_10[121];
133 136
134 #ifdef TRACE 137 #ifdef TRACE
135 int frame_count; 138 int frame_count;
136 #endif 139 #endif
137 } WMADecodeContext; 140 } WMADecodeContext;
216 { 219 {
217 WMADecodeContext *s = avctx->priv_data; 220 WMADecodeContext *s = avctx->priv_data;
218 int i, flags1, flags2; 221 int i, flags1, flags2;
219 float *window; 222 float *window;
220 uint8_t *extradata; 223 uint8_t *extradata;
221 float bps1, high_freq; 224 float bps, bps1;
222 volatile float bps; 225 volatile float high_freq_factor;
223 int sample_rate1; 226 int sample_rate1;
224 int coef_vlc_table; 227 int coef_vlc_table;
225 228
226 s->sample_rate = avctx->sample_rate; 229 s->sample_rate = avctx->sample_rate;
227 s->nb_channels = avctx->channels; 230 s->nb_channels = avctx->channels;
273 s->nb_block_sizes = 1; 276 s->nb_block_sizes = 1;
274 } 277 }
275 278
276 /* init rate dependant parameters */ 279 /* init rate dependant parameters */
277 s->use_noise_coding = 1; 280 s->use_noise_coding = 1;
278 high_freq = s->sample_rate * 0.5;
279 281
280 /* if version 2, then the rates are normalized */ 282 /* if version 2, then the rates are normalized */
281 sample_rate1 = s->sample_rate; 283 sample_rate1 = s->sample_rate;
282 if (s->version == 2) { 284 if (s->version == 2) {
283 if (sample_rate1 >= 44100) 285 if (sample_rate1 >= 44100)
302 bps1 = bps * 1.6; 304 bps1 = bps * 1.6;
303 if (sample_rate1 == 44100) { 305 if (sample_rate1 == 44100) {
304 if (bps1 >= 0.61) 306 if (bps1 >= 0.61)
305 s->use_noise_coding = 0; 307 s->use_noise_coding = 0;
306 else 308 else
307 high_freq = high_freq * 0.4; 309 high_freq_factor = 0.4;
308 } else if (sample_rate1 == 22050) { 310 } else if (sample_rate1 == 22050) {
309 if (bps1 >= 1.16) 311 if (bps1 >= 1.16)
310 s->use_noise_coding = 0; 312 s->use_noise_coding = 0;
311 else if (bps1 >= 0.72) 313 else if (bps1 >= 0.72)
312 high_freq = high_freq * 0.7; 314 high_freq_factor = 0.7;
313 else 315 else
314 high_freq = high_freq * 0.6; 316 high_freq_factor = 0.6;
315 } else if (sample_rate1 == 16000) { 317 } else if (sample_rate1 == 16000) {
316 if (bps > 0.5) 318 if (bps > 0.5)
317 high_freq = high_freq * 0.5; 319 high_freq_factor = 0.5;
318 else 320 else
319 high_freq = high_freq * 0.3; 321 high_freq_factor = 0.3;
320 } else if (sample_rate1 == 11025) { 322 } else if (sample_rate1 == 11025) {
321 high_freq = high_freq * 0.7; 323 high_freq_factor = 0.7;
322 } else if (sample_rate1 == 8000) { 324 } else if (sample_rate1 == 8000) {
323 if (bps <= 0.625) { 325 if (bps <= 0.625) {
324 high_freq = high_freq * 0.5; 326 high_freq_factor = 0.5;
325 } else if (bps > 0.75) { 327 } else if (bps > 0.75) {
326 s->use_noise_coding = 0; 328 s->use_noise_coding = 0;
327 } else { 329 } else {
328 high_freq = high_freq * 0.65; 330 high_freq_factor = 0.65;
329 } 331 }
330 } else { 332 } else {
331 if (bps >= 0.8) { 333 if (bps >= 0.8) {
332 high_freq = high_freq * 0.75; 334 high_freq_factor = 0.75;
333 } else if (bps >= 0.6) { 335 } else if (bps >= 0.6) {
334 high_freq = high_freq * 0.6; 336 high_freq_factor = 0.6;
335 } else { 337 } else {
336 high_freq = high_freq * 0.5; 338 high_freq_factor = 0.5;
337 } 339 }
338 } 340 }
339 dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2); 341 dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);
340 dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", 342 dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
341 s->version, s->nb_channels, s->sample_rate, s->bit_rate, 343 s->version, s->nb_channels, s->sample_rate, s->bit_rate,
342 s->block_align); 344 s->block_align);
343 dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n", 345 dprintf("bps=%f bps1=%f bitoffset=%d\n",
344 bps, bps1, high_freq, s->byte_offset_bits); 346 bps, bps1, s->byte_offset_bits);
345 dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n", 347 dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
346 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); 348 s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
347 349
348 /* compute the scale factor band sizes for each MDCT block size */ 350 /* compute the scale factor band sizes for each MDCT block size */
349 { 351 {
412 } 414 }
413 415
414 /* max number of coefs */ 416 /* max number of coefs */
415 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; 417 s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
416 /* high freq computation */ 418 /* high freq computation */
417 s->high_band_start[k] = (int)((block_len * 2 * high_freq) / 419 s->high_band_start[k] = (int)((block_len * high_freq_factor) + 0.5);
418 s->sample_rate + 0.5); 420
419 n = s->exponent_sizes[k]; 421 n = s->exponent_sizes[k];
420 j = 0; 422 j = 0;
421 pos = 0; 423 pos = 0;
422 for(i=0;i<n;i++) { 424 for(i=0;i<n;i++) {
423 int start, end; 425 int start, end;
525 527
526 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], 528 init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
527 &coef_vlcs[coef_vlc_table * 2]); 529 &coef_vlcs[coef_vlc_table * 2]);
528 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], 530 init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
529 &coef_vlcs[coef_vlc_table * 2 + 1]); 531 &coef_vlcs[coef_vlc_table * 2 + 1]);
532
533 /* init pow tables */
534 for (i=0 ; i<121 ; i++) {
535 s->pow_005_10[i] = pow(10, i * 0.05);
536 s->pow_00625_10[i] = pow(10, i * (1.0 / 16.0));
537 }
538
530 return 0; 539 return 0;
531 } 540 }
532 541
533 /* interpolate values for a bigger or smaller block. The block must 542 /* interpolate values for a bigger or smaller block. The block must
534 have multiple sizes */ 543 have multiple sizes */
676 q = s->exponents[ch]; 685 q = s->exponents[ch];
677 q_end = q + s->block_len; 686 q_end = q + s->block_len;
678 max_scale = 0; 687 max_scale = 0;
679 if (s->version == 1) { 688 if (s->version == 1) {
680 last_exp = get_bits(&s->gb, 5) + 10; 689 last_exp = get_bits(&s->gb, 5) + 10;
681 /* XXX: use a table */ 690 v = s->pow_00625_10[last_exp];
682 v = pow(10, last_exp * (1.0 / 16.0));
683 max_scale = v; 691 max_scale = v;
684 n = *ptr++; 692 n = *ptr++;
685 do { 693 do {
686 *q++ = v; 694 *q++ = v;
687 } while (--n); 695 } while (--n);
691 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX); 699 code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
692 if (code < 0) 700 if (code < 0)
693 return -1; 701 return -1;
694 /* NOTE: this offset is the same as MPEG4 AAC ! */ 702 /* NOTE: this offset is the same as MPEG4 AAC ! */
695 last_exp += code - 60; 703 last_exp += code - 60;
696 /* XXX: use a table */ 704 v = s->pow_00625_10[last_exp];
697 v = pow(10, last_exp * (1.0 / 16.0));
698 if (v > max_scale) 705 if (v > max_scale)
699 max_scale = v; 706 max_scale = v;
700 n = *ptr++; 707 n = *ptr++;
701 do { 708 do {
702 *q++ = v; 709 *q++ = v;
937 int i, j, n, n1, last_high_band; 944 int i, j, n, n1, last_high_band;
938 float exp_power[HIGH_BAND_MAX_SIZE]; 945 float exp_power[HIGH_BAND_MAX_SIZE];
939 946
940 coefs1 = s->coefs1[ch]; 947 coefs1 = s->coefs1[ch];
941 exponents = s->exponents[ch]; 948 exponents = s->exponents[ch];
942 mult = pow(10, total_gain * 0.05) / s->max_exponent[ch]; 949 mult = s->pow_005_10[total_gain] / s->max_exponent[ch];
943 mult *= mdct_norm; 950 mult *= mdct_norm;
944 coefs = s->coefs[ch]; 951 coefs = s->coefs[ch];
945 if (s->use_noise_coding) { 952 if (s->use_noise_coding) {
946 mult1 = mult; 953 mult1 = mult;
947 /* very low freqs : noise */ 954 /* very low freqs : noise */
984 s->block_len_bits][j]; 991 s->block_len_bits][j];
985 } 992 }
986 if (j >= 0 && s->high_band_coded[ch][j]) { 993 if (j >= 0 && s->high_band_coded[ch][j]) {
987 /* use noise with specified power */ 994 /* use noise with specified power */
988 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]); 995 mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
989 /* XXX: use a table */ 996 mult1 = mult1 * s->pow_005_10[s->high_band_values[ch][j]];
990 mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05);
991 mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult); 997 mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
992 mult1 *= mdct_norm; 998 mult1 *= mdct_norm;
993 for(i = 0;i < n; i++) { 999 for(i = 0;i < n; i++) {
994 noise = s->noise_table[s->noise_index]; 1000 noise = s->noise_table[s->noise_index];
995 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); 1001 s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);