1 /* 2 * lame utility library source file 3 * 4 * Copyright (c) 1999 Albert L Faber 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Library General Public 8 * License as published by the Free Software Foundation; either 9 * version 2 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Library General Public License for more details. 15 * 16 * You should have received a copy of the GNU Library General Public 17 * License along with this library; if not, write to the 18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 19 * Boston, MA 02111-1307, USA. 20 */ 21 22 /* $Id: util.c,v 1.67 2001/03/20 00:42:56 markt Exp $ */ 23 24 #ifdef HAVE_CONFIG_H 25 # include <config.h> 26 #endif 27 28 #define PRECOMPUTE 29 30 #include "util.h" 31 #include <ctype.h> 32 #include <assert.h> 33 #include <stdarg.h> 34 35 #if defined(__FreeBSD__) && !defined(__alpha__) 36 # include <machine/floatingpoint.h> 37 #endif 38 39 #ifdef WITH_DMALLOC 40 #include <dmalloc.h> 41 #endif 42 43 /*********************************************************************** 44 * 45 * Global Function Definitions 46 * 47 ***********************************************************************/ 48 /*empty and close mallocs in gfc */ 49 50 void freegfc ( lame_internal_flags* const gfc ) /* bit stream structure */ 51 { 52 int i; 53 54 #ifdef KLEMM_44 55 if (gfc->resample_in != NULL) { 56 resample_close(gfc->resample_in); 57 gfc->resample_in = NULL; 58 } 59 free(gfc->mfbuf[0]); 60 free(gfc->mfbuf[1]); 61 #endif 62 63 for ( i = 0 ; i <= 2*BPC; i++ ) 64 if ( gfc->blackfilt[i] != NULL ) { 65 free ( gfc->blackfilt[i] ); 66 gfc->blackfilt[i] = NULL; 67 } 68 if ( gfc->inbuf_old[0] ) { 69 free ( gfc->inbuf_old[0] ); 70 gfc->inbuf_old[0] = NULL; 71 } 72 if ( gfc->inbuf_old[1] ) { 73 free ( gfc->inbuf_old[1] ); 74 gfc->inbuf_old[1] = NULL; 75 } 76 77 if ( gfc->bs.buf != NULL ) { 78 free ( gfc->bs.buf ); 79 gfc->bs.buf = NULL; 80 } 81 82 if ( gfc->VBR_seek_table.bag ) { 83 free ( gfc->VBR_seek_table.bag ); 84 } 85 if ( gfc->ATH ) { 86 free ( gfc->ATH ); 87 } 88 free ( gfc ); 89 } 90 91 FLOAT8 ATHformula_old(FLOAT8 f) 92 { 93 FLOAT8 ath; 94 f /= 1000; // convert to khz 95 f = Max(0.01, f); 96 f = Min(18.0, f); 97 98 /* from Painter & Spanias, 1997 */ 99 /* minimum: (i=77) 3.3kHz = -5db */ 100 ath = 3.640 * pow(f,-0.8) 101 - 6.500 * exp(-0.6*pow(f-3.3,2.0)) 102 + 0.001 * pow(f,4.0); 103 return ath; 104 } 105 106 FLOAT8 ATHformula_GB(FLOAT8 f) 107 { 108 FLOAT8 ath; 109 f /= 1000; // convert to khz 110 f = Max(0.01, f); 111 f = Min(18.0, f); 112 113 /* from Painter & Spanias, 1997 */ 114 /* modified by Gabriel Bouvigne to better fit to the reality */ 115 ath = 3.640 * pow(f,-0.8) 116 - 6.800 * exp(-0.6*pow(f-3.4,2.0)) 117 + 6.000 * exp(-0.15*pow(f-8.7,2.0)) 118 + 0.6* 0.001 * pow(f,4.0); 119 return ath; 120 } 121 122 FLOAT8 ATHformula_GBtweak(FLOAT8 f) 123 { 124 FLOAT8 ath; 125 f /= 1000; // convert to khz 126 f = Max(0.01, f); 127 f = Min(18.0, f); 128 129 /* from Painter & Spanias, 1997 */ 130 /* modified by Gabriel Bouvigne to better fit to the reality */ 131 ath = 3.640 * pow(f,-0.8) 132 - 6.800 * exp(-0.6*pow(f-3.4,2.0)) 133 + 6.000 * exp(-0.15*pow(f-8.7,2.0)) 134 + 0.57* 0.001 * pow(f,4.0) //0.57 to maximize HF importance 135 + 6; //std --athlower -6 for 136 return ath; 137 } 138 139 140 /* 141 * Klemm 1994 and 1997. Experimental data. Sorry, data looks a little bit 142 * dodderly. Data below 30 Hz is extrapolated from other material, above 18 143 * kHz the ATH is limited due to the original purpose (too much noise at 144 * ATH is not good even if it's theoretically inaudible). 145 */ 146 147 FLOAT8 ATHformula_Frank( FLOAT8 freq ) 148 { 149 /* 150 * one value per 100 cent = 1 151 * semitone = 1/4 152 * third = 1/12 153 * octave = 1/40 decade 154 * rest is linear interpolated, values are currently in decibel rel. 20 �Pa 155 */ 156 static FLOAT tab [] = { 157 /* 10.0 */ 96.69, 96.69, 96.26, 95.12, 158 /* 12.6 */ 93.53, 91.13, 88.82, 86.76, 159 /* 15.8 */ 84.69, 82.43, 79.97, 77.48, 160 /* 20.0 */ 74.92, 72.39, 70.00, 67.62, 161 /* 25.1 */ 65.29, 63.02, 60.84, 59.00, 162 /* 31.6 */ 57.17, 55.34, 53.51, 51.67, 163 /* 39.8 */ 50.04, 48.12, 46.38, 44.66, 164 /* 50.1 */ 43.10, 41.73, 40.50, 39.22, 165 /* 63.1 */ 37.23, 35.77, 34.51, 32.81, 166 /* 79.4 */ 31.32, 30.36, 29.02, 27.60, 167 /* 100.0 */ 26.58, 25.91, 24.41, 23.01, 168 /* 125.9 */ 22.12, 21.25, 20.18, 19.00, 169 /* 158.5 */ 17.70, 16.82, 15.94, 15.12, 170 /* 199.5 */ 14.30, 13.41, 12.60, 11.98, 171 /* 251.2 */ 11.36, 10.57, 9.98, 9.43, 172 /* 316.2 */ 8.87, 8.46, 7.44, 7.12, 173 /* 398.1 */ 6.93, 6.68, 6.37, 6.06, 174 /* 501.2 */ 5.80, 5.55, 5.29, 5.02, 175 /* 631.0 */ 4.75, 4.48, 4.22, 3.98, 176 /* 794.3 */ 3.75, 3.51, 3.27, 3.22, 177 /* 1000.0 */ 3.12, 3.01, 2.91, 2.68, 178 /* 1258.9 */ 2.46, 2.15, 1.82, 1.46, 179 /* 1584.9 */ 1.07, 0.61, 0.13, -0.35, 180 /* 1995.3 */ -0.96, -1.56, -1.79, -2.35, 181 /* 2511.9 */ -2.95, -3.50, -4.01, -4.21, 182 /* 3162.3 */ -4.46, -4.99, -5.32, -5.35, 183 /* 3981.1 */ -5.13, -4.76, -4.31, -3.13, 184 /* 5011.9 */ -1.79, 0.08, 2.03, 4.03, 185 /* 6309.6 */ 5.80, 7.36, 8.81, 10.22, 186 /* 7943.3 */ 11.54, 12.51, 13.48, 14.21, 187 /* 10000.0 */ 14.79, 13.99, 12.85, 11.93, 188 /* 12589.3 */ 12.87, 15.19, 19.14, 23.69, 189 /* 15848.9 */ 33.52, 48.65, 59.42, 61.77, 190 /* 19952.6 */ 63.85, 66.04, 68.33, 70.09, 191 /* 25118.9 */ 70.66, 71.27, 71.91, 72.60, 192 }; 193 FLOAT8 freq_log; 194 unsigned index; 195 196 if ( freq < 10. ) freq = 10.; 197 if ( freq > 29853. ) freq = 29853.; 198 199 freq_log = 40. * log10 (0.1 * freq); /* 4 steps per third, starting at 10 Hz */ 200 index = (unsigned) freq_log; 201 assert ( index < sizeof(tab)/sizeof(*tab) ); 202 return tab [index] * (1 + index - freq_log) + tab [index+1] * (freq_log - index); 203 } 204 205 FLOAT8 ATHformula(FLOAT8 f,lame_global_flags *gfp) 206 { 207 switch(gfp->ATHtype) 208 { 209 case 0: 210 return ATHformula_old(f); 211 case 1: 212 return ATHformula_Frank(f); 213 case 2: 214 return ATHformula_GB(f); 215 case 3: 216 return ATHformula_GBtweak(f); 217 } 218 219 return ATHformula_Frank(f); 220 } 221 222 /* see for example "Zwicker: Psychoakustik, 1982; ISBN 3-540-11401-7 */ 223 FLOAT8 freq2bark(FLOAT8 freq) 224 { 225 /* input: freq in hz output: barks */ 226 if (freq<0) freq=0; 227 freq = freq * 0.001; 228 return 13.0*atan(.76*freq) + 3.5*atan(freq*freq/(7.5*7.5)); 229 } 230 231 /* see for example "Zwicker: Psychoakustik, 1982; ISBN 3-540-11401-7 */ 232 FLOAT8 freq2cbw(FLOAT8 freq) 233 { 234 /* input: freq in hz output: critical band width */ 235 freq = freq * 0.001; 236 return 25+75*pow(1+1.4*(freq*freq),0.69); 237 } 238 239 240 241 242 243 244 /*********************************************************************** 245 * compute bitsperframe and mean_bits for a layer III frame 246 **********************************************************************/ 247 void getframebits(lame_global_flags *gfp, int *bitsPerFrame, int *mean_bits) 248 { 249 lame_internal_flags *gfc=gfp->internal_flags; 250 int whole_SpF; /* integral number of Slots per Frame without padding */ 251 int bit_rate; 252 253 /* get bitrate in kbps [?] */ 254 if (gfc->bitrate_index) 255 bit_rate = bitrate_table[gfp->version][gfc->bitrate_index]; 256 else 257 bit_rate = gfp->brate; 258 assert ( bit_rate <= 550 ); 259 260 // bytes_per_frame = bitrate * 1000 / ( gfp->out_samplerate / (gfp->version == 1 ? 1152 : 576 )) / 8; 261 // bytes_per_frame = bitrate * 1000 / gfp->out_samplerate * (gfp->version == 1 ? 1152 : 576 ) / 8; 262 // bytes_per_frame = bitrate * ( gfp->version == 1 ? 1152/8*1000 : 576/8*1000 ) / gfp->out_samplerate; 263 264 whole_SpF = (gfp->version+1)*72000*bit_rate / gfp->out_samplerate; 265 266 // There must be somewhere code toggling gfc->padding on and off 267 268 /* main encoding routine toggles padding on and off */ 269 /* one Layer3 Slot consists of 8 bits */ 270 *bitsPerFrame = 8 * (whole_SpF + gfc->padding); 271 272 // sideinfo_len 273 *mean_bits = (*bitsPerFrame - 8*gfc->sideinfo_len) / gfc->mode_gr; 274 } 275 276 277 278 279 #define ABS(A) (((A)>0) ? (A) : -(A)) 280 281 int FindNearestBitrate( 282 int bRate, /* legal rates from 32 to 448 */ 283 int version, /* MPEG-1 or MPEG-2 LSF */ 284 int samplerate) /* convert bitrate in kbps to index */ 285 { 286 int bitrate = 0; 287 int i; 288 289 for ( i = 1; i <= 14; i++ ) 290 if ( ABS (bitrate_table[version][i] - bRate) < ABS (bitrate - bRate) ) 291 bitrate = bitrate_table [version] [i]; 292 293 return bitrate; 294 } 295 296 297 /* map frequency to a valid MP3 sample frequency 298 * 299 * Robert.Hegemann@gmx.de 2000-07-01 300 */ 301 int map2MP3Frequency(int freq) 302 { 303 if (freq <= 8000) return 8000; 304 if (freq <= 11025) return 11025; 305 if (freq <= 12000) return 12000; 306 if (freq <= 16000) return 16000; 307 if (freq <= 22050) return 22050; 308 if (freq <= 24000) return 24000; 309 if (freq <= 32000) return 32000; 310 if (freq <= 44100) return 44100; 311 312 return 48000; 313 } 314 315 int BitrateIndex( 316 int bRate, /* legal rates from 32 to 448 kbps */ 317 int version, /* MPEG-1 or MPEG-2/2.5 LSF */ 318 int samplerate) /* convert bitrate in kbps to index */ 319 { 320 int i; 321 322 for ( i = 0; i <= 14; i++) 323 if ( bitrate_table [version] [i] == bRate ) 324 return i; 325 326 return -1; 327 } 328 329 /* convert samp freq in Hz to index */ 330 331 int SmpFrqIndex ( int sample_freq, int* const version ) 332 { 333 switch ( sample_freq ) { 334 case 44100: *version = 1; return 0; 335 case 48000: *version = 1; return 1; 336 case 32000: *version = 1; return 2; 337 case 22050: *version = 0; return 0; 338 case 24000: *version = 0; return 1; 339 case 16000: *version = 0; return 2; 340 case 11025: *version = 0; return 0; 341 case 12000: *version = 0; return 1; 342 case 8000: *version = 0; return 2; 343 default: *version = 0; return -1; 344 } 345 } 346 347 348 /***************************************************************************** 349 * 350 * End of bit_stream.c package 351 * 352 *****************************************************************************/ 353 354 /* reorder the three short blocks By Takehiro TOMINAGA */ 355 /* 356 Within each scalefactor band, data is given for successive 357 time windows, beginning with window 0 and ending with window 2. 358 Within each window, the quantized values are then arranged in 359 order of increasing frequency... 360 */ 361 void freorder(int scalefac_band[],FLOAT8 ix_orig[576]) { 362 int i,sfb, window, j=0; 363 FLOAT8 ix[576]; 364 for (sfb = 0; sfb < SBMAX_s; sfb++) { 365 int start = scalefac_band[sfb]; 366 int end = scalefac_band[sfb + 1]; 367 for (window = 0; window < 3; window++) { 368 for (i = start; i < end; ++i) { 369 ix[j++] = ix_orig[3*i+window]; 370 } 371 } 372 } 373 memcpy(ix_orig,ix,576*sizeof(FLOAT8)); 374 } 375 376 377 378 379 380 381 382 #ifndef KLEMM_44 383 384 385 /* resampling via FIR filter, blackman window */ 386 inline static FLOAT8 blackman(FLOAT8 x,FLOAT8 fcn,int l) 387 { 388 /* This algorithm from: 389 SIGNAL PROCESSING ALGORITHMS IN FORTRAN AND C 390 S.D. Stearns and R.A. David, Prentice-Hall, 1992 391 */ 392 FLOAT8 bkwn,x2; 393 FLOAT8 wcn = (PI * fcn); 394 395 x /= l; 396 if (x<0) x=0; 397 if (x>1) x=1; 398 x2 = x - .5; 399 400 bkwn = 0.42 - 0.5*cos(2*x*PI) + 0.08*cos(4*x*PI); 401 if (fabs(x2)<1e-9) return wcn/PI; 402 else 403 return ( bkwn*sin(l*wcn*x2) / (PI*l*x2) ); 404 405 406 } 407 408 /* gcd - greatest common divisor */ 409 /* Joint work of Euclid and M. Hendry */ 410 411 int gcd ( int i, int j ) 412 { 413 // assert ( i > 0 && j > 0 ); 414 return j ? gcd(j, i % j) : i; 415 } 416 417 418 419 /* copy in new samples from in_buffer into mfbuf, with resampling & scaling 420 if necessary. n_in = number of samples from the input buffer that 421 were used. n_out = number of samples copied into mfbuf */ 422 423 void fill_buffer(lame_global_flags *gfp, 424 sample_t *mfbuf[2], 425 sample_t *in_buffer[2], 426 int nsamples, int *n_in, int *n_out) 427 { 428 lame_internal_flags *gfc = gfp->internal_flags; 429 int ch,i; 430 431 /* copy in new samples into mfbuf, with resampling if necessary */ 432 if (gfc->resample_ratio != 1.0) { 433 for (ch = 0; ch < gfc->channels_out; ch++) { 434 *n_out = 435 fill_buffer_resample(gfp, &mfbuf[ch][gfc->mf_size], 436 gfp->framesize, in_buffer[ch], 437 nsamples, n_in, ch); 438 } 439 } 440 else { 441 *n_out = Min(gfp->framesize, nsamples); 442 *n_in = *n_out; 443 for (i = 0; i < *n_out; ++i) { 444 mfbuf[0][gfc->mf_size + i] = in_buffer[0][i]; 445 if (gfc->channels_out == 2) 446 mfbuf[1][gfc->mf_size + i] = in_buffer[1][i]; 447 } 448 } 449 450 /* user selected scaling of the samples */ 451 if (gfp->scale != 0) { 452 for (i=0 ; i<*n_out; ++i) { 453 mfbuf[0][gfc->mf_size+i] *= gfp->scale; 454 if (gfc->channels_out == 2) 455 mfbuf[1][gfc->mf_size + i] *= gfp->scale; 456 } 457 } 458 459 } 460 461 462 463 464 int fill_buffer_resample( 465 lame_global_flags *gfp, 466 sample_t *outbuf, 467 int desired_len, 468 sample_t *inbuf, 469 int len, 470 int *num_used, 471 int ch) 472 { 473 474 475 lame_internal_flags *gfc=gfp->internal_flags; 476 int BLACKSIZE; 477 FLOAT8 offset,xvalue; 478 int i,j=0,k; 479 int filter_l; 480 FLOAT8 fcn,intratio; 481 FLOAT *inbuf_old; 482 int bpc; /* number of convolution functions to pre-compute */ 483 bpc = gfp->out_samplerate/gcd(gfp->out_samplerate,gfp->in_samplerate); 484 if (bpc>BPC) bpc = BPC; 485 486 intratio=( fabs(gfc->resample_ratio - floor(.5+gfc->resample_ratio)) < .0001 ); 487 fcn = 1.00/gfc->resample_ratio; 488 if (fcn>1.00) fcn=1.00; 489 filter_l = gfp->quality < 7 ? 31 : 7; 490 filter_l = 31; 491 if (0==filter_l % 2 ) --filter_l;/* must be odd */ 492 filter_l += intratio; /* unless resample_ratio=int, it must be even */ 493 494 495 BLACKSIZE = filter_l+1; /* size of data needed for FIR */ 496 497 if ( gfc->fill_buffer_resample_init == 0 ) { 498 gfc->inbuf_old[0]=calloc(BLACKSIZE,sizeof(gfc->inbuf_old[0][0])); 499 gfc->inbuf_old[1]=calloc(BLACKSIZE,sizeof(gfc->inbuf_old[0][0])); 500 for (i=0; i<=2*bpc; ++i) 501 gfc->blackfilt[i]=calloc(BLACKSIZE,sizeof(gfc->blackfilt[0][0])); 502 503 gfc->itime[0]=0; 504 gfc->itime[1]=0; 505 506 /* precompute blackman filter coefficients */ 507 for ( j = 0; j <= 2*bpc; j++ ) { 508 FLOAT8 sum = 0.; 509 offset = (j-bpc) / (2.*bpc); 510 for ( i = 0; i <= filter_l; i++ ) 511 sum += 512 gfc->blackfilt[j][i] = blackman(i-offset,fcn,filter_l); 513 for ( i = 0; i <= filter_l; i++ ) 514 gfc->blackfilt[j][i] /= sum; 515 } 516 gfc->fill_buffer_resample_init = 1; 517 } 518 519 inbuf_old=gfc->inbuf_old[ch]; 520 521 /* time of j'th element in inbuf = itime + j/ifreq; */ 522 /* time of k'th element in outbuf = j/ofreq */ 523 for (k=0;k<desired_len;k++) { 524 FLOAT time0; 525 int joff; 526 527 time0 = k*gfc->resample_ratio; /* time of k'th output sample */ 528 j = floor( time0 -gfc->itime[ch] ); 529 530 /* check if we need more input data */ 531 if ((filter_l + j - filter_l/2) >= len) break; 532 533 /* blackman filter. by default, window centered at j+.5(filter_l%2) */ 534 /* but we want a window centered at time0. */ 535 offset = ( time0 -gfc->itime[ch] - (j + .5*(filter_l%2))); 536 assert(fabs(offset)<=.500001); 537 538 /* find the closest precomputed window for this offset: */ 539 joff = floor((offset*2*bpc) + bpc +.5); 540 541 xvalue = 0.; 542 for (i=0 ; i<=filter_l ; ++i) { 543 int j2 = i+j-filter_l/2; 544 int y; 545 assert(j2<len); 546 assert(j2+BLACKSIZE >= 0); 547 y = (j2<0) ? inbuf_old[BLACKSIZE+j2] : inbuf[j2]; 548 #define PRECOMPUTE 549 #ifdef PRECOMPUTE 550 xvalue += y*gfc->blackfilt[joff][i]; 551 #else 552 xvalue += y*blackman(i-offset,fcn,filter_l); /* very slow! */ 553 #endif 554 } 555 outbuf[k]=xvalue; 556 } 557 558 559 /* k = number of samples added to outbuf */ 560 /* last k sample used data from [j-filter_l/2,j+filter_l-filter_l/2] */ 561 562 /* how many samples of input data were used: */ 563 *num_used = Min(len,filter_l+j-filter_l/2); 564 565 /* adjust our input time counter. Incriment by the number of samples used, 566 * then normalize so that next output sample is at time 0, next 567 * input buffer is at time itime[ch] */ 568 gfc->itime[ch] += *num_used - k*gfc->resample_ratio; 569 570 /* save the last BLACKSIZE samples into the inbuf_old buffer */ 571 if (*num_used >= BLACKSIZE) { 572 for (i=0;i<BLACKSIZE;i++) 573 inbuf_old[i]=inbuf[*num_used + i -BLACKSIZE]; 574 }else{ 575 /* shift in *num_used samples into inbuf_old */ 576 int n_shift = BLACKSIZE-*num_used; /* number of samples to shift */ 577 578 /* shift n_shift samples by *num_used, to make room for the 579 * num_used new samples */ 580 for (i=0; i<n_shift; ++i ) 581 inbuf_old[i] = inbuf_old[i+ *num_used]; 582 583 /* shift in the *num_used samples */ 584 for (j=0; i<BLACKSIZE; ++i, ++j ) 585 inbuf_old[i] = inbuf[j]; 586 587 assert(j==*num_used); 588 } 589 return k; /* return the number samples created at the new samplerate */ 590 } 591 592 593 #endif /* ndef KLEMM_44 */ 594 595 596 597 /*********************************************************************** 598 * 599 * Message Output 600 * 601 ***********************************************************************/ 602 void lame_debugf (const lame_internal_flags *gfc, const char* format, ... ) 603 { 604 va_list args; 605 606 va_start ( args, format ); 607 608 if ( gfc->report.debugf != NULL ) { 609 gfc->report.debugf( format, args ); 610 } else { 611 (void) vfprintf ( stderr, format, args ); 612 fflush ( stderr ); /* an debug function should flush immediately */ 613 } 614 615 va_end ( args ); 616 } 617 618 619 void lame_msgf (const lame_internal_flags *gfc, const char* format, ... ) 620 { 621 va_list args; 622 623 va_start ( args, format ); 624 625 if ( gfc->report.msgf != NULL ) { 626 gfc->report.msgf( format, args ); 627 } else { 628 (void) vfprintf ( stderr, format, args ); 629 fflush ( stderr ); /* we print to stderr, so me may want to flush */ 630 } 631 632 va_end ( args ); 633 } 634 635 636 void lame_errorf (const lame_internal_flags *gfc, const char* format, ... ) 637 { 638 va_list args; 639 640 va_start ( args, format ); 641 642 if ( gfc->report.errorf != NULL ) { 643 gfc->report.errorf( format, args ); 644 } else { 645 (void) vfprintf ( stderr, format, args ); 646 fflush ( stderr ); /* an error function should flush immediately */ 647 } 648 649 va_end ( args ); 650 } 651 652 653 654 /*********************************************************************** 655 * 656 * routines to detect CPU specific features like 3DNow, MMX, SIMD 657 * 658 * donated by Frank Klemm 659 * added Robert Hegemann 2000-10-10 660 * 661 ***********************************************************************/ 662 663 int has_i387 ( void ) 664 { 665 #ifdef HAVE_NASM 666 return 1; 667 #else 668 return 0; /* don't know, assume not */ 669 #endif 670 } 671 672 int has_MMX ( void ) 673 { 674 #ifdef HAVE_NASM 675 extern int has_MMX_nasm ( void ); 676 return has_MMX_nasm (); 677 #else 678 return 0; /* don't know, assume not */ 679 #endif 680 } 681 682 int has_3DNow ( void ) 683 { 684 #ifdef HAVE_NASM 685 extern int has_3DNow_nasm ( void ); 686 return has_3DNow_nasm (); 687 #else 688 return 0; /* don't know, assume not */ 689 #endif 690 } 691 692 int has_SIMD ( void ) 693 { 694 #ifdef HAVE_NASM 695 extern int has_SIMD_nasm ( void ); 696 return has_SIMD_nasm (); 697 #else 698 return 0; /* don't know, assume not */ 699 #endif 700 } 701 702 int has_SIMD2 ( void ) 703 { 704 #ifdef HAVE_NASM 705 extern int has_SIMD2_nasm ( void ); 706 return has_SIMD2_nasm (); 707 #else 708 return 0; /* don't know, assume not */ 709 #endif 710 } 711 712 /*********************************************************************** 713 * 714 * some simple statistics 715 * 716 * bitrate index 0: free bitrate -> not allowed in VBR mode 717 * : bitrates, kbps depending on MPEG version 718 * bitrate index 15: forbidden 719 * 720 * mode_ext: 721 * 0: LR 722 * 1: LR-i 723 * 2: MS 724 * 3: MS-i 725 * 726 ***********************************************************************/ 727 728 void updateStats( lame_internal_flags * const gfc ) 729 { 730 assert ( gfc->bitrate_index < 16u ); 731 assert ( gfc->mode_ext < 4u ); 732 733 /* count bitrate indices */ 734 gfc->bitrate_stereoMode_Hist [gfc->bitrate_index] [4] ++; 735 736 /* count 'em for every mode extension in case of 2 channel encoding */ 737 if (gfc->channels_out == 2) 738 gfc->bitrate_stereoMode_Hist [gfc->bitrate_index] [gfc->mode_ext]++; 739 } 740 741 742 743 /* caution: a[] will be resorted!! 744 */ 745 int select_kth_int(int a[], int N, int k) 746 { 747 int i, j, l, r, v, w; 748 749 l = 0; 750 r = N-1; 751 while (r > l) { 752 v = a[r]; 753 i = l-1; 754 j = r; 755 for (;;) { 756 while (a[++i] < v) /*empty*/; 757 while (a[--j] > v) /*empty*/; 758 if (i >= j) 759 break; 760 /* swap i and j */ 761 w = a[i]; 762 a[i] = a[j]; 763 a[j] = w; 764 } 765 /* swap i and r */ 766 w = a[i]; 767 a[i] = a[r]; 768 a[r] = w; 769 if (i >= k) 770 r = i-1; 771 if (i <= k) 772 l = i+1; 773 } 774 return a[k]; 775 } 776 777 778 779 void disable_FPE(void) { 780 /* extremly system dependent stuff, move to a lib to make the code readable */ 781 /*==========================================================================*/ 782 783 /* 784 * Disable floating point exceptions 785 */ 786 #if defined(__FreeBSD__) && !defined(__alpha__) 787 { 788 /* seet floating point mask to the Linux default */ 789 fp_except_t mask; 790 mask = fpgetmask(); 791 /* if bit is set, we get SIGFPE on that error! */ 792 fpsetmask(mask & ~(FP_X_INV | FP_X_DZ)); 793 /* DEBUGF("FreeBSD mask is 0x%x\n",mask); */ 794 } 795 #endif 796 797 #if defined(__riscos__) && !defined(ABORTFP) 798 /* Disable FPE's under RISC OS */ 799 /* if bit is set, we disable trapping that error! */ 800 /* _FPE_IVO : invalid operation */ 801 /* _FPE_DVZ : divide by zero */ 802 /* _FPE_OFL : overflow */ 803 /* _FPE_UFL : underflow */ 804 /* _FPE_INX : inexact */ 805 DisableFPETraps(_FPE_IVO | _FPE_DVZ | _FPE_OFL); 806 #endif 807 808 /* 809 * Debugging stuff 810 * The default is to ignore FPE's, unless compiled with -DABORTFP 811 * so add code below to ENABLE FPE's. 812 */ 813 814 #if defined(ABORTFP) 815 #if defined(_MSC_VER) 816 { 817 #include <float.h> 818 unsigned int mask; 819 mask = _controlfp(0, 0); 820 mask &= ~(_EM_OVERFLOW | _EM_UNDERFLOW | _EM_ZERODIVIDE | _EM_INVALID); 821 mask = _controlfp(mask, _MCW_EM); 822 } 823 #elif defined(__CYGWIN__) 824 # define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw)) 825 # define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw)) 826 827 # define _EM_INEXACT 0x00000020 /* inexact (precision) */ 828 # define _EM_UNDERFLOW 0x00000010 /* underflow */ 829 # define _EM_OVERFLOW 0x00000008 /* overflow */ 830 # define _EM_ZERODIVIDE 0x00000004 /* zero divide */ 831 # define _EM_INVALID 0x00000001 /* invalid */ 832 { 833 unsigned int mask; 834 _FPU_GETCW(mask); 835 /* Set the FPU control word to abort on most FPEs */ 836 mask &= ~(_EM_OVERFLOW | _EM_ZERODIVIDE | _EM_INVALID); 837 _FPU_SETCW(mask); 838 } 839 # elif defined(__linux__) 840 { 841 842 # include <fpu_control.h> 843 # ifndef _FPU_GETCW 844 # define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw)) 845 # endif 846 # ifndef _FPU_SETCW 847 # define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw)) 848 # endif 849 850 /* 851 * Set the Linux mask to abort on most FPE's 852 * if bit is set, we _mask_ SIGFPE on that error! 853 * mask &= ~( _FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM | _FPU_MASK_UM ); 854 */ 855 856 unsigned int mask; 857 _FPU_GETCW(mask); 858 mask &= ~(_FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM); 859 _FPU_SETCW(mask); 860 } 861 #endif 862 #endif /* ABORTFP */ 863 } 864 865 866 /* end of util.c */ 867