new function list_deep_free
[swftools.git] / lib / lame / util.h
1 /*
2  *      lame utility library include 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 #ifndef LAME_UTIL_H
23 #define LAME_UTIL_H
24
25 /***********************************************************************
26 *
27 *  Global Include Files
28 *
29 ***********************************************************************/
30 #include "machine.h"
31 #include "encoder.h"
32 #include "lame.h"
33 #include "lame_global_flags.h"
34 #include "lame-analysis.h"
35 #include "id3tag.h"
36
37 /***********************************************************************
38 *
39 *  Global Definitions
40 *
41 ***********************************************************************/
42
43 #ifndef FALSE
44 #define         FALSE                   0
45 #endif
46
47 #ifndef TRUE
48 #define         TRUE                    (!FALSE)
49 #endif
50
51 #ifdef UINT_MAX
52 # define         MAX_U_32_NUM            UINT_MAX
53 #else
54 # define         MAX_U_32_NUM            0xFFFFFFFF
55 #endif
56
57 #ifndef PI
58 # ifdef M_PI
59 #  define       PI                      M_PI
60 # else
61 #  define       PI                      3.14159265358979323846
62 # endif
63 #endif
64
65
66 #ifdef M_LN2
67 # define        LOG2                    M_LN2
68 #else
69 # define        LOG2                    0.69314718055994530942
70 #endif
71
72 #ifdef M_LN10
73 # define        LOG10                   M_LN10
74 #else
75 # define        LOG10                   2.30258509299404568402
76 #endif
77
78
79 #ifdef M_SQRT2
80 # define        SQRT2                   M_SQRT2
81 #else
82 # define        SQRT2                   1.41421356237309504880
83 #endif
84
85
86 #define         HAN_SIZE                512
87 #define         CRC16_POLYNOMIAL        0x8005
88 #define MAX_BITS 4095
89
90 /* "bit_stream.h" Definitions */
91 #define         BUFFER_SIZE     LAME_MAXMP3BUFFER 
92
93 #define         Min(A, B)       ((A) < (B) ? (A) : (B))
94 #define         Max(A, B)       ((A) > (B) ? (A) : (B))
95
96
97
98
99
100 /***********************************************************************
101 *
102 *  Global Type Definitions
103 *
104 ***********************************************************************/
105
106
107
108 /* "bit_stream.h" Type Definitions */
109
110 typedef struct  bit_stream_struc {
111     unsigned char *buf;         /* bit stream buffer */
112     int         buf_size;       /* size of buffer (in number of bytes) */
113     int         totbit;         /* bit counter of bit stream */
114     int         buf_byte_idx;   /* pointer to top byte in buffer */
115     int         buf_bit_idx;    /* pointer to top bit of top byte in buffer */
116     
117     /* format of file in rd mode (BINARY/ASCII) */
118 } Bit_stream_struc;
119
120 #include "l3side.h"
121
122
123 /* variables used for --nspsytune */
124 typedef struct {
125   int   use; /* indicates the use of exp_nspsytune */
126   int   safejoint; /* safe joint stereo mode */
127   FLOAT last_en_subshort[4][9];
128   FLOAT last_attack_intensity[4][9];
129   FLOAT last_thm[4][SBMAX_s][3];
130   int   last_attacks[4][3];
131   FLOAT pe_l[4],pe_s[4];
132   FLOAT pefirbuf[19];
133   FLOAT bass,alto,treble,sfb21;
134 } nsPsy_t;
135
136 /* variables used for --alt-preset */
137 typedef struct {
138
139   // indicates the use of alt-preset
140   int     use;
141
142   // short block tuning
143   int     attackthre;
144   int     attackthre_s;
145
146   // adjustment to joint stereo
147   FLOAT8  ms_maskadjust;
148
149   // adjustments to quantization selection
150   int     quantcomp_current;          // current quant_compare mode we are using
151   FLOAT8  quantcomp_adjust_rh_tot;    // adjustments for tot_noise with vbr-old
152   FLOAT8  quantcomp_adjust_rh_max;    // adjustments for max_noise with vbr-old
153   FLOAT8  quantcomp_adjust_mtrh;      // adjustments for calc_scalefac "c" with vbr-mtrh
154   int     quantcomp_type_s;           // quantization comparison to switch to on non-normal blocks
155   int     quantcomp_alt_type;          // third quantization comparison to use for special cases
156                                        // such as high athadjust values, or long blocks, etc
157
158   // tunings reliant upon athadjust
159   FLOAT8  athadjust_max_val;           // maximum value of athadjust before limit is applied
160   FLOAT8  athadjust_switch_level;      // level of athadjust at which to apply tunings at
161                                        // x <= 0 == never switch, x >= 1 == always switch
162   FLOAT8  athadjust_msfix;             // msfix adjustment based on athadjust
163   int     athadjust_safe_noiseshaping; // if 0, noise shaping 2 will not be used no matter what
164                                        // the noise shaping type would normally be set to
165   FLOAT8  athadjust_safe_noiseshaping_thre; // value which max_pow_alt must be greater than
166                                             // for noise shaping 2 to be used "safely"                                                     
167   FLOAT8  athadjust_safe_athaasensitivity; // used for second determination if it is safe to switch
168                                               // to noise shaping 2
169 } presetTune_t;
170
171 typedef struct 
172 {
173     int sum;    // what we have seen so far
174     int seen;   // how many frames we have seen in this chunk
175     int want;   // how many frames we want to collect into one chunk
176     int pos;    // actual position in our bag
177     int size;   // size of our bag
178     int *bag;   // pointer to our bag
179 } VBR_seek_info_t;
180
181
182 /**
183  *  ATH related stuff, if something new ATH related has to be added,
184  *  please plugg it here into the ATH_t struct
185  */
186 typedef struct
187 {
188     int     use_adjust;     // method for the auto adjustment 
189     FLOAT8  adjust;         // lowering based on peak volume, 1 = no lowering
190     FLOAT8  adjust_limit;   // limit for dynamic ATH adjust
191     FLOAT8  decay;          // determined to lower x dB each second
192     FLOAT8  floor;          // lowest ATH value
193     FLOAT8  l[SBMAX_l];     // ATH for sfbs in long blocks
194     FLOAT8  s[SBMAX_s];     // ATH for sfbs in short blocks
195     FLOAT8  cb[CBANDS];     // ATH for convolution bands
196 } ATH_t;
197
198 /**
199  *  VBR related stuff
200  */
201 typedef struct
202 {
203     int     quality;
204     FLOAT8  mask_adjust;    // the dbQ stuff
205     int     smooth;         // 0=no, 1=peaks, 2=+-4
206     int     bitpressure;    // strategy for bitpressure situations
207     FLOAT8  scratch[192];
208 } VBR_t;
209
210 /**
211  *  PSY Model related stuff
212  */
213 typedef struct
214 {
215     int     tonalityPatch;      // temporaly needed by VBR
216     FLOAT   cwlimit;
217     FLOAT8  prvTonRed[CBANDS];
218 } PSY_t; 
219
220
221 /* Guest structure, only temporarly here */
222
223 typedef enum {
224     coding_MPEG_Layer_1 = 1,
225     coding_MPEG_Layer_2 = 2,
226     coding_MPEG_Layer_3 = 3,
227     coding_MPEG_AAC     = 4,
228     coding_Ogg_Vorbis   = 5,
229     coding_MPEG_plus    = 6
230 } coding_t;
231
232 #define MAX_CHANNELS  2
233
234 typedef struct {
235     unsigned long  Class_ID;        /* Class ID to recognize a resample_t
236                                        object */
237     FLOAT8   sample_freq_in;  /* Input sample frequency in Hz */
238     FLOAT8   sample_freq_out; /* requested Output sample frequency in Hz */
239     FLOAT8   lowpass_freq;    /* lowpass frequency, this is the -6 dB
240                                        point */
241     int            scale_in;        /* the resampling is actually done by
242                                        scale_out: */
243     int            scale_out;       /* frequency is
244                                          samplefreq_in * scale_out / scal */
245     int            taps;            /* number of taps for every FIR resample
246                                        filter */
247
248     sample_t**     fir;             /* the FIR resample filters:
249                                          fir [scale_out] [taps */
250     void*          firfree;         /* start address of the alloced memory for
251                                        fir, */
252     unsigned char* src_step;
253     sample_t*      in_old       [MAX_CHANNELS];
254     //    uint64_t       sample_count [MAX_CHANNELS];
255     unsigned       fir_stepper  [MAX_CHANNELS];
256     int            inp_stepper  [MAX_CHANNELS];
257
258 } resample_t;
259
260
261 struct lame_internal_flags {
262
263   /********************************************************************
264    * internal variables NOT set by calling program, and should not be *
265    * modified by the calling program                                  *
266    ********************************************************************/
267   
268   /*  
269    * Some remarks to the Class_ID field:
270    * The Class ID is an Identifier for a pointer to this struct.
271    * It is very unlikely that a pointer to lame_global_flags has the same 32 bits 
272    * in it's structure (large and other special properties, for instance prime).
273    *
274    * To test that the structure is right and initialized, use:
275    *     if ( gfc -> Class_ID == LAME_ID ) ...
276    * Other remark:
277    *     If you set a flag to 0 for uninit data and 1 for init data, the right test
278    *     should be "if (flag == 1)" and NOT "if (flag)". Unintended modification
279    *     of this element will be otherwise misinterpreted as an init.
280    */
281   
282   #define  LAME_ID   0xFFF88E3B
283   unsigned long Class_ID;
284
285   struct {
286     void (*msgf)  (const char *format, va_list ap);
287     void (*debugf)(const char *format, va_list ap);
288     void (*errorf)(const char *format, va_list ap);
289   } report;
290   
291   int lame_encode_frame_init;     
292   int iteration_init_init;
293   int fill_buffer_resample_init;
294   int psymodel_init;
295
296   int padding;                  /* padding for the current frame? */
297   int mode_gr;                    /* granules per frame */
298   int          channels_in;     /* number of channels in the input data stream (PCM or decoded PCM) */
299   int          channels_out;  /* number of channels in the output data stream (not used for decoding) */
300   resample_t*  resample_in;   /* context for coding (PCM=>MP3) resampling */
301   resample_t*  resample_out;    /* context for decoding (MP3=>PCM) resampling */
302   FLOAT8  samplefreq_in;
303   FLOAT8  samplefreq_out;
304   uint16_t nMusicCRC;
305
306 #ifndef  MFSIZE
307 # define MFSIZE  ( 3*1152 + ENCDELAY - MDCTDELAY )
308 #endif
309 #ifdef  KLEMM_44
310   sample_t*    mfbuf [MAX_CHANNELS];
311 #else
312   sample_t     mfbuf [2] [MFSIZE];
313 #endif
314   size_t       frame_size;    /* size of one frame in samples per channel */
315   lame_global_flags* gfp;     /* needed as long as the frame encoding functions must access gfp (all needed information can be added to gfc) */
316   coding_t     coding;        /* MPEG Layer 1/2/3, Ogg Vorbis, MPEG AAC, ... */
317   unsigned long frame_count;  /* Number of frames coded, 2^32 > 3 years */
318   int          mf_samples_to_encode;
319   int          mf_size;
320   FLOAT8       ampl;      /* amplification at the end of the current chunk (1. = 0 dB) */
321   FLOAT8       last_ampl;         /* amplification at the end of the last chunk    (1. = 0 dB) */
322   int VBR_min_bitrate;            /* min bitrate index */
323   int VBR_max_bitrate;            /* max bitrate index */
324   FLOAT resample_ratio;           /* input_samp_rate/output_samp_rate */
325   int bitrate_index;
326   int samplerate_index;
327   int mode_ext;
328
329
330   /* lowpass and highpass filter control */
331   FLOAT8 lowpass1,lowpass2;        /* normalized frequency bounds of passband */
332   FLOAT8 highpass1,highpass2;      /* normalized frequency bounds of passband */
333                                   
334   /* polyphase filter (filter_type=0)  */
335   int lowpass_band;          /* zero bands >= lowpass_band in the polyphase filterbank */
336   int highpass_band;         /* zero bands <= highpass_band */
337   int lowpass_start_band;    /* amplify bands between start */
338   int lowpass_end_band;      /* and end for lowpass */
339   int highpass_start_band;   /* amplify bands between start */
340   int highpass_end_band;     /* and end for highpass */
341
342
343   int filter_type;          /* 0=polyphase filter, 1= FIR filter 2=MDCT filter(bad)*/
344   int quantization;         /* 0 = ISO formual,  1=best amplitude */
345   int noise_shaping;        /* 0 = none 
346                                1 = ISO AAC model
347                                2 = allow scalefac_select=1  
348                              */
349
350   int noise_shaping_amp;    /*  0 = ISO model: amplify all distorted bands
351                                 1 = amplify within 50% of max (on db scale)
352                                 2 = amplify only most distorted band
353                                 3 = amplify only most distorted band and
354                                     use pseudo half step
355                              */
356
357   int psymodel;             /* 1 = gpsycho. 0 = none */
358   int noise_shaping_stop;   /* 0 = stop at over=0, all scalefacs amplified or
359                                    a scalefac has reached max value
360                                1 = stop when all scalefacs amplified or        
361                                    a scalefac has reached max value
362                                2 = stop when all scalefacs amplified 
363                             */
364
365   int use_best_huffman;     /* 0 = no.  1=outside loop  2=inside loop(slow) */
366
367
368
369
370   /* variables used by lame.c */
371   Bit_stream_struc   bs;
372   III_side_info_t l3_side;
373   FLOAT8 ms_ratio[2];
374   /* used for padding */
375   int frac_SpF;
376   int slot_lag;
377
378
379   /* optional ID3 tags, used in id3tag.c  */
380   struct id3tag_spec tag_spec;
381
382
383   /* variables used by quantize.c */
384   int OldValue[2];
385   int CurrentStep;
386   FLOAT8 decay;
387   FLOAT8 masking_lower;
388
389   char bv_scf[576];
390   
391   int sfb21_extra; /* will be set in lame_init_params */
392   
393   int is_mpeg1; /* 1 for MPEG-1, 0 for MPEG-2(.5) */
394
395 #ifndef KLEMM_44
396   /* variables used by util.c */
397   /* BPC = maximum number of filter convolution windows to precompute */
398 #define BPC 320
399   sample_t *inbuf_old [2];
400   sample_t *blackfilt [2*BPC+1];
401   FLOAT8 itime[2];
402 #endif
403   int sideinfo_len;
404
405   /* variables for newmdct.c */
406   FLOAT8 sb_sample[2][2][18][SBLIMIT];
407   FLOAT8 amp_lowpass[32];
408   FLOAT8 amp_highpass[32];
409
410   /* variables for bitstream.c */
411   /* mpeg1: buffer=511 bytes  smallest frame: 96-38(sideinfo)=58
412    * max number of frames in reservoir:  8 
413    * mpeg2: buffer=255 bytes.  smallest frame: 24-23bytes=1
414    * with VBR, if you are encoding all silence, it is possible to
415    * have 8kbs/24khz frames with 1byte of data each, which means we need
416    * to buffer up to 255 headers! */
417   /* also, max_header_buf has to be a power of two */
418 #define MAX_HEADER_BUF 256
419 #define MAX_HEADER_LEN 40 /* max size of header is 38 */
420   struct {
421     int write_timing;
422     int ptr;
423     char buf[MAX_HEADER_LEN];
424   } header[MAX_HEADER_BUF];
425
426   int h_ptr;
427   int w_ptr;
428   int ancillary_flag;
429   
430
431   /* variables for reservoir.c */
432   int ResvSize; /* in bits */
433   int ResvMax;  /* in bits */
434
435   
436   scalefac_struct scalefac_band;
437
438   /* DATA FROM PSYMODEL.C */
439 /* The static variables "r", "phi_sav", "new", "old" and "oldest" have    */
440 /* to be remembered for the unpredictability measure.  For "r" and        */
441 /* "phi_sav", the first index from the left is the channel select and     */
442 /* the second index is the "age" of the data.                             */
443   FLOAT8        minval[CBANDS];
444   FLOAT8        nb_1[4][CBANDS], nb_2[4][CBANDS];
445   FLOAT8        nb_s1[4][CBANDS], nb_s2[4][CBANDS];
446   FLOAT8  *s3_ss;
447   FLOAT8  *s3_ll;
448
449   III_psy_xmin thm[4];
450   III_psy_xmin en[4];
451   
452   /* unpredictability calculation
453    */
454   int cw_upper_index;
455   int cw_lower_index;
456   FLOAT ax_sav[4][2][HBLKSIZE];
457   FLOAT bx_sav[4][2][HBLKSIZE];
458   FLOAT rx_sav[4][2][HBLKSIZE];
459   FLOAT cw[HBLKSIZE];
460
461   /* fft and energy calculation    */
462   FLOAT wsamp_L[2][BLKSIZE];
463   FLOAT energy[HBLKSIZE];
464   FLOAT wsamp_S[2][3][BLKSIZE_s];
465   FLOAT energy_s[3][HBLKSIZE_s];
466   FLOAT tot_ener[4];
467
468
469   /* loudness calculation (for adaptive threshold of hearing) */
470   FLOAT loudness_sq[2][2];  /* loudness^2 approx. per granule and channel */
471   FLOAT loudness_sq_save[2];/* account for granule delay of L3psycho_anal */
472
473   /* factor for tuning the (sample power) point below which adaptive threshold
474      of hearing adjustment occurs 
475    */
476   FLOAT athaa_sensitivity_p;
477
478  
479   /* fft.c    */
480   FLOAT window[BLKSIZE], window_s[BLKSIZE_s/2];
481   
482   
483   /* Scale Factor Bands    */
484   III_scalefac_t pseudohalf;
485   FLOAT8        w1_l[SBMAX_l], w2_l[SBMAX_l];
486   FLOAT8        w1_s[SBMAX_s], w2_s[SBMAX_s];
487   FLOAT8 mld_l[SBMAX_l],mld_s[SBMAX_s];
488   int   bu_l[SBMAX_l],bo_l[SBMAX_l] ;
489   int   bu_s[SBMAX_s],bo_s[SBMAX_s] ;
490   int   npart_l,npart_s;
491   int   npart_l_orig,npart_s_orig;
492   
493   int   s3ind[CBANDS][2];
494   int   s3ind_s[CBANDS][2];
495   FLOAT8 SNR_s[CBANDS];
496
497   int   numlines_s[CBANDS];
498   int   numlines_l[CBANDS];
499   
500   
501   /* frame analyzer    */
502   FLOAT energy_save[4][HBLKSIZE];
503   FLOAT8 pe_save[4];
504   FLOAT8 ers_save[4];
505   
506   /* simple statistics */
507   int   bitrate_stereoMode_Hist [16] [4+1];
508
509   /* ratios  */
510   FLOAT8 pe[4];
511   FLOAT8 ms_ratio_s_old,ms_ratio_l_old;
512   FLOAT8 ms_ener_ratio_old;
513
514   /* block type */
515   int   blocktype_old[2];
516
517   /* used by the frame analyzer */
518   plotting_data *pinfo;
519
520   /* CPU features */
521   struct {
522     unsigned int  i387      : 1; /* FPU is a normal Intel CPU */
523     unsigned int  MMX       : 1; /* Pentium MMX, Pentium II...IV, K6, K6-2,
524                                     K6-III, Athlon */
525     unsigned int  AMD_3DNow : 1; /* K6-2, K6-III, Athlon      */
526     unsigned int  SIMD      : 1; /* Pentium III, Pentium 4    */
527     unsigned int  SIMD2     : 1; /* Pentium 4, K8             */
528   } CPU_features;
529    
530   /* functions to replace with CPU feature optimized versions in takehiro.c */
531   int (*choose_table)(const int *ix, const int *end, int *s);
532   
533   void (*fft_fht)(FLOAT *, int);
534
535   nsPsy_t nsPsy;  /* variables used for --nspsytune */
536   presetTune_t presetTune;  /* variables used for --alt-preset */
537   
538   unsigned crcvalue;
539   
540   VBR_seek_info_t VBR_seek_table; // used for Xing VBR header
541   
542   ATH_t *ATH;   // all ATH related stuff
543   VBR_t *VBR;
544   PSY_t *PSY;
545
546   int nogap_total;
547   int nogap_current;  
548 };
549
550
551
552  
553
554 /***********************************************************************
555 *
556 *  Global Function Prototype Declarations
557 *
558 ***********************************************************************/
559 void                  freegfc(lame_internal_flags * const gfc);
560 extern int            BitrateIndex(int, int,int);
561 extern int            FindNearestBitrate(int,int,int);
562 extern int            map2MP3Frequency(int freq);
563 extern int            SmpFrqIndex(int, int* const);
564 extern FLOAT8         ATHformula(FLOAT8 f,lame_global_flags *gfp);
565 extern FLOAT8         freq2bark(FLOAT8 freq);
566 extern FLOAT8         freq2cbw(FLOAT8 freq);
567 extern void freorder(int scalefac_band[],FLOAT8 ix_orig[576]);
568 void disable_FPE(void);
569
570 extern void 
571 getframebits( const lame_global_flags *gfp, int *bitsPerFrame, int *mean_bits);
572
573 void fill_buffer(lame_global_flags *gfp,
574                  sample_t *mfbuf[2],
575                  sample_t *in_buffer[2],
576                  int nsamples, int *n_in, int *n_out);
577
578 int  fill_buffer_resample (
579         lame_global_flags *gfp,
580         sample_t*  outbuf,
581         int        desired_len,
582         sample_t*  inbuf,
583         int        len,
584         int*       num_used,
585         int        channels );
586
587
588 extern int  has_i387  ( void );
589 extern int  has_MMX   ( void );
590 extern int  has_3DNow ( void );
591 extern int  has_SIMD  ( void );
592 extern int  has_SIMD2 ( void );
593
594 extern void updateStats (lame_internal_flags * const gfc);
595
596
597
598 /***********************************************************************
599 *
600 *  Macros about Message Printing and Exit
601 *
602 ***********************************************************************/
603 extern void lame_errorf(const lame_internal_flags *gfc, const char *, ...);
604 extern void lame_debugf(const lame_internal_flags *gfc, const char *, ...);
605 extern void lame_msgf  (const lame_internal_flags *gfc, const char *, ...);
606 #define DEBUGF  lame_debugf
607 #define ERRORF  lame_errorf
608 #define MSGF    lame_msgf
609
610
611 int select_kth_int(int b[], int N, int k);
612
613
614
615 #endif /* LAME_UTIL_H */