added checking for freetype.
[swftools.git] / lib / lame / encoder.c
1 /*
2  *      LAME MP3 encoding engine
3  *
4  *      Copyright (c) 1999 Mark Taylor
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: encoder.c,v 1.1 2002/04/28 17:30:18 kramm Exp $ */
23
24 #include "config_static.h"
25
26 #include <assert.h>
27
28 #include "lame.h"
29 #include "util.h"
30 #include "newmdct.h"
31 #include "psymodel.h"
32 #include "quantize.h"
33 #include "quantize_pvt.h"
34 #include "bitstream.h"
35 #include "VbrTag.h"
36 #include "vbrquantize.h"
37
38 #ifdef WITH_DMALLOC
39 #include <dmalloc.h>
40 #endif
41
42
43 /*
44  * auto-adjust of ATH, useful for low volume
45  * Gabriel Bouvigne 3 feb 2001
46  *
47  * modifies some values in
48  *   gfp->internal_flags->ATH
49  *   (gfc->ATH)
50  */
51 void
52 adjust_ATH( lame_global_flags* const  gfp,
53             FLOAT8              tot_ener[2][4] )
54 {
55     lame_internal_flags* const  gfc = gfp->internal_flags;
56     int gr, channel;
57     FLOAT max_pow, max_pow_alt;
58     FLOAT8 max_val;
59
60     if (gfc->ATH->use_adjust == 0) {
61         gfc->ATH->adjust = 1.0; /* no adjustment */
62         return;
63     }
64     
65     switch( gfp->athaa_loudapprox ) {
66     case 1:
67                                 /* flat approximation for loudness (squared) */
68         max_pow = 0;
69         for ( gr = 0; gr < gfc->mode_gr; ++gr ) 
70             for ( channel = 0; channel < gfc->channels_out; ++channel ) 
71                 max_pow = Max( max_pow, tot_ener[gr][channel] );
72         max_pow *= 0.25/ 5.6e13; /* scale to 0..1 (5.6e13), and tune (0.25) */
73         break;
74     
75     case 2:                     /* jd - 2001 mar 12, 27, jun 30 */
76     {                           /* loudness based on equal loudness curve; */
77                                 /* use granule with maximum combined loudness*/
78         FLOAT gr2_max;
79         max_pow = gfc->loudness_sq[0][0];
80         if( gfc->channels_out == 2 ) {
81             max_pow += gfc->loudness_sq[0][1];
82             gr2_max = gfc->loudness_sq[1][0] + gfc->loudness_sq[1][1];
83         } else {
84             gr2_max = gfc->loudness_sq[1][0];
85             max_pow += max_pow;
86             gr2_max += gr2_max;
87         }
88         if( gfc->mode_gr == 2 ) {
89             max_pow = Max( max_pow, gr2_max );
90         }
91         max_pow *= 0.5;         /* max_pow approaches 1.0 for full band noise*/
92         break;
93     }
94
95     default:                    /* jd - 2001 mar 27, 31, jun 30 */
96                                 /* no adaptive threshold */
97         max_pow = 1.0 / gfc->athaa_sensitivity_p;
98         break;
99     }
100
101                                 /* jd - 2001 mar 31, jun 30 */
102                                 /* user tuning of ATH adjustment region */
103     max_pow_alt = max_pow;
104     max_pow *= gfc->athaa_sensitivity_p;
105     if (gfc->presetTune.use)
106         max_pow_alt *= pow( 10.0, gfc->presetTune.athadjust_safe_athaasensitivity / -10.0 );
107
108     /*  adjust ATH depending on range of maximum value
109      */
110     switch ( gfc->ATH->use_adjust ) {
111
112     case  1:
113         max_val = sqrt( max_pow ); /* GB's original code requires a maximum */
114         max_val *= 32768;          /*  sample or loudness value up to 32768 */
115
116                                 /* by Gabriel Bouvigne */
117         if      (0.5 < max_val / 32768) {       /* value above 50 % */
118                 gfc->ATH->adjust = 1.0;         /* do not reduce ATH */
119         }
120         else if (0.3 < max_val / 32768) {       /* value above 30 % */
121                 gfc->ATH->adjust *= 0.955;      /* reduce by ~0.2 dB */
122                 if (gfc->ATH->adjust < 0.3)     /* but ~5 dB in maximum */
123                     gfc->ATH->adjust = 0.3;            
124         }
125         else {                                  /* value below 30 % */
126                 gfc->ATH->adjust *= 0.93;       /* reduce by ~0.3 dB */
127                 if (gfc->ATH->adjust < 0.01)    /* but 20 dB in maximum */
128                     gfc->ATH->adjust = 0.01;
129         }
130         break;
131
132     case  2:   
133         max_val = Min( max_pow, 1.0 ) * 32768; /* adapt for RH's adjust */
134
135       {                         /* by Robert Hegemann */
136         /*  this code reduces slowly the ATH (speed of 12 dB per second)
137          */
138         FLOAT8 
139         //x = Max (640, 320*(int)(max_val/320));
140         x = Max (32, 32*(int)(max_val/32));
141         x = x/32768;
142         gfc->ATH->adjust *= gfc->ATH->decay;
143         if (gfc->ATH->adjust < x)       /* but not more than f(x) dB */
144             gfc->ATH->adjust = x;
145       }
146         break;
147
148     case  3:
149       {                         /* jd - 2001 feb27, mar12,20, jun30, jul22 */
150                                 /* continuous curves based on approximation */
151                                 /* to GB's original values. */
152         FLOAT8 adj_lim_new;
153                                 /* For an increase in approximate loudness, */
154                                 /* set ATH adjust to adjust_limit immediately*/
155                                 /* after a delay of one frame. */
156                                 /* For a loudness decrease, reduce ATH adjust*/
157                                 /* towards adjust_limit gradually. */
158                                 /* max_pow is a loudness squared or a power. */
159         if( max_pow > 0.03125) { /* ((1 - 0.000625)/ 31.98) from curve below */
160             if( gfc->ATH->adjust >= 1.0) {
161                 gfc->ATH->adjust = 1.0;
162                 if (gfc->presetTune.use) {
163                         if (max_pow_alt > gfc->presetTune.athadjust_safe_noiseshaping_thre)
164                               gfc->presetTune.athadjust_safe_noiseshaping = 1;
165                         else
166                               gfc->presetTune.athadjust_safe_noiseshaping = 0;
167                 }
168             } else {
169                                 /* preceding frame has lower ATH adjust; */
170                                 /* ascend only to the preceding adjust_limit */
171                                 /* in case there is leading low volume */
172                 if( gfc->ATH->adjust < gfc->ATH->adjust_limit) {
173                     gfc->ATH->adjust = gfc->ATH->adjust_limit;
174                     if (gfc->presetTune.use) {
175                         if (max_pow_alt > gfc->presetTune.athadjust_safe_noiseshaping_thre)
176                             gfc->presetTune.athadjust_safe_noiseshaping = 1;
177                         else
178                             gfc->presetTune.athadjust_safe_noiseshaping = 0;
179                     }
180                 }
181             }
182             gfc->ATH->adjust_limit = 1.0;
183         } else {                /* adjustment curve */
184                                 /* about 32 dB maximum adjust (0.000625) */
185             adj_lim_new = 31.98 * max_pow + 0.000625;
186             if( gfc->ATH->adjust >= adj_lim_new) { /* descend gradually */
187                 gfc->ATH->adjust *= adj_lim_new * 0.075 + 0.925;
188                 if( gfc->ATH->adjust < adj_lim_new) { /* stop descent */
189                     gfc->ATH->adjust = adj_lim_new;
190                 }
191             } else {            /* ascend */
192                 if( gfc->ATH->adjust_limit >= adj_lim_new) {
193                     gfc->ATH->adjust = adj_lim_new;
194                 } else {        /* preceding frame has lower ATH adjust; */
195                                 /* ascend only to the preceding adjust_limit */
196                     if( gfc->ATH->adjust < gfc->ATH->adjust_limit) {
197                         gfc->ATH->adjust = gfc->ATH->adjust_limit;
198                     }
199                 }
200             }
201             gfc->ATH->adjust_limit = adj_lim_new;
202         }
203       }
204         break;
205         
206     default:
207         gfc->ATH->adjust = 1.0; /* no adjustment */
208         break;
209     }   /* switch */
210 }
211
212 /************************************************************************
213 *
214 * encodeframe()           Layer 3
215 *
216 * encode a single frame
217 *
218 ************************************************************************
219 lame_encode_frame()
220
221
222                        gr 0            gr 1
223 inbuf:           |--------------|---------------|-------------|
224 MDCT output:  |--------------|---------------|-------------|
225
226 FFT's                    <---------1024---------->
227                                          <---------1024-------->
228
229
230
231     inbuf = buffer of PCM data size=MP3 framesize
232     encoder acts on inbuf[ch][0], but output is delayed by MDCTDELAY
233     so the MDCT coefficints are from inbuf[ch][-MDCTDELAY]
234
235     psy-model FFT has a 1 granule delay, so we feed it data for the 
236     next granule.
237     FFT is centered over granule:  224+576+224
238     So FFT starts at:   576-224-MDCTDELAY
239
240     MPEG2:  FFT ends at:  BLKSIZE+576-224-MDCTDELAY
241     MPEG1:  FFT ends at:  BLKSIZE+2*576-224-MDCTDELAY    (1904)
242
243     FFT starts at 576-224-MDCTDELAY (304)  = 576-FFTOFFSET
244
245 */
246
247 typedef FLOAT8 chgrdata[2][2];
248
249 int  lame_encode_mp3_frame (                            // Output
250         lame_global_flags* const  gfp,                  // Context
251         sample_t*                 inbuf_l,              // Input
252         sample_t*                 inbuf_r,              // Input
253         unsigned char*            mp3buf,               // Output
254         int                    mp3buf_size )            // Output
255 {
256 #ifdef macintosh /* PLL 14/04/2000 */
257   static FLOAT8 xr[2][2][576];
258   static int l3_enc[2][2][576];
259 #else
260   FLOAT8 xr[2][2][576];
261   int l3_enc[2][2][576];
262 #endif
263   int mp3count;
264   III_psy_ratio masking_LR[2][2];    /*LR masking & energy */
265   III_psy_ratio masking_MS[2][2]; /*MS masking & energy */
266   III_psy_ratio (*masking)[2][2];  /*pointer to selected maskings*/
267   III_scalefac_t scalefac[2][2];
268   const sample_t *inbuf[2];
269   lame_internal_flags *gfc=gfp->internal_flags;
270
271   FLOAT8 tot_ener[2][4];   
272   FLOAT8 ms_ener_ratio[2]={.5,.5};
273   chgrdata pe,pe_MS;
274   chgrdata *pe_use;
275
276   int ch,gr,mean_bits;
277   int bitsPerFrame;
278
279   int check_ms_stereo;
280   FLOAT8 ms_ratio_next = 0.;
281   FLOAT8 ms_ratio_prev = 0.;
282
283
284   memset((char *) masking_LR, 0, sizeof(masking_LR));
285   memset((char *) masking_MS, 0, sizeof(masking_MS));
286   memset((char *) scalefac, 0, sizeof(scalefac));
287   inbuf[0]=inbuf_l;
288   inbuf[1]=inbuf_r;
289
290   check_ms_stereo =  (gfp->mode == JOINT_STEREO);
291   gfc->mode_ext = MPG_MD_LR_LR;
292
293   if (gfc->lame_encode_frame_init==0 )  {
294     gfc->lame_encode_frame_init=1;
295     
296     /* padding method as described in 
297      * "MPEG-Layer3 / Bitstream Syntax and Decoding"
298      * by Martin Sieler, Ralph Sperschneider
299      *
300      * note: there is no padding for the very first frame
301      *
302      * Robert.Hegemann@gmx.de 2000-06-22
303      */
304         
305     gfc->frac_SpF = ((gfp->version+1)*72000L*gfp->brate) % gfp->out_samplerate;
306     gfc->slot_lag  = gfc->frac_SpF;
307     
308     /* check FFT will not use a negative starting offset */
309 #if 576 < FFTOFFSET
310 # error FFTOFFSET greater than 576: FFT uses a negative offset
311 #endif
312     /* check if we have enough data for FFT */
313     assert(gfc->mf_size>=(BLKSIZE+gfp->framesize-FFTOFFSET));
314     /* check if we have enough data for polyphase filterbank */
315     /* it needs 1152 samples + 286 samples ignored for one granule */
316     /*          1152+576+286 samples for two granules */
317     assert(gfc->mf_size>=(286+576*(1+gfc->mode_gr)));
318
319     /* prime the MDCT/polyphase filterbank with a short block */
320     { 
321       int i,j;
322       sample_t primebuff0[286+1152+576];
323       sample_t primebuff1[286+1152+576];
324       for (i=0, j=0; i<286+576*(1+gfc->mode_gr); ++i) {
325         if (i<576*gfc->mode_gr) {
326           primebuff0[i]=0;
327           if (gfc->channels_out==2) 
328             primebuff1[i]=0;
329         }else{
330           primebuff0[i]=inbuf[0][j];
331           if (gfc->channels_out==2) 
332             primebuff1[i]=inbuf[1][j];
333           ++j;
334         }
335       }
336       /* polyphase filtering / mdct */
337       for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
338         for ( ch = 0; ch < gfc->channels_out; ch++ ) {
339           gfc->l3_side.gr[gr].ch[ch].tt.block_type=SHORT_TYPE;
340         }
341       }
342       mdct_sub48(gfc, primebuff0, primebuff1, xr);
343     }
344     
345     iteration_init(gfp);
346     
347     /*  prepare for ATH auto adjustment:
348      *  we want to decrease the ATH by 12 dB per second
349      */ {
350         FLOAT8 frame_duration = 576. * gfc->mode_gr / gfp->out_samplerate;
351         gfc->ATH->decay = pow(10., -12./10. * frame_duration);
352         gfc->ATH->adjust = 0.01; /* minimum, for leading low loudness */
353         gfc->ATH->adjust_limit = 1.0; /* on lead, allow adjust up to maximum */
354     }
355   }
356
357
358   /********************** padding *****************************/
359   switch (gfp->padding_type) {
360   case PAD_NO:
361     gfc->padding = FALSE;
362     break;
363   case PAD_ALL:
364     gfc->padding = TRUE;
365     break;
366   case PAD_ADJUST:
367   default:
368     if (gfp->VBR!=vbr_off) {
369       gfc->padding = FALSE;
370     } else {
371       if (gfp->disable_reservoir) {
372         gfc->padding = FALSE;
373         /* if the user specified --nores, dont very gfc->padding either */
374         /* tiny changes in frac_SpF rounding will cause file differences */
375       }else{
376         /* padding method as described in 
377          * "MPEG-Layer3 / Bitstream Syntax and Decoding"
378          * by Martin Sieler, Ralph Sperschneider
379          *
380          * note: there is no padding for the very first frame
381          *
382          * Robert.Hegemann@gmx.de 2000-06-22
383          */
384
385         gfc->slot_lag -= gfc->frac_SpF;
386         if (gfc->slot_lag < 0) {
387           gfc->slot_lag += gfp->out_samplerate;
388           gfc->padding = TRUE;
389         } else {
390           gfc->padding = FALSE;
391         }
392       } /* reservoir enabled */
393     }
394   }
395
396
397   if (gfc->psymodel) {
398     /* psychoacoustic model
399      * psy model has a 1 granule (576) delay that we must compensate for
400      * (mt 6/99).
401      */
402     int ret;
403     const sample_t *bufp[2];  /* address of beginning of left & right granule */
404     int blocktype[2];
405
406     ms_ratio_prev=gfc->ms_ratio[gfc->mode_gr-1];
407     for (gr=0; gr < gfc->mode_gr ; gr++) {
408
409       for ( ch = 0; ch < gfc->channels_out; ch++ )
410         bufp[ch] = &inbuf[ch][576 + gr*576-FFTOFFSET];
411
412       if (gfc->nsPsy.use) {
413         ret=L3psycho_anal_ns( gfp, bufp, gr, 
414                               &gfc->ms_ratio[gr],&ms_ratio_next,
415                               masking_LR, masking_MS,
416                               pe[gr],pe_MS[gr],tot_ener[gr],blocktype);
417       } else {
418         ret=L3psycho_anal( gfp, bufp, gr, 
419                            &gfc->ms_ratio[gr],&ms_ratio_next,
420                            masking_LR, masking_MS,
421                            pe[gr],pe_MS[gr],tot_ener[gr],blocktype);
422       }
423       if (ret!=0) return -4;
424
425       for ( ch = 0; ch < gfc->channels_out; ch++ )
426         gfc->l3_side.gr[gr].ch[ch].tt.block_type=blocktype[ch];
427
428       if (check_ms_stereo) {
429           ms_ener_ratio[gr] = tot_ener[gr][2]+tot_ener[gr][3];
430           if (ms_ener_ratio[gr]>0)
431               ms_ener_ratio[gr] = tot_ener[gr][3]/ms_ener_ratio[gr];
432       }
433
434     }
435   }else{
436     for (gr=0; gr < gfc->mode_gr ; gr++)
437       for ( ch = 0; ch < gfc->channels_out; ch++ ) {
438         gfc->l3_side.gr[gr].ch[ch].tt.block_type=NORM_TYPE;
439         pe_MS[gr][ch]=pe[gr][ch]=700;
440       }
441   }
442
443
444
445   /* auto-adjust of ATH, useful for low volume */
446   adjust_ATH( gfp, tot_ener );
447
448
449
450   /* block type flags */
451   for( gr = 0; gr < gfc->mode_gr; gr++ ) {
452     for ( ch = 0; ch < gfc->channels_out; ch++ ) {
453       gr_info *cod_info = &gfc->l3_side.gr[gr].ch[ch].tt;
454       cod_info->mixed_block_flag = 0;     /* never used by this model */
455       if (cod_info->block_type == NORM_TYPE )
456         cod_info->window_switching_flag = 0;
457       else
458         cod_info->window_switching_flag = 1;
459     }
460   }
461
462
463   /* polyphase filtering / mdct */
464   mdct_sub48(gfc, inbuf[0], inbuf[1], xr);
465   /* re-order the short blocks, for more efficient encoding below */
466   for (gr = 0; gr < gfc->mode_gr; gr++) {
467     for (ch = 0; ch < gfc->channels_out; ch++) {
468       gr_info *cod_info = &gfc->l3_side.gr[gr].ch[ch].tt;
469       if (cod_info->block_type==SHORT_TYPE) {
470         freorder(gfc->scalefac_band.s,xr[gr][ch]);
471       }
472     }
473   }
474   
475
476   /* use m/s gfc->channels_out? */
477   if (check_ms_stereo) {
478     int gr0 = 0, gr1 = gfc->mode_gr-1;
479     /* make sure block type is the same in each channel */
480     check_ms_stereo =
481       (gfc->l3_side.gr[gr0].ch[0].tt.block_type==gfc->l3_side.gr[gr0].ch[1].tt.block_type) &&
482       (gfc->l3_side.gr[gr1].ch[0].tt.block_type==gfc->l3_side.gr[gr1].ch[1].tt.block_type);
483   }
484   
485   /* Here will be selected MS or LR coding of the 2 stereo channels */
486
487   assert (  gfc->mode_ext == MPG_MD_LR_LR );
488   gfc->mode_ext = MPG_MD_LR_LR;
489   
490   if (gfp->force_ms) {
491     gfc->mode_ext = MPG_MD_MS_LR;
492   } else if (check_ms_stereo) {
493       /* ms_ratio = is scaled, for historical reasons, to look like
494          a ratio of side_channel / total.  
495          0 = signal is 100% mono
496          .5 = L & R uncorrelated
497       */
498       
499       /* [0] and [1] are the results for the two granules in MPEG-1,
500        * in MPEG-2 it's only a faked averaging of the same value
501        * _prev is the value of the last granule of the previous frame
502        * _next is the value of the first granule of the next frame
503        */
504       FLOAT8  ms_ratio_ave1;
505       FLOAT8  ms_ratio_ave2;
506       FLOAT8  threshold1    = 0.35;
507       FLOAT8  threshold2    = 0.45;
508
509       /* take an average */
510       if (gfc->mode_gr==1) {
511           /* MPEG2 - no second granule */
512           ms_ratio_ave1 = 0.33 * ( gfc->ms_ratio[0] + ms_ratio_prev + ms_ratio_next );
513           ms_ratio_ave2 = gfc->ms_ratio[0];
514       }else{
515           ms_ratio_ave1 = 0.25 * ( gfc->ms_ratio[0] + gfc->ms_ratio[1] + ms_ratio_prev + ms_ratio_next );
516           ms_ratio_ave2 = 0.50 * ( gfc->ms_ratio[0] + gfc->ms_ratio[1] );
517       }
518       
519       if (gfp->mode_automs) {
520           if ( gfp->compression_ratio < 11.025 ) {
521               /* 11.025 => 1, 6.3 => 0 */
522               double thr = (gfp->compression_ratio - 6.3) / (11.025 - 6.3);
523               if (thr<0) thr=0;
524               threshold1   *= thr;
525               threshold2   *= thr;
526           }
527       }
528       
529       if ((ms_ratio_ave1 < threshold1  &&  ms_ratio_ave2 < threshold2) || gfc->nsPsy.use) {
530           int  sum_pe_MS = 0;
531           int  sum_pe_LR = 0;
532           for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
533               for ( ch = 0; ch < gfc->channels_out; ch++ ) {
534                   sum_pe_MS += pe_MS[gr][ch];
535                   sum_pe_LR += pe[gr][ch];
536               }
537           }
538           
539           /* based on PE: M/S coding would not use much more bits than L/R coding */
540           
541           if (sum_pe_MS <= 1.07 * sum_pe_LR && !gfc->nsPsy.use) gfc->mode_ext = MPG_MD_MS_LR;
542           if (sum_pe_MS <= 1.00 * sum_pe_LR &&  gfc->nsPsy.use) gfc->mode_ext = MPG_MD_MS_LR;
543       }
544   }
545
546
547 #if defined(HAVE_GTK)
548   /* copy data for MP3 frame analyzer */
549   if (gfp->analysis && gfc->pinfo != NULL) {
550     for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
551       for ( ch = 0; ch < gfc->channels_out; ch++ ) {
552         gfc->pinfo->ms_ratio[gr]=gfc->ms_ratio[gr];
553         gfc->pinfo->ms_ener_ratio[gr]=ms_ener_ratio[gr];
554         gfc->pinfo->blocktype[gr][ch]=
555           gfc->l3_side.gr[gr].ch[ch].tt.block_type;
556         memcpy(gfc->pinfo->xr[gr][ch],xr[gr][ch],sizeof(xr[gr][ch]));
557         /* in psymodel, LR and MS data was stored in pinfo.  
558            switch to MS data: */
559         if (gfc->mode_ext==MPG_MD_MS_LR) {
560           gfc->pinfo->pe[gr][ch]=gfc->pinfo->pe[gr][ch+2];
561           gfc->pinfo->ers[gr][ch]=gfc->pinfo->ers[gr][ch+2];
562           memcpy(gfc->pinfo->energy[gr][ch],gfc->pinfo->energy[gr][ch+2],
563                  sizeof(gfc->pinfo->energy[gr][ch]));
564         }
565       }
566     }
567   }
568 #endif
569
570
571
572
573   /* bit and noise allocation */
574   if (MPG_MD_MS_LR == gfc->mode_ext) {
575     masking = &masking_MS;    /* use MS masking */
576     pe_use = &pe_MS;
577   } else {
578     masking = &masking_LR;    /* use LR masking */
579     pe_use = &pe;
580   }
581
582
583   if (gfc->nsPsy.use && (gfp->VBR == vbr_off || gfp->VBR == vbr_abr)) {
584     static FLOAT fircoef[19] = {
585       -0.0207887,-0.0378413,-0.0432472,-0.031183,
586       7.79609e-18,0.0467745,0.10091,0.151365,
587       0.187098,0.2,0.187098,0.151365,
588       0.10091,0.0467745,7.79609e-18,-0.031183,
589       -0.0432472,-0.0378413,-0.0207887,
590     };
591     int i;
592     FLOAT8 f;
593
594     for(i=0;i<18;i++) gfc->nsPsy.pefirbuf[i] = gfc->nsPsy.pefirbuf[i+1];
595
596     i=0;
597     gfc->nsPsy.pefirbuf[18] = 0;
598     for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
599       for ( ch = 0; ch < gfc->channels_out; ch++ ) {
600         gfc->nsPsy.pefirbuf[18] += (*pe_use)[gr][ch];
601         i++;
602       }
603     }
604
605     gfc->nsPsy.pefirbuf[18] = gfc->nsPsy.pefirbuf[18] / i;
606     f = 0;
607     for(i=0;i<19;i++) f += gfc->nsPsy.pefirbuf[i] * fircoef[i];
608
609     for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
610       for ( ch = 0; ch < gfc->channels_out; ch++ ) {
611         (*pe_use)[gr][ch] *= 670 / f;
612       }
613     }
614   }
615
616   switch (gfp->VBR){ 
617   default:
618   case vbr_off:
619     iteration_loop( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
620     break;
621   case vbr_mt:
622     VBR_quantize( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
623     break;
624   case vbr_rh:
625   case vbr_mtrh:
626     VBR_iteration_loop( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
627     break;
628   case vbr_abr:
629     ABR_iteration_loop( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
630     break;
631   }
632
633   /*  write the frame to the bitstream  */
634   getframebits(gfp, &bitsPerFrame, &mean_bits);
635
636   format_bitstream( gfp, bitsPerFrame, l3_enc, scalefac);
637
638   /* copy mp3 bit buffer into array */
639   mp3count = copy_buffer(gfc,mp3buf,mp3buf_size,1);
640
641
642
643
644   if (gfp->bWriteVbrTag) AddVbrFrame(gfp);
645
646
647 #if defined(HAVE_GTK)
648   /* copy data for MP3 frame analyzer */
649   if (gfp->analysis && gfc->pinfo != NULL) {
650     int j;
651     for ( ch = 0; ch < gfc->channels_out; ch++ ) {
652       for ( j = 0; j < FFTOFFSET; j++ )
653         gfc->pinfo->pcmdata[ch][j] = gfc->pinfo->pcmdata[ch][j+gfp->framesize];
654       for ( j = FFTOFFSET; j < 1600; j++ ) {
655         gfc->pinfo->pcmdata[ch][j] = inbuf[ch][j-FFTOFFSET];
656       }
657     }
658     set_frame_pinfo (gfp, xr, *masking, l3_enc, scalefac);
659   }
660 #endif
661   
662   updateStats( gfc );
663
664   return mp3count;
665 }