X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Flame%2Futil.c;fp=lib%2Flame%2Futil.c;h=1df7de1dea714de96e1632aa4e20ae42477c0038;hb=698acf324aaa52147b1486646f6549ffd95804da;hp=0000000000000000000000000000000000000000;hpb=f8d07c79494e8536e682da73cee2057740a0e4db;p=swftools.git diff --git a/lib/lame/util.c b/lib/lame/util.c new file mode 100644 index 0000000..1df7de1 --- /dev/null +++ b/lib/lame/util.c @@ -0,0 +1,989 @@ +/* + * lame utility library source file + * + * Copyright (c) 1999 Albert L Faber + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* $Id: util.c,v 1.1 2002/04/28 17:30:30 kramm Exp $ */ + +#include "config_static.h" + +#define PRECOMPUTE + +#include "util.h" +#include "tools.h" +#include +#include +#include + +#if defined(__FreeBSD__) && !defined(__alpha__) +# include +#endif + +#ifdef WITH_DMALLOC +#include +#endif + +/*********************************************************************** +* +* Global Function Definitions +* +***********************************************************************/ +/*empty and close mallocs in gfc */ + +void freegfc ( lame_internal_flags* const gfc ) /* bit stream structure */ +{ + int i; + +#ifdef KLEMM_44 + if (gfc->resample_in != NULL) { + resample_close(gfc->resample_in); + gfc->resample_in = NULL; + } + free(gfc->mfbuf[0]); + free(gfc->mfbuf[1]); +#endif + + for ( i = 0 ; i <= 2*BPC; i++ ) + if ( gfc->blackfilt[i] != NULL ) { + free ( gfc->blackfilt[i] ); + gfc->blackfilt[i] = NULL; + } + if ( gfc->inbuf_old[0] ) { + free ( gfc->inbuf_old[0] ); + gfc->inbuf_old[0] = NULL; + } + if ( gfc->inbuf_old[1] ) { + free ( gfc->inbuf_old[1] ); + gfc->inbuf_old[1] = NULL; + } + + if ( gfc->bs.buf != NULL ) { + free ( gfc->bs.buf ); + gfc->bs.buf = NULL; + } + + if ( gfc->VBR_seek_table.bag ) { + free ( gfc->VBR_seek_table.bag ); + } + if ( gfc->ATH ) { + free ( gfc->ATH ); + } + if ( gfc->VBR ) { + free ( gfc->VBR ); + } + if ( gfc->PSY ) { + free ( gfc->PSY ); + } + if ( gfc->s3_ll ) { + /* XXX allocated in psymodel_init() */ + free ( gfc->s3_ll ); + } + if ( gfc->s3_ss ) { + /* XXX allocated in psymodel_init() */ + free ( gfc->s3_ss ); + } + free ( gfc ); +} + + + +/*those ATH formulas are returning +their minimum value for input = -1*/ + +FLOAT8 ATHformula_GB(FLOAT8 f, FLOAT8 value) +{ + /* from Painter & Spanias + modified by Gabriel Bouvigne to better fit the reality + ath = 3.640 * pow(f,-0.8) + - 6.800 * exp(-0.6*pow(f-3.4,2.0)) + + 6.000 * exp(-0.15*pow(f-8.7,2.0)) + + 0.6* 0.001 * pow(f,4.0); + + + In the past LAME was using the Painter &Spanias formula. + But we had some recurrent problems with HF content. + We measured real ATH values, and found the older formula + to be inacurate in the higher part. So we made this new + formula and this solved most of HF problematic testcases. + The tradeoff is that in VBR mode it increases a lot the + bitrate.*/ + + +/*this curve can be udjusted according to the VBR scale: +it adjusts from something close to Painter & Spanias +on V9 up to Bouvigne's formula for V0. This way the VBR +bitrate is more balanced according to the -V value.*/ + + FLOAT8 ath; + + if (f < -.3) + f=3410; + + f /= 1000; // convert to khz + f = Max(0.01, f); + f = Min(18.0, f); + + ath = 3.640 * pow(f,-0.8) + - 6.800 * exp(-0.6*pow(f-3.4,2.0)) + + 6.000 * exp(-0.15*pow(f-8.7,2.0)) + + (0.6+0.04*value)* 0.001 * pow(f,4.0); + return ath; +} + + +/* + * Klemm 1994 and 1997. Experimental data. Sorry, data looks a little bit + * dodderly. Data below 30 Hz is extrapolated from other material, above 18 + * kHz the ATH is limited due to the original purpose (too much noise at + * ATH is not good even if it's theoretically inaudible). + */ + +FLOAT8 ATHformula_Frank( FLOAT8 freq ) +{ + /* + * one value per 100 cent = 1 + * semitone = 1/4 + * third = 1/12 + * octave = 1/40 decade + * rest is linear interpolated, values are currently in decibel rel. 20 µPa + */ + static FLOAT tab [] = { + /* 10.0 */ 96.69, 96.69, 96.26, 95.12, + /* 12.6 */ 93.53, 91.13, 88.82, 86.76, + /* 15.8 */ 84.69, 82.43, 79.97, 77.48, + /* 20.0 */ 74.92, 72.39, 70.00, 67.62, + /* 25.1 */ 65.29, 63.02, 60.84, 59.00, + /* 31.6 */ 57.17, 55.34, 53.51, 51.67, + /* 39.8 */ 50.04, 48.12, 46.38, 44.66, + /* 50.1 */ 43.10, 41.73, 40.50, 39.22, + /* 63.1 */ 37.23, 35.77, 34.51, 32.81, + /* 79.4 */ 31.32, 30.36, 29.02, 27.60, + /* 100.0 */ 26.58, 25.91, 24.41, 23.01, + /* 125.9 */ 22.12, 21.25, 20.18, 19.00, + /* 158.5 */ 17.70, 16.82, 15.94, 15.12, + /* 199.5 */ 14.30, 13.41, 12.60, 11.98, + /* 251.2 */ 11.36, 10.57, 9.98, 9.43, + /* 316.2 */ 8.87, 8.46, 7.44, 7.12, + /* 398.1 */ 6.93, 6.68, 6.37, 6.06, + /* 501.2 */ 5.80, 5.55, 5.29, 5.02, + /* 631.0 */ 4.75, 4.48, 4.22, 3.98, + /* 794.3 */ 3.75, 3.51, 3.27, 3.22, + /* 1000.0 */ 3.12, 3.01, 2.91, 2.68, + /* 1258.9 */ 2.46, 2.15, 1.82, 1.46, + /* 1584.9 */ 1.07, 0.61, 0.13, -0.35, + /* 1995.3 */ -0.96, -1.56, -1.79, -2.35, + /* 2511.9 */ -2.95, -3.50, -4.01, -4.21, + /* 3162.3 */ -4.46, -4.99, -5.32, -5.35, + /* 3981.1 */ -5.13, -4.76, -4.31, -3.13, + /* 5011.9 */ -1.79, 0.08, 2.03, 4.03, + /* 6309.6 */ 5.80, 7.36, 8.81, 10.22, + /* 7943.3 */ 11.54, 12.51, 13.48, 14.21, + /* 10000.0 */ 14.79, 13.99, 12.85, 11.93, + /* 12589.3 */ 12.87, 15.19, 19.14, 23.69, + /* 15848.9 */ 33.52, 48.65, 59.42, 61.77, + /* 19952.6 */ 63.85, 66.04, 68.33, 70.09, + /* 25118.9 */ 70.66, 71.27, 71.91, 72.60, + }; + FLOAT8 freq_log; + unsigned index; + + if (freq < -.3) + freq=3758; + + if ( freq < 10. ) freq = 10.; + if ( freq > 29853. ) freq = 29853.; + + freq_log = 40. * log10 (0.1 * freq); /* 4 steps per third, starting at 10 Hz */ + index = (unsigned) freq_log; + assert ( index < sizeof(tab)/sizeof(*tab) ); + return tab [index] * (1 + index - freq_log) + tab [index+1] * (freq_log - index); +} + + + +/* ATHformula_jd - Compute ATH at a given frequency from experimental data. + Below 15000 Hz, this ATH curve is based on data merged from + various existing sources. New experimental data covers + frequencies above 15000 Hz. -jd + in: freq (Hz) +returns: ATH value at freq in dB, or minimum ATH value if input freq is -1 +design notes: + Above 15000 Hz, my data indicates roughly 10 dB between the edge of + ready detection, and statistical indistinguishability. To provide a + balance between my data, and ATH data from other sources, roughly 5 dB + is added above 15000 Hz, except at frequencies above 20500 Hz. The ATH + of 21000+ Hz frequencies is decreased by 5 dB, to reduce the possibility + of extra distortion that some output systems exhibit when given a contrived + sample with an intense, but hardly audible frequency. +*/ +FLOAT8 +ATHformula_jd( FLOAT8 freq ) +{ + int i; + int ifreq; + int at_i; + int tstep; + int xtrans; + FLOAT coeff[3]; + FLOAT8 rval; + + const FLOAT ath_lt100[] /* 20 - 120 Hz (for computing 0 - 100 Hz) */ + = { 74.0, 47.9, 35.2, 28.1, 23.5, 20.4 }; + + const FLOAT ath_lt500[] /* 100 - 600 Hz (for 100 - 500 Hz) */ + = { 23.5, 13.4, 9.4, 6.9, 5.9, 5.0 }; + + const FLOAT ath_gt500[] /* 500 Hz and above */ + = { /* 500 */ 5.9, 3.2, 1.6, -0.7, + /* 2500 */ -2.7, -4.5, -5.2, -4.8, -3.7, + /* 5000 */ -1.6, 1.5, 3.8, 5.3, 6.8, + /* 7500 */ 8.2, 9.5, 10.5, 11.3, 11.8, + /* 10000 */ 12.1, 12.2, 12.4, 12.4, 12.4, + /* 12500 */ 12.8, 13.5, 14.9, 16.8, 19.0, + /* 15000 */ 23.0, 27.0, 33.0, 36.5, 39.5, + /* 17500 */ 43.5, 51.5, 58.5, 65.0, 71.5, + /* 20000 */ 78.0, 79.5, 80.0, 80.5, 80.5, 80.5 }; + + const FLOAT *ath_table[4]; + const int ath_table_step[4] = { 20, 100, 500, 500 }; + const FLOAT ath_table_xratio[4] = { 0.05, 0.01, 0.002, 0.002 }; + + ath_table[0] = ath_lt100; + ath_table[1] = ath_lt500; + ath_table[3] = ath_gt500; + + if( freq >= -0.5 && freq < 22000 ) { + ifreq = (int) freq; + at_i = ( (((99 - ifreq) >> (sizeof(int) * 8 - 1)) & 0x1) + | (((499 - ifreq) >> (sizeof(int) * 8 - 2)) & 0x3) ); + tstep = ath_table_step[at_i]; + + i = (ifreq / tstep); + i -= 2; + if( i >= 0 ) { + qinterp_cf_42( ath_table[at_i] + i, coeff ); + xtrans = (i + 2) * tstep; + } else { /* leading edge */ + qinterp_cf_3( ath_table[at_i], coeff ); + xtrans = tstep; + } + rval = qinterp_eval( coeff, freq, (FLOAT)xtrans, ath_table_xratio[at_i]); + return(rval); + } else if( freq < 0 ) { + return(-5.2); /* minimum value from table */ + } else { + return( ath_gt500[ 22000 / 500 - 1 ] ); /* 22kHz ATH used for 22kHz+ */ + } +} + + + +FLOAT8 ATHformula(FLOAT8 f,lame_global_flags *gfp) +{ + switch(gfp->ATHtype) + { + case 0: + return ATHformula_GB(f, 9); + case 1: + return ATHformula_Frank(f); + case 2: + return ATHformula_GB(f, 0); + case 3: + return ATHformula_GB(f, 1) +6; /*modification of GB formula by Roel*/ + case 4: + if (!(gfp->VBR == vbr_off || gfp->VBR == vbr_abr)) /*this case should be used with true vbr only*/ + return ATHformula_GB(f,gfp->VBR_q); + case 5: + return ATHformula_jd(f); + } + + return ATHformula_GB(f, 0); +} + +/* see for example "Zwicker: Psychoakustik, 1982; ISBN 3-540-11401-7 */ +FLOAT8 freq2bark(FLOAT8 freq) +{ + /* input: freq in hz output: barks */ + if (freq<0) freq=0; + freq = freq * 0.001; + return 13.0*atan(.76*freq) + 3.5*atan(freq*freq/(7.5*7.5)); +} + +/* see for example "Zwicker: Psychoakustik, 1982; ISBN 3-540-11401-7 */ +FLOAT8 freq2cbw(FLOAT8 freq) +{ + /* input: freq in hz output: critical band width */ + freq = freq * 0.001; + return 25+75*pow(1+1.4*(freq*freq),0.69); +} + + + + + + +/*********************************************************************** + * compute bitsperframe and mean_bits for a layer III frame + **********************************************************************/ +void getframebits(const lame_global_flags * gfp, int *bitsPerFrame, int *mean_bits) +{ + lame_internal_flags *gfc=gfp->internal_flags; + int whole_SpF; /* integral number of Slots per Frame without padding */ + int bit_rate; + + /* get bitrate in kbps [?] */ + if (gfc->bitrate_index) + bit_rate = bitrate_table[gfp->version][gfc->bitrate_index]; + else + bit_rate = gfp->brate; + assert ( bit_rate <= 550 ); + + // bytes_per_frame = bitrate * 1000 / ( gfp->out_samplerate / (gfp->version == 1 ? 1152 : 576 )) / 8; + // bytes_per_frame = bitrate * 1000 / gfp->out_samplerate * (gfp->version == 1 ? 1152 : 576 ) / 8; + // bytes_per_frame = bitrate * ( gfp->version == 1 ? 1152/8*1000 : 576/8*1000 ) / gfp->out_samplerate; + + whole_SpF = (gfp->version+1)*72000*bit_rate / gfp->out_samplerate; + + /* main encoding routine toggles padding on and off */ + /* one Layer3 Slot consists of 8 bits */ + *bitsPerFrame = 8 * (whole_SpF + gfc->padding); + + // sideinfo_len + *mean_bits = (*bitsPerFrame - 8*gfc->sideinfo_len) / gfc->mode_gr; +} + + + + +#define ABS(A) (((A)>0) ? (A) : -(A)) + +int FindNearestBitrate( +int bRate, /* legal rates from 32 to 448 */ +int version, /* MPEG-1 or MPEG-2 LSF */ +int samplerate) /* convert bitrate in kbps to index */ +{ + int bitrate = 0; + int i; + + for ( i = 1; i <= 14; i++ ) + if ( ABS (bitrate_table[version][i] - bRate) < ABS (bitrate - bRate) ) + bitrate = bitrate_table [version] [i]; + + return bitrate; +} + + +/* map frequency to a valid MP3 sample frequency + * + * Robert.Hegemann@gmx.de 2000-07-01 + */ +int map2MP3Frequency(int freq) +{ + if (freq <= 8000) return 8000; + if (freq <= 11025) return 11025; + if (freq <= 12000) return 12000; + if (freq <= 16000) return 16000; + if (freq <= 22050) return 22050; + if (freq <= 24000) return 24000; + if (freq <= 32000) return 32000; + if (freq <= 44100) return 44100; + + return 48000; +} + +int BitrateIndex( +int bRate, /* legal rates from 32 to 448 kbps */ +int version, /* MPEG-1 or MPEG-2/2.5 LSF */ +int samplerate) /* convert bitrate in kbps to index */ +{ + int i; + + for ( i = 0; i <= 14; i++) + if ( bitrate_table [version] [i] == bRate ) + return i; + + return -1; +} + +/* convert samp freq in Hz to index */ + +int SmpFrqIndex ( int sample_freq, int* const version ) +{ + switch ( sample_freq ) { + case 44100: *version = 1; return 0; + case 48000: *version = 1; return 1; + case 32000: *version = 1; return 2; + case 22050: *version = 0; return 0; + case 24000: *version = 0; return 1; + case 16000: *version = 0; return 2; + case 11025: *version = 0; return 0; + case 12000: *version = 0; return 1; + case 8000: *version = 0; return 2; + default: *version = 0; return -1; + } +} + + +/***************************************************************************** +* +* End of bit_stream.c package +* +*****************************************************************************/ + +/* reorder the three short blocks By Takehiro TOMINAGA */ +/* + Within each scalefactor band, data is given for successive + time windows, beginning with window 0 and ending with window 2. + Within each window, the quantized values are then arranged in + order of increasing frequency... +*/ +void freorder(int scalefac_band[],FLOAT8 ix_orig[576]) { + int i,sfb, window, j=0; + FLOAT8 ix[576]; + for (sfb = 0; sfb < SBMAX_s; sfb++) { + int start = scalefac_band[sfb]; + int end = scalefac_band[sfb + 1]; + for (window = 0; window < 3; window++) { + for (i = start; i < end; ++i) { + ix[j++] = ix_orig[3*i+window]; + } + } + } + memcpy(ix_orig,ix,576*sizeof(FLOAT8)); +} + + + + + + + +#ifndef KLEMM_44 + + +/* resampling via FIR filter, blackman window */ +inline static FLOAT8 blackman(FLOAT8 x,FLOAT8 fcn,int l) +{ + /* This algorithm from: +SIGNAL PROCESSING ALGORITHMS IN FORTRAN AND C +S.D. Stearns and R.A. David, Prentice-Hall, 1992 + */ + FLOAT8 bkwn,x2; + FLOAT8 wcn = (PI * fcn); + + x /= l; + if (x<0) x=0; + if (x>1) x=1; + x2 = x - .5; + + bkwn = 0.42 - 0.5*cos(2*x*PI) + 0.08*cos(4*x*PI); + if (fabs(x2)<1e-9) return wcn/PI; + else + return ( bkwn*sin(l*wcn*x2) / (PI*l*x2) ); + + +} + +/* gcd - greatest common divisor */ +/* Joint work of Euclid and M. Hendry */ + +int gcd ( int i, int j ) +{ +// assert ( i > 0 && j > 0 ); + return j ? gcd(j, i % j) : i; +} + + + +/* copy in new samples from in_buffer into mfbuf, with resampling & scaling + if necessary. n_in = number of samples from the input buffer that + were used. n_out = number of samples copied into mfbuf */ + +void fill_buffer(lame_global_flags *gfp, + sample_t *mfbuf[2], + sample_t *in_buffer[2], + int nsamples, int *n_in, int *n_out) +{ + lame_internal_flags *gfc = gfp->internal_flags; + int ch,i; + + /* copy in new samples into mfbuf, with resampling if necessary */ + if (gfc->resample_ratio != 1.0) { + for (ch = 0; ch < gfc->channels_out; ch++) { + *n_out = + fill_buffer_resample(gfp, &mfbuf[ch][gfc->mf_size], + gfp->framesize, in_buffer[ch], + nsamples, n_in, ch); + } + } + else { + *n_out = Min(gfp->framesize, nsamples); + *n_in = *n_out; + for (i = 0; i < *n_out; ++i) { + mfbuf[0][gfc->mf_size + i] = in_buffer[0][i]; + if (gfc->channels_out == 2) + mfbuf[1][gfc->mf_size + i] = in_buffer[1][i]; + } + } + + /* user selected scaling of the samples */ + if (gfp->scale != 0 && gfp->scale != 1.0) { + for (i=0 ; i<*n_out; ++i) { + mfbuf[0][gfc->mf_size+i] *= gfp->scale; + if (gfc->channels_out == 2) + mfbuf[1][gfc->mf_size + i] *= gfp->scale; + } + } + + /* user selected scaling of the channel 0 (left) samples */ + if (gfp->scale_left != 0 && gfp->scale_left != 1.0) { + for (i=0 ; i<*n_out; ++i) { + mfbuf[0][gfc->mf_size+i] *= gfp->scale_left; + } + } + + /* user selected scaling of the channel 1 (right) samples */ + if (gfc->channels_out == 2) { + if (gfp->scale_right != 0 && gfp->scale_right != 1.0) { + for (i=0 ; i<*n_out; ++i) { + mfbuf[1][gfc->mf_size + i] *= gfp->scale_right; + } + } + } +} + + + + +int fill_buffer_resample( + lame_global_flags *gfp, + sample_t *outbuf, + int desired_len, + sample_t *inbuf, + int len, + int *num_used, + int ch) +{ + + + lame_internal_flags *gfc=gfp->internal_flags; + int BLACKSIZE; + FLOAT8 offset,xvalue; + int i,j=0,k; + int filter_l; + FLOAT8 fcn,intratio; + FLOAT *inbuf_old; + int bpc; /* number of convolution functions to pre-compute */ + bpc = gfp->out_samplerate/gcd(gfp->out_samplerate,gfp->in_samplerate); + if (bpc>BPC) bpc = BPC; + + intratio=( fabs(gfc->resample_ratio - floor(.5+gfc->resample_ratio)) < .0001 ); + fcn = 1.00/gfc->resample_ratio; + if (fcn>1.00) fcn=1.00; + filter_l = gfp->quality < 7 ? 31 : 7; + filter_l = 31; + if (0==filter_l % 2 ) --filter_l;/* must be odd */ + filter_l += intratio; /* unless resample_ratio=int, it must be even */ + + + BLACKSIZE = filter_l+1; /* size of data needed for FIR */ + + if ( gfc->fill_buffer_resample_init == 0 ) { + gfc->inbuf_old[0]=calloc(BLACKSIZE,sizeof(gfc->inbuf_old[0][0])); + gfc->inbuf_old[1]=calloc(BLACKSIZE,sizeof(gfc->inbuf_old[0][0])); + for (i=0; i<=2*bpc; ++i) + gfc->blackfilt[i]=calloc(BLACKSIZE,sizeof(gfc->blackfilt[0][0])); + + gfc->itime[0]=0; + gfc->itime[1]=0; + + /* precompute blackman filter coefficients */ + for ( j = 0; j <= 2*bpc; j++ ) { + FLOAT8 sum = 0.; + offset = (j-bpc) / (2.*bpc); + for ( i = 0; i <= filter_l; i++ ) + sum += + gfc->blackfilt[j][i] = blackman(i-offset,fcn,filter_l); + for ( i = 0; i <= filter_l; i++ ) + gfc->blackfilt[j][i] /= sum; + } + gfc->fill_buffer_resample_init = 1; + } + + inbuf_old=gfc->inbuf_old[ch]; + + /* time of j'th element in inbuf = itime + j/ifreq; */ + /* time of k'th element in outbuf = j/ofreq */ + for (k=0;kresample_ratio; /* time of k'th output sample */ + j = floor( time0 -gfc->itime[ch] ); + + /* check if we need more input data */ + if ((filter_l + j - filter_l/2) >= len) break; + + /* blackman filter. by default, window centered at j+.5(filter_l%2) */ + /* but we want a window centered at time0. */ + offset = ( time0 -gfc->itime[ch] - (j + .5*(filter_l%2))); + assert(fabs(offset)<=.501); + + /* find the closest precomputed window for this offset: */ + joff = floor((offset*2*bpc) + bpc +.5); + + xvalue = 0.; + for (i=0 ; i<=filter_l ; ++i) { + int j2 = i+j-filter_l/2; + int y; + assert(j2= 0); + y = (j2<0) ? inbuf_old[BLACKSIZE+j2] : inbuf[j2]; +#define PRECOMPUTE +#ifdef PRECOMPUTE + xvalue += y*gfc->blackfilt[joff][i]; +#else + xvalue += y*blackman(i-offset,fcn,filter_l); /* very slow! */ +#endif + } + outbuf[k]=xvalue; + } + + + /* k = number of samples added to outbuf */ + /* last k sample used data from [j-filter_l/2,j+filter_l-filter_l/2] */ + + /* how many samples of input data were used: */ + *num_used = Min(len,filter_l+j-filter_l/2); + + /* adjust our input time counter. Incriment by the number of samples used, + * then normalize so that next output sample is at time 0, next + * input buffer is at time itime[ch] */ + gfc->itime[ch] += *num_used - k*gfc->resample_ratio; + + /* save the last BLACKSIZE samples into the inbuf_old buffer */ + if (*num_used >= BLACKSIZE) { + for (i=0;ireport.debugf != NULL ) { + gfc->report.debugf( format, args ); + } else { + (void) vfprintf ( stderr, format, args ); + fflush ( stderr ); /* an debug function should flush immediately */ + } + + va_end ( args ); +} + + +void lame_msgf (const lame_internal_flags *gfc, const char* format, ... ) +{ + va_list args; + + va_start ( args, format ); + + if ( gfc->report.msgf != NULL ) { + gfc->report.msgf( format, args ); + } else { + (void) vfprintf ( stderr, format, args ); + fflush ( stderr ); /* we print to stderr, so me may want to flush */ + } + + va_end ( args ); +} + + +void lame_errorf (const lame_internal_flags *gfc, const char* format, ... ) +{ + va_list args; + + va_start ( args, format ); + + if ( gfc->report.errorf != NULL ) { + gfc->report.errorf( format, args ); + } else { + (void) vfprintf ( stderr, format, args ); + fflush ( stderr ); /* an error function should flush immediately */ + } + + va_end ( args ); +} + + + +/*********************************************************************** + * + * routines to detect CPU specific features like 3DNow, MMX, SIMD + * + * donated by Frank Klemm + * added Robert Hegemann 2000-10-10 + * + ***********************************************************************/ + +int has_i387 ( void ) +{ +#ifdef HAVE_NASM + return 1; +#else + return 0; /* don't know, assume not */ +#endif +} + +int has_MMX ( void ) +{ +#ifdef HAVE_NASM + extern int has_MMX_nasm ( void ); + return has_MMX_nasm (); +#else + return 0; /* don't know, assume not */ +#endif +} + +int has_3DNow ( void ) +{ +#ifdef HAVE_NASM + extern int has_3DNow_nasm ( void ); + return has_3DNow_nasm (); +#else + return 0; /* don't know, assume not */ +#endif +} + +int has_SIMD ( void ) +{ +#ifdef HAVE_NASM + extern int has_SIMD_nasm ( void ); + return has_SIMD_nasm (); +#else + return 0; /* don't know, assume not */ +#endif +} + +int has_SIMD2 ( void ) +{ +#ifdef HAVE_NASM + extern int has_SIMD2_nasm ( void ); + return has_SIMD2_nasm (); +#else + return 0; /* don't know, assume not */ +#endif +} + +/*********************************************************************** + * + * some simple statistics + * + * bitrate index 0: free bitrate -> not allowed in VBR mode + * : bitrates, kbps depending on MPEG version + * bitrate index 15: forbidden + * + * mode_ext: + * 0: LR + * 1: LR-i + * 2: MS + * 3: MS-i + * + ***********************************************************************/ + +void updateStats( lame_internal_flags * const gfc ) +{ + assert ( gfc->bitrate_index < 16u ); + assert ( gfc->mode_ext < 4u ); + + /* count bitrate indices */ + gfc->bitrate_stereoMode_Hist [gfc->bitrate_index] [4] ++; + + /* count 'em for every mode extension in case of 2 channel encoding */ + if (gfc->channels_out == 2) + gfc->bitrate_stereoMode_Hist [gfc->bitrate_index] [gfc->mode_ext]++; +} + + + +/* caution: a[] will be resorted!! + */ +int select_kth_int(int a[], int N, int k) +{ + int i, j, l, r, v, w; + + l = 0; + r = N-1; + while (r > l) { + v = a[r]; + i = l-1; + j = r; + for (;;) { + while (a[++i] < v) /*empty*/; + while (a[--j] > v) /*empty*/; + if (i >= j) + break; + /* swap i and j */ + w = a[i]; + a[i] = a[j]; + a[j] = w; + } + /* swap i and r */ + w = a[i]; + a[i] = a[r]; + a[r] = w; + if (i >= k) + r = i-1; + if (i <= k) + l = i+1; + } + return a[k]; +} + + + +void disable_FPE(void) { +/* extremly system dependent stuff, move to a lib to make the code readable */ +/*==========================================================================*/ + + + + /* + * Disable floating point exceptions + */ + + + + +#if defined(__FreeBSD__) && !defined(__alpha__) + { + /* seet floating point mask to the Linux default */ + fp_except_t mask; + mask = fpgetmask(); + /* if bit is set, we get SIGFPE on that error! */ + fpsetmask(mask & ~(FP_X_INV | FP_X_DZ)); + /* DEBUGF("FreeBSD mask is 0x%x\n",mask); */ + } +#endif + +#if defined(__riscos__) && !defined(ABORTFP) + /* Disable FPE's under RISC OS */ + /* if bit is set, we disable trapping that error! */ + /* _FPE_IVO : invalid operation */ + /* _FPE_DVZ : divide by zero */ + /* _FPE_OFL : overflow */ + /* _FPE_UFL : underflow */ + /* _FPE_INX : inexact */ + DisableFPETraps(_FPE_IVO | _FPE_DVZ | _FPE_OFL); +#endif + + /* + * Debugging stuff + * The default is to ignore FPE's, unless compiled with -DABORTFP + * so add code below to ENABLE FPE's. + */ + +#if defined(ABORTFP) +#if defined(_MSC_VER) + { + + /* set affinity to a single CPU. Fix for EAC/lame on SMP systems from + "Todd Richmond" */ + SYSTEM_INFO si; + GetSystemInfo(&si); + SetProcessAffinityMask(GetCurrentProcess(), si.dwActiveProcessorMask); + +#include + unsigned int mask; + mask = _controlfp(0, 0); + mask &= ~(_EM_OVERFLOW | _EM_UNDERFLOW | _EM_ZERODIVIDE | _EM_INVALID); + mask = _controlfp(mask, _MCW_EM); + } +#elif defined(__CYGWIN__) +# define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw)) +# define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw)) + +# define _EM_INEXACT 0x00000020 /* inexact (precision) */ +# define _EM_UNDERFLOW 0x00000010 /* underflow */ +# define _EM_OVERFLOW 0x00000008 /* overflow */ +# define _EM_ZERODIVIDE 0x00000004 /* zero divide */ +# define _EM_INVALID 0x00000001 /* invalid */ + { + unsigned int mask; + _FPU_GETCW(mask); + /* Set the FPU control word to abort on most FPEs */ + mask &= ~(_EM_OVERFLOW | _EM_ZERODIVIDE | _EM_INVALID); + _FPU_SETCW(mask); + } +# elif defined(__linux__) + { + +# include +# ifndef _FPU_GETCW +# define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw)) +# endif +# ifndef _FPU_SETCW +# define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw)) +# endif + + /* + * Set the Linux mask to abort on most FPE's + * if bit is set, we _mask_ SIGFPE on that error! + * mask &= ~( _FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM | _FPU_MASK_UM ); + */ + + unsigned int mask; + _FPU_GETCW(mask); + mask &= ~(_FPU_MASK_IM | _FPU_MASK_ZM | _FPU_MASK_OM); + _FPU_SETCW(mask); + } +#endif +#endif /* ABORTFP */ +} + + +/* end of util.c */