/* * lame utility library include 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. */ #ifndef LAME_UTIL_H #define LAME_UTIL_H #ifdef HUGE_VAL /* math.h already seen? */ #ifndef fabs #define fabs(x) ((double)((x) < 0? -(x): (x))) #endif #endif /*********************************************************************** * * Global Include Files * ***********************************************************************/ #include "machine.h" #include "encoder.h" #include "lame.h" #include "lame-analysis.h" #include "id3tag.h" /*********************************************************************** * * Global Definitions * ***********************************************************************/ #ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE (!FALSE) #endif #ifdef UINT_MAX # define MAX_U_32_NUM UINT_MAX #else # define MAX_U_32_NUM 0xFFFFFFFF #endif #ifndef PI # ifdef M_PI # define PI M_PI # else # define PI 3.14159265358979323846 # endif #endif #ifdef M_LN2 # define LOG2 M_LN2 #else # define LOG2 0.69314718055994530942 #endif #ifdef M_LN10 # define LOG10 M_LN10 #else # define LOG10 2.30258509299404568402 #endif #ifdef M_SQRT2 # define SQRT2 M_SQRT2 #else # define SQRT2 1.41421356237309504880 #endif #define HAN_SIZE 512 #define CRC16_POLYNOMIAL 0x8005 #define MAX_BITS 4095 /* "bit_stream.h" Definitions */ #define BUFFER_SIZE LAME_MAXMP3BUFFER #define Min(A, B) ((A) < (B) ? (A) : (B)) #define Max(A, B) ((A) > (B) ? (A) : (B)) /*********************************************************************** * * Global Type Definitions * ***********************************************************************/ /* "bit_stream.h" Type Definitions */ typedef struct bit_stream_struc { unsigned char *buf; /* bit stream buffer */ int buf_size; /* size of buffer (in number of bytes) */ int totbit; /* bit counter of bit stream */ int buf_byte_idx; /* pointer to top byte in buffer */ int buf_bit_idx; /* pointer to top bit of top byte in buffer */ /* format of file in rd mode (BINARY/ASCII) */ } Bit_stream_struc; #include "l3side.h" /* variables used for --nspsytune */ typedef struct { int use; /* indicates the use of exp_nspsytune */ int safejoint; /* safe joint stereo mode */ FLOAT last_en_subshort[4][9]; FLOAT last_attack_intensity[4][9]; FLOAT last_thm[4][SBMAX_s][3]; int last_attacks[4][3]; FLOAT pe_l[4],pe_s[4]; FLOAT pefirbuf[19]; FLOAT bass,alto,treble; } nsPsy_t; typedef struct { int sum; // what we have seen so far int seen; // how many frames we have seen in this chunk int want; // how many frames we want to collect into one chunk int pos; // actual position in our bag int size; // size of our bag int *bag; // pointer to our bag } VBR_seek_info_t; /** * ATH related stuff, if something new ATH related has to be added, * please plugg it here into the ATH_t struct */ typedef struct { int use_adjust; // do we want to use the auto adjustment yes/no FLOAT8 adjust; // lowering based on peak volume, 1 = no lowering FLOAT8 adjust_limit; // limit for dynamic ATH adjust FLOAT8 decay; // determined to lower x dB each second FLOAT8 l[SBMAX_l]; // ATH for sfbs in long blocks FLOAT8 s[SBMAX_s]; // ATH for sfbs in short blocks FLOAT8 cb[CBANDS]; // ATH for convolution bands } ATH_t; /* Guest structure, only temporarly here */ typedef enum { coding_MPEG_Layer_1 = 1, coding_MPEG_Layer_2 = 2, coding_MPEG_Layer_3 = 3, coding_MPEG_AAC = 4, coding_Ogg_Vorbis = 5, coding_MPEG_plus = 6 } coding_t; #define MAX_CHANNELS 2 typedef struct { unsigned long Class_ID; /* Class ID to recognize a resample_t object */ long double sample_freq_in; /* Input sample frequency in Hz */ long double sample_freq_out; /* requested Output sample frequency in Hz */ float lowpass_freq; /* lowpass frequency, this is the -6 dB point */ int scale_in; /* the resampling is actually done by scale_out: */ int scale_out; /* frequency is samplefreq_in * scale_out / scal */ int taps; /* number of taps for every FIR resample filter */ sample_t** fir; /* the FIR resample filters: fir [scale_out] [taps */ void* firfree; /* start address of the alloced memory for fir, */ unsigned char* src_step; sample_t* in_old [MAX_CHANNELS]; // uint64_t sample_count [MAX_CHANNELS]; unsigned fir_stepper [MAX_CHANNELS]; int inp_stepper [MAX_CHANNELS]; } resample_t; typedef struct { /******************************************************************** * internal variables NOT set by calling program, and should not be * * modified by the calling program * ********************************************************************/ /* * Some remarks to the Class_ID field: * The Class ID is an Identifier for a pointer to this struct. * It is very unlikely that a pointer to lame_global_flags has the same 32 bits * in it's structure (large and other special properties, for instance prime). * * To test that the structure is right and initialized, use: * if ( gfc -> Class_ID == LAME_ID ) ... * Other remark: * If you set a flag to 0 for uninit data and 1 for init data, the right test * should be "if (flag == 1)" and NOT "if (flag)". Unintended modification * of this element will be otherwise misinterpreted as an init. */ #define LAME_ID 0xFFF88E3B unsigned long Class_ID; struct { void (*msgf) (const char *format, va_list ap); void (*debugf)(const char *format, va_list ap); void (*errorf)(const char *format, va_list ap); } report; int lame_encode_frame_init; int iteration_init_init; int fill_buffer_resample_init; int psymodel_init; int padding; /* padding for the current frame? */ int mode_gr; /* granules per frame */ int channels_in; /* number of channels in the input data stream (PCM or decoded PCM) */ int channels_out; /* number of channels in the output data stream (not used for decoding) */ resample_t* resample_in; /* context for coding (PCM=>MP3) resampling */ resample_t* resample_out; /* context for decoding (MP3=>PCM) resampling */ long double samplefreq_in; long double samplefreq_out; #ifndef MFSIZE # define MFSIZE ( 3*1152 + ENCDELAY - MDCTDELAY ) #endif #ifdef KLEMM_44 sample_t* mfbuf [MAX_CHANNELS]; #else sample_t mfbuf [2] [MFSIZE]; #endif size_t frame_size; /* size of one frame in samples per channel */ lame_global_flags* gfp; /* needed as long as the frame encoding functions must access gfp (all needed information can be added to gfc) */ coding_t coding; /* MPEG Layer 1/2/3, Ogg Vorbis, MPEG AAC, ... */ unsigned long frame_count; /* Number of frames coded, 2^32 > 3 years */ int mf_samples_to_encode; int mf_size; float ampl; /* amplification at the end of the current chunk (1. = 0 dB) */ float last_ampl; /* amplification at the end of the last chunk (1. = 0 dB) */ int VBR_min_bitrate; /* min bitrate index */ int VBR_max_bitrate; /* max bitrate index */ float resample_ratio; /* input_samp_rate/output_samp_rate */ int bitrate_index; int samplerate_index; int mode_ext; /* lowpass and highpass filter control */ float lowpass1,lowpass2; /* normalized frequency bounds of passband */ float highpass1,highpass2; /* normalized frequency bounds of passband */ /* polyphase filter (filter_type=0) */ int lowpass_band; /* zero bands >= lowpass_band in the polyphase filterbank */ int highpass_band; /* zero bands <= highpass_band */ int lowpass_start_band; /* amplify bands between start */ int lowpass_end_band; /* and end for lowpass */ int highpass_start_band; /* amplify bands between start */ int highpass_end_band; /* and end for highpass */ int filter_type; /* 0=polyphase filter, 1= FIR filter 2=MDCT filter(bad)*/ int quantization; /* 0 = ISO formual, 1=best amplitude */ int noise_shaping; /* 0 = none 1 = ISO AAC model 2 = allow scalefac_select=1 */ int noise_shaping_amp; /* 0 = ISO model: amplify all distorted bands 1 = amplify only most distorted band 2 = amplify bands using? 3 = amplify bands using? */ int psymodel; /* 1 = gpsycho. 0 = none */ int noise_shaping_stop; /* 0 = stop at over=0, all scalefacs amplified or a scalefac has reached max value 1 = stop when all scalefacs amplified or a scalefac has reached max value 2 = stop when all scalefacs amplified */ int use_best_huffman; /* 0 = no. 1=outside loop 2=inside loop(slow) */ /* variables used by lame.c */ Bit_stream_struc bs; III_side_info_t l3_side; FLOAT8 ms_ratio[2]; /* used for padding */ int frac_SpF; int slot_lag; /* optional ID3 tags, used in id3tag.c */ struct id3tag_spec tag_spec; /* variables used by quantize.c */ int OldValue[2]; int CurrentStep; FLOAT8 decay; FLOAT8 masking_lower; char bv_scf[576]; int sfb21_extra; /* will be set in lame_init_params */ int is_mpeg1; /* 1 for MPEG-1, 0 for MPEG-2(.5) */ #ifndef KLEMM_44 /* variables used by util.c */ /* BPC = maximum number of filter convolution windows to precompute */ #define BPC 320 sample_t *inbuf_old [2]; sample_t *blackfilt [2*BPC+1]; FLOAT8 itime[2]; #endif int sideinfo_len; /* variables for newmdct.c */ FLOAT8 sb_sample[2][2][18][SBLIMIT]; FLOAT8 amp_lowpass[32]; FLOAT8 amp_highpass[32]; /* variables for bitstream.c */ /* mpeg1: buffer=511 bytes smallest frame: 96-38(sideinfo)=58 * max number of frames in reservoir: 8 * mpeg2: buffer=255 bytes. smallest frame: 24-23bytes=1 * with VBR, if you are encoding all silence, it is possible to * have 8kbs/24khz frames with 1byte of data each, which means we need * to buffer up to 255 headers! */ /* also, max_header_buf has to be a power of two */ #define MAX_HEADER_BUF 256 #define MAX_HEADER_LEN 40 /* max size of header is 38 */ struct { int write_timing; int ptr; char buf[MAX_HEADER_LEN]; } header[MAX_HEADER_BUF]; int h_ptr; int w_ptr; int ancillary_flag; /* variables for reservoir.c */ int ResvSize; /* in bits */ int ResvMax; /* in bits */ scalefac_struct scalefac_band; /* DATA FROM PSYMODEL.C */ /* The static variables "r", "phi_sav", "new", "old" and "oldest" have */ /* to be remembered for the unpredictability measure. For "r" and */ /* "phi_sav", the first index from the left is the channel select and */ /* the second index is the "age" of the data. */ FLOAT8 minval[CBANDS]; FLOAT8 nb_1[4][CBANDS], nb_2[4][CBANDS]; FLOAT8 s3_s[CBANDS][CBANDS]; FLOAT8 s3_l[CBANDS][CBANDS]; III_psy_xmin thm[4]; III_psy_xmin en[4]; /* unpredictability calculation */ int cw_upper_index; int cw_lower_index; FLOAT ax_sav[4][2][HBLKSIZE]; FLOAT bx_sav[4][2][HBLKSIZE]; FLOAT rx_sav[4][2][HBLKSIZE]; FLOAT cw[HBLKSIZE]; /* fft and energy calculation */ FLOAT wsamp_L[2][BLKSIZE]; FLOAT energy[HBLKSIZE]; FLOAT wsamp_S[2][3][BLKSIZE_s]; FLOAT energy_s[3][HBLKSIZE_s]; FLOAT tot_ener[4]; /* fft.c */ FLOAT window[BLKSIZE], window_s[BLKSIZE_s/2]; /* Scale Factor Bands */ FLOAT8 w1_l[SBMAX_l], w2_l[SBMAX_l]; FLOAT8 w1_s[SBMAX_s], w2_s[SBMAX_s]; FLOAT8 mld_l[SBMAX_l],mld_s[SBMAX_s]; int bu_l[SBMAX_l],bo_l[SBMAX_l] ; int bu_s[SBMAX_s],bo_s[SBMAX_s] ; int npart_l,npart_s; int npart_l_orig,npart_s_orig; int s3ind[CBANDS][2]; int s3ind_s[CBANDS][2]; FLOAT8 SNR_s[CBANDS]; int numlines_s[CBANDS]; int numlines_l[CBANDS]; /* frame analyzer */ FLOAT energy_save[4][HBLKSIZE]; FLOAT8 pe_save[4]; FLOAT8 ers_save[4]; /* simple statistics */ int bitrate_stereoMode_Hist [16] [4+1]; /* ratios */ FLOAT8 pe[4]; FLOAT8 ms_ratio_s_old,ms_ratio_l_old; FLOAT8 ms_ener_ratio_old; /* block type */ int blocktype_old[2]; /* used by the frame analyzer */ plotting_data *pinfo; /* CPU features */ struct { unsigned int i387 : 1; /* FPU is a normal Intel CPU */ unsigned int MMX : 1; /* Pentium MMX, Pentium II...IV, K6, K6-2, K6-III, Athlon */ unsigned int AMD_3DNow : 1; /* K6-2, K6-III, Athlon */ unsigned int SIMD : 1; /* Pentium III, Pentium 4 */ unsigned int SIMD2 : 1; /* Pentium 4, K8 */ } CPU_features; /* functions to replace with CPU feature optimized versions in takehiro.c */ int (*choose_table)(const int *ix, const int *end, int *s); nsPsy_t nsPsy; /* variables used for --nspsytune */ unsigned crcvalue; VBR_seek_info_t VBR_seek_table; // used for Xing VBR header ATH_t *ATH; // all ATH related stuff } lame_internal_flags; /*********************************************************************** * * Global Function Prototype Declarations * ***********************************************************************/ void freegfc(lame_internal_flags *gfc); extern int BitrateIndex(int, int,int); extern int FindNearestBitrate(int,int,int); extern int map2MP3Frequency(int freq); extern int SmpFrqIndex(int, int*); extern FLOAT8 ATHformula(FLOAT8 f,lame_global_flags *gfp); extern FLOAT8 freq2bark(FLOAT8 freq); extern FLOAT8 freq2cbw(FLOAT8 freq); extern void freorder(int scalefac_band[],FLOAT8 ix_orig[576]); void disable_FPE(void); extern void getframebits(lame_global_flags *gfp, int *bitsPerFrame, int *mean_bits); void fill_buffer(lame_global_flags *gfp, sample_t *mfbuf[2], sample_t *in_buffer[2], int nsamples, int *n_in, int *n_out); int fill_buffer_resample ( lame_global_flags *gfp, sample_t* outbuf, int desired_len, sample_t* inbuf, int len, int* num_used, int channels ); extern int has_i387 ( void ); extern int has_MMX ( void ); extern int has_3DNow ( void ); extern int has_SIMD ( void ); extern int has_SIMD2 ( void ); extern void updateStats (lame_internal_flags *gfc); /*********************************************************************** * * Macros about Message Printing and Exit * ***********************************************************************/ extern void lame_errorf(const lame_internal_flags *gfc, const char *, ...); extern void lame_debugf(const lame_internal_flags *gfc, const char *, ...); extern void lame_msgf (const lame_internal_flags *gfc, const char *, ...); #define DEBUGF lame_debugf #define ERRORF lame_errorf #define MSGF lame_msgf int select_kth_int(int b[], int N, int k); #endif /* LAME_UTIL_H */