new function list_deep_free
[swftools.git] / lib / lame / psymodel.c
1 /*
2  *      psymodel.c
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: psymodel.c,v 1.2 2006/02/09 16:56:23 kramm Exp $ */
23
24
25 /*
26 PSYCHO ACOUSTICS
27
28
29 This routine computes the psycho acoustics, delayed by
30 one granule.  
31
32 Input: buffer of PCM data (1024 samples).  
33
34 This window should be centered over the 576 sample granule window.
35 The routine will compute the psycho acoustics for
36 this granule, but return the psycho acoustics computed
37 for the *previous* granule.  This is because the block
38 type of the previous granule can only be determined
39 after we have computed the psycho acoustics for the following
40 granule.  
41
42 Output:  maskings and energies for each scalefactor band.
43 block type, PE, and some correlation measures.  
44 The PE is used by CBR modes to determine if extra bits
45 from the bit reservoir should be used.  The correlation
46 measures are used to determine mid/side or regular stereo.
47
48
49 Notation:
50
51 barks:  a non-linear frequency scale.  Mapping from frequency to
52         barks is given by freq2bark()
53
54 scalefactor bands: The spectrum (frequencies) are broken into 
55                    SBMAX "scalefactor bands".  Thes bands
56                    are determined by the MPEG ISO spec.  In
57                    the noise shaping/quantization code, we allocate
58                    bits among the partition bands to achieve the
59                    best possible quality
60
61 partition bands:   The spectrum is also broken into about
62                    64 "partition bands".  Each partition 
63                    band is about .34 barks wide.  There are about 2-5
64                    partition bands for each scalefactor band.
65
66 LAME computes all psycho acoustic information for each partition
67 band.  Then at the end of the computations, this information
68 is mapped to scalefactor bands.  The energy in each scalefactor
69 band is taken as the sum of the energy in all partition bands
70 which overlap the scalefactor band.  The maskings can be computed
71 in the same way (and thus represent the average masking in that band)
72 or by taking the minmum value multiplied by the number of
73 partition bands used (which represents a minimum masking in that band).
74
75
76 The general outline is as follows:
77
78
79 1. compute the energy in each partition band
80 2. compute the tonality in each partition band
81 3. compute the strength of each partion band "masker"
82 4. compute the masking (via the spreading function applied to each masker)
83 5. Modifications for mid/side masking.  
84
85 Each partition band is considiered a "masker".  The strength
86 of the i'th masker in band j is given by:
87
88     s3(bark(i)-bark(j))*strength(i)
89
90 The strength of the masker is a function of the energy and tonality.
91 The more tonal, the less masking.  LAME uses a simple linear formula
92 (controlled by NMT and TMN) which says the strength is given by the
93 energy divided by a linear function of the tonality.
94
95
96 s3() is the "spreading function".  It is given by a formula
97 determined via listening tests.  
98
99 The total masking in the j'th partition band is the sum over
100 all maskings i.  It is thus given by the convolution of
101 the strength with s3(), the "spreading function."
102
103 masking(j) = sum_over_i  s3(i-j)*strength(i)  = s3 o strength
104
105 where "o" = convolution operator.  s3 is given by a formula determined
106 via listening tests.  It is normalized so that s3 o 1 = 1.
107
108 Note: instead of a simple convolution, LAME also has the
109 option of using "additive masking"
110
111 The most critical part is step 2, computing the tonality of each
112 partition band.  LAME has two tonality estimators.  The first
113 is based on the ISO spec, and measures how predictiable the
114 signal is over time.  The more predictable, the more tonal.
115 The second measure is based on looking at the spectrum of
116 a single granule.  The more peaky the spectrum, the more
117 tonal.  By most indications, the latter approach is better.
118
119 Finally, in step 5, the maskings for the mid and side
120 channel are possibly increased.  Under certain circumstances,
121 noise in the mid & side channels is assumed to also
122 be masked by strong maskers in the L or R channels.
123
124
125 Other data computed by the psy-model:
126
127 ms_ratio        side-channel / mid-channel masking ratio (for previous granule)
128 ms_ratio_next   side-channel / mid-channel masking ratio for this granule
129
130 percep_entropy[2]     L and R values (prev granule) of PE - A measure of how 
131                       much pre-echo is in the previous granule
132 percep_entropy_MS[2]  mid and side channel values (prev granule) of percep_entropy
133 energy[4]             L,R,M,S energy in each channel, prev granule
134 blocktype_d[2]        block type to use for previous granule
135
136
137 */
138
139
140
141
142 #include <stdlib.h>
143 #include "config_static.h"
144
145 #include "util.h"
146 #include "encoder.h"
147 #include "psymodel.h"
148 #include "l3side.h"
149 #include <assert.h>
150 #include "tables.h"
151 #include "fft.h"
152
153 #ifdef WITH_DMALLOC
154 #include <dmalloc.h>
155 #endif
156
157 #define NSFIRLEN 21
158 #define rpelev 2
159 #define rpelev2 16
160 #define rpelev_s 2
161 #define rpelev2_s 16
162
163 /* size of each partition band, in barks: */
164 #define DELBARK .34
165
166
167 #if 1
168     /* AAC values, results in more masking over MP3 values */
169 # define TMN 18
170 # define NMT 6
171 #else
172     /* MP3 values */
173 # define TMN 29
174 # define NMT 6
175 #endif
176
177 #define NBPSY_l  (SBMAX_l)
178 #define NBPSY_s  (SBMAX_s)
179
180
181 #ifdef M_LN10
182 #define         LN_TO_LOG10             (M_LN10/10)
183 #else
184 #define         LN_TO_LOG10             0.2302585093
185 #endif
186
187 FLOAT
188 psycho_loudness_approx( FLOAT *energy, lame_global_flags *gfp );
189
190
191
192
193
194 /*
195    L3psycho_anal.  Compute psycho acoustics.
196
197    Data returned to the calling program must be delayed by one 
198    granule. 
199
200    This is done in two places.  
201    If we do not need to know the blocktype, the copying
202    can be done here at the top of the program: we copy the data for
203    the last granule (computed during the last call) before it is
204    overwritten with the new data.  It looks like this:
205   
206    0. static psymodel_data 
207    1. calling_program_data = psymodel_data
208    2. compute psymodel_data
209     
210    For data which needs to know the blocktype, the copying must be
211    done at the end of this loop, and the old values must be saved:
212    
213    0. static psymodel_data_old 
214    1. compute psymodel_data
215    2. compute possible block type of this granule
216    3. compute final block type of previous granule based on #2.
217    4. calling_program_data = psymodel_data_old
218    5. psymodel_data_old = psymodel_data
219 */
220 int L3psycho_anal( lame_global_flags * gfp,
221                     const sample_t *buffer[2], int gr_out, 
222                     FLOAT8 *ms_ratio,
223                     FLOAT8 *ms_ratio_next,
224                     III_psy_ratio masking_ratio[2][2],
225                     III_psy_ratio masking_MS_ratio[2][2],
226                     FLOAT8 percep_entropy[2],FLOAT8 percep_MS_entropy[2], 
227                     FLOAT8 energy[4],
228                     int blocktype_d[2])
229 {
230 /* to get a good cache performance, one has to think about
231  * the sequence, in which the variables are used.  
232  * (Note: these static variables have been moved to the gfc-> struct,
233  * and their order in memory is layed out in util.h)
234  */
235   lame_internal_flags *gfc=gfp->internal_flags;
236
237
238   /* fft and energy calculation   */
239   FLOAT (*wsamp_l)[BLKSIZE];
240   FLOAT (*wsamp_s)[3][BLKSIZE_s];
241
242   /* convolution   */
243   FLOAT8 eb[CBANDS];
244   FLOAT8 cb[CBANDS];
245   FLOAT8 thr[CBANDS];
246   
247   /* ratios    */
248   FLOAT8 ms_ratio_l=0,ms_ratio_s=0;
249
250   /* block type  */
251   int blocktype[2],uselongblock[2];
252   
253   /* usual variables like loop indices, etc..    */
254   int numchn, chn;
255   int   b, i, j, k;
256   int   sb,sblock;
257
258
259   if(gfc->psymodel_init==0) {
260       psymodel_init(gfp);
261       init_fft(gfc);
262       gfc->psymodel_init=1;
263       
264       for (chn = 0; chn < 4; ++chn )
265       for (b = 0; b < CBANDS; ++b ) 
266         gfc->nb_s1[chn][b] = gfc->nb_s2[chn][b] = 1.0;
267       
268   }
269   
270
271
272   
273   
274   numchn = gfc->channels_out;
275   /* chn=2 and 3 = Mid and Side channels */
276   if (gfp->mode == JOINT_STEREO) numchn=4;
277
278   for (chn=0; chn<numchn; chn++) {
279       for (i=0; i<numchn; ++i) {
280           energy[chn]=gfc->tot_ener[chn];
281       }
282   }
283   
284   for (chn=0; chn<numchn; chn++) {
285
286       /* there is a one granule delay.  Copy maskings computed last call
287        * into masking_ratio to return to calling program.
288        */
289       if (chn < 2) {    
290           /* LR maskings  */
291           percep_entropy            [chn]       = gfc -> pe  [chn]; 
292           masking_ratio    [gr_out] [chn]  .en  = gfc -> en  [chn];
293           masking_ratio    [gr_out] [chn]  .thm = gfc -> thm [chn];
294       } else {
295           /* MS maskings  */
296           percep_MS_entropy         [chn-2]     = gfc -> pe  [chn]; 
297           masking_MS_ratio [gr_out] [chn-2].en  = gfc -> en  [chn];
298           masking_MS_ratio [gr_out] [chn-2].thm = gfc -> thm [chn];
299       }
300       
301       
302
303     /**********************************************************************
304      *  compute FFTs
305      **********************************************************************/
306     wsamp_s = gfc->wsamp_S+(chn & 1);
307     wsamp_l = gfc->wsamp_L+(chn & 1);
308     if (chn<2) {    
309       fft_long ( gfc, *wsamp_l, chn, buffer);
310       fft_short( gfc, *wsamp_s, chn, buffer);
311     } 
312     /* FFT data for mid and side channel is derived from L & R */
313     if (chn == 2)
314       {
315         for (j = BLKSIZE-1; j >=0 ; --j)
316         {
317           FLOAT l = gfc->wsamp_L[0][j];
318           FLOAT r = gfc->wsamp_L[1][j];
319           gfc->wsamp_L[0][j] = (l+r)*(FLOAT)(SQRT2*0.5);
320           gfc->wsamp_L[1][j] = (l-r)*(FLOAT)(SQRT2*0.5);
321         }
322         for (b = 2; b >= 0; --b)
323         {
324           for (j = BLKSIZE_s-1; j >= 0 ; --j)
325           {
326             FLOAT l = gfc->wsamp_S[0][b][j];
327             FLOAT r = gfc->wsamp_S[1][b][j];
328             gfc->wsamp_S[0][b][j] = (l+r)*(FLOAT)(SQRT2*0.5);
329             gfc->wsamp_S[1][b][j] = (l-r)*(FLOAT)(SQRT2*0.5);
330           }
331         }
332       }
333
334
335     /**********************************************************************
336      *  compute energies
337      **********************************************************************/
338     
339     
340     
341     gfc->energy[0]  = (*wsamp_l)[0];
342     gfc->energy[0] *= gfc->energy[0];
343     
344     gfc->tot_ener[chn] = gfc->energy[0]; /* sum total energy at nearly no extra cost */
345     
346     for (j=BLKSIZE/2-1; j >= 0; --j)
347     {
348       FLOAT re = (*wsamp_l)[BLKSIZE/2-j];
349       FLOAT im = (*wsamp_l)[BLKSIZE/2+j];
350       gfc->energy[BLKSIZE/2-j] = (re * re + im * im) * (FLOAT)0.5;
351
352       if (BLKSIZE/2-j > 10)
353         gfc->tot_ener[chn] += gfc->energy[BLKSIZE/2-j];
354     }
355     for (b = 2; b >= 0; --b)
356     {
357       gfc->energy_s[b][0]  = (*wsamp_s)[b][0];
358       gfc->energy_s[b][0] *=  gfc->energy_s [b][0];
359       for (j=BLKSIZE_s/2-1; j >= 0; --j)
360       {
361         FLOAT re = (*wsamp_s)[b][BLKSIZE_s/2-j];
362         FLOAT im = (*wsamp_s)[b][BLKSIZE_s/2+j];
363         gfc->energy_s[b][BLKSIZE_s/2-j] = (re * re + im * im) * (FLOAT)0.5;
364       }
365     }
366
367 #if defined(HAVE_GTK)
368     if (gfp->analysis) {
369       for (j=0; j<HBLKSIZE ; j++) {
370         gfc->pinfo->energy[gr_out][chn][j]=gfc->energy_save[chn][j];
371         gfc->energy_save[chn][j]=gfc->energy[j];
372       }
373     }
374 #endif
375
376
377
378     /**********************************************************************
379      * compute loudness approximation (used for ATH auto-level adjustment) 
380      **********************************************************************/
381     if( gfp->athaa_loudapprox == 2 ) {
382       if( chn < 2 ) {           /* no loudness for mid and side channels */
383         gfc->loudness_sq[gr_out][chn] = gfc->loudness_sq_save[chn];
384         gfc->loudness_sq_save[chn]
385           = psycho_loudness_approx( gfc->energy, gfp);
386       }
387     }
388
389
390
391     /**********************************************************************
392      *    compute unpredicatability of first six spectral lines            * 
393      **********************************************************************/
394     for ( j = 0; j < gfc->cw_lower_index; j++ )
395       {  /* calculate unpredictability measure cw */
396         FLOAT an, a1, a2;
397         FLOAT bn, b1, b2;
398         FLOAT rn, r1, r2;
399         FLOAT numre, numim, den;
400
401         a2 = gfc-> ax_sav[chn][1][j];
402         b2 = gfc-> bx_sav[chn][1][j];
403         r2 = gfc-> rx_sav[chn][1][j];
404         a1 = gfc-> ax_sav[chn][1][j] = gfc-> ax_sav[chn][0][j];
405         b1 = gfc-> bx_sav[chn][1][j] = gfc-> bx_sav[chn][0][j];
406         r1 = gfc-> rx_sav[chn][1][j] = gfc-> rx_sav[chn][0][j];
407         an = gfc-> ax_sav[chn][0][j] = (*wsamp_l)[j];
408         bn = gfc-> bx_sav[chn][0][j] = j==0 ? (*wsamp_l)[0] : (*wsamp_l)[BLKSIZE-j];  
409         rn = gfc-> rx_sav[chn][0][j] = sqrt(gfc->energy[j]);
410
411         { /* square (x1,y1) */
412           if( r1 != 0 ) {
413             numre = (a1*b1);
414             numim = (a1*a1-b1*b1)*(FLOAT)0.5;
415             den = r1*r1;
416           } else {
417             numre = 1;
418             numim = 0;
419             den = 1;
420           }
421         }
422         
423         { /* multiply by (x2,-y2) */
424           if( r2 != 0 ) {
425             FLOAT tmp2 = (numim+numre)*(a2+b2)*(FLOAT)0.5;
426             FLOAT tmp1 = -a2*numre+tmp2;
427             numre =       -b2*numim+tmp2;
428             numim = tmp1;
429             den *= r2;
430           } else {
431             /* do nothing */
432           }
433         }
434         
435         { /* r-prime factor */
436           FLOAT tmp = (2*r1-r2)/den;
437           numre *= tmp;
438           numim *= tmp;
439         }
440         den=rn+fabs(2*r1-r2);
441         if( den != 0 ) {
442           numre = (an+bn)*(FLOAT)0.5-numre;
443           numim = (an-bn)*(FLOAT)0.5-numim;
444           den = sqrt(numre*numre+numim*numim)/den;
445         }
446         gfc->cw[j] = den;
447       }
448
449
450
451     /**********************************************************************
452      *     compute unpredicatibility of next 200 spectral lines            *
453      **********************************************************************/ 
454     for ( j = gfc->cw_lower_index; j < gfc->cw_upper_index; j += 4 )
455       {/* calculate unpredictability measure cw */
456         FLOAT rn, r1, r2;
457         FLOAT numre, numim, den;
458         
459         k = (j+2) / 4; 
460         
461         { /* square (x1,y1) */
462           r1 = gfc->energy_s[0][k];
463           if( r1 != 0 ) {
464             FLOAT a1 = (*wsamp_s)[0][k]; 
465             FLOAT b1 = (*wsamp_s)[0][BLKSIZE_s-k]; /* k is never 0 */
466             numre = (a1*b1);
467             numim = (a1*a1-b1*b1)*(FLOAT)0.5;
468             den = r1;
469             r1 = sqrt(r1);
470           } else {
471             numre = 1;
472             numim = 0;
473             den = 1;
474           }
475         }
476         
477         
478         { /* multiply by (x2,-y2) */
479           r2 = gfc->energy_s[2][k];
480           if( r2 != 0 ) {
481             FLOAT a2 = (*wsamp_s)[2][k]; 
482             FLOAT b2 = (*wsamp_s)[2][BLKSIZE_s-k];
483             
484             
485             FLOAT tmp2 = (numim+numre)*(a2+b2)*(FLOAT)0.5;
486             FLOAT tmp1 = -a2*numre+tmp2;
487             numre =       -b2*numim+tmp2;
488             numim = tmp1;
489             
490             r2 = sqrt(r2);
491             den *= r2;
492           } else {
493             /* do nothing */
494           }
495         }
496         
497         { /* r-prime factor */
498           FLOAT tmp = (2*r1-r2)/den;
499           numre *= tmp;
500           numim *= tmp;
501         }
502         
503         rn = sqrt(gfc->energy_s[1][k]);
504         den=rn+fabs(2*r1-r2);
505         if( den != 0 ) {
506           FLOAT an = (*wsamp_s)[1][k]; 
507           FLOAT bn = (*wsamp_s)[1][BLKSIZE_s-k];
508           numre = (an+bn)*(FLOAT)0.5-numre;
509           numim = (an-bn)*(FLOAT)0.5-numim;
510           den = sqrt(numre*numre+numim*numim)/den;
511         }
512         
513         gfc->cw[j+1] = gfc->cw[j+2] = gfc->cw[j+3] = gfc->cw[j] = den;
514       }
515     
516 #if 0
517     for ( j = 14; j < HBLKSIZE-4; j += 4 )
518       {/* calculate energy from short ffts */
519         FLOAT8 tot,ave;
520         k = (j+2) / 4; 
521         for (tot=0, sblock=0; sblock < 3; sblock++)
522           tot+=gfc->energy_s[sblock][k];
523         ave = gfc->energy[j+1]+ gfc->energy[j+2]+ gfc->energy[j+3]+ gfc->energy[j];
524         ave /= 4.;
525         gfc->energy[j+1] = gfc->energy[j+2] = gfc->energy[j+3] =  gfc->energy[j]=tot;
526       }
527 #endif
528     
529     /**********************************************************************
530      *    Calculate the energy and the unpredictability in the threshold   *
531      *    calculation partitions                                           *
532      **********************************************************************/
533
534     b = 0;
535     for (j = 0; j < gfc->cw_upper_index && gfc->numlines_l[b] && b<gfc->npart_l_orig; )
536       {
537         FLOAT8 ebb, cbb;
538
539         ebb = gfc->energy[j];
540         cbb = gfc->energy[j] * gfc->cw[j];
541         j++;
542
543         for (i = gfc->numlines_l[b] - 1; i > 0; i--)
544           {
545             ebb += gfc->energy[j];
546             cbb += gfc->energy[j] * gfc->cw[j];
547             j++;
548           }
549         eb[b] = ebb;
550         cb[b] = cbb;
551         b++;
552       }
553
554     for (; b < gfc->npart_l_orig; b++ )
555       {
556         FLOAT8 ebb = gfc->energy[j++];
557         assert(gfc->numlines_l[b]);
558         for (i = gfc->numlines_l[b] - 1; i > 0; i--)
559           {
560             ebb += gfc->energy[j++];
561           }
562         eb[b] = ebb;
563         cb[b] = ebb * 0.4;
564       }
565
566     /**********************************************************************
567      *      convolve the partitioned energy and unpredictability          *
568      *      with the spreading function, s3_l[b][k](packed into s3_ll)    *
569      ******************************************************************** */
570     gfc->pe[chn] = 0;           /*  calculate percetual entropy */
571     {
572       int kk = 0;
573       for ( b = 0;b < gfc->npart_l; b++ )
574         {
575           FLOAT8 tbb,ecb,ctb;
576
577           ecb = 0;
578           ctb = 0;
579
580           for ( k = gfc->s3ind[b][0]; k <= gfc->s3ind[b][1]; k++ )
581             {
582               ecb += gfc->s3_ll[kk] * eb[k];    /* sprdngf for Layer III */
583               ctb += gfc->s3_ll[kk] * cb[k];
584               kk++;
585             }
586
587           /* calculate the tonality of each threshold calculation partition 
588            * calculate the SNR in each threshold calculation partition 
589            * tonality = -0.299 - .43*log(ctb/ecb);
590            * tonality = 0:           use NMT   (lots of masking)
591            * tonality = 1:           use TMN   (little masking)
592            */
593
594 /* ISO values */
595 #define CONV1 (-.299)
596 #define CONV2 (-.43)
597
598           tbb = ecb;
599           if (tbb != 0)
600             {
601               tbb = ctb / tbb;
602               if (tbb <= exp((1-CONV1)/CONV2)) 
603                 { /* tonality near 1 */
604                   tbb = exp(-LN_TO_LOG10 * TMN);
605                 }
606               else if (tbb >= exp((0-CONV1)/CONV2)) 
607                 {/* tonality near 0 */
608                   tbb = exp(-LN_TO_LOG10 * NMT);
609                 }
610               else
611                 {
612                   /* convert to tonality index */
613                   /* tonality small:   tbb=1 */
614                   /* tonality large:   tbb=-.299 */
615                   tbb = CONV1 + CONV2*log(tbb);
616                   tbb = exp(-LN_TO_LOG10 * ( TMN*tbb + (1-tbb)*NMT) );
617                 }
618             }
619
620           /* at this point, tbb represents the amount the spreading function
621            * will be reduced.  The smaller the value, the less masking.
622            * minval[] = 1 (0db)     says just use tbb.
623            * minval[]= .01 (-20db)  says reduce spreading function by 
624            *                        at least 20db.  
625            */
626
627           tbb = Min(gfc->minval[b], tbb);
628           
629             /* stabilize tonality estimation */
630             if ( gfc->PSY->tonalityPatch ) {
631                 if ( b > 5 ) 
632                 {
633                     FLOAT8 const x = 1.8699422;
634                     FLOAT8 w = gfc->PSY->prvTonRed[b/2] * x;
635                     if (tbb > w) 
636                         tbb = w;
637                 }
638                 gfc->PSY->prvTonRed[b] = tbb;
639             }
640             
641           ecb *= tbb;
642
643           /* long block pre-echo control.   */
644           /* rpelev=2.0, rpelev2=16.0 */
645           /* note: all surges in PE are because of this pre-echo formula
646            * for thr[b].  If it this is not used, PE is always around 600
647            */
648           /* dont use long block pre-echo control if previous granule was 
649            * a short block.  This is to avoid the situation:   
650            * frame0:  quiet (very low masking)  
651            * frame1:  surge  (triggers short blocks)
652            * frame2:  regular frame.  looks like pre-echo when compared to 
653            *          frame0, but all pre-echo was in frame1.
654            */
655           /* chn=0,1   L and R channels
656              chn=2,3   S and M channels.  
657           */
658         
659             if (gfc->blocktype_old[chn>1 ? chn-2 : chn] == SHORT_TYPE )
660                 thr[b] = ecb; /* Min(ecb, rpelev*gfc->nb_1[chn][b]); */
661             else
662                 thr[b] = Min(ecb, Min(rpelev*gfc->nb_1[chn][b],rpelev2*gfc->nb_2[chn][b]) );
663                 
664           {
665             FLOAT8 thrpe;
666             thrpe = Max(thr[b],gfc->ATH->cb[b]);
667             /*
668               printf("%i thr=%e   ATH=%e  \n",b,thr[b],gfc->ATH->cb[b]);
669             */
670             if (thrpe < eb[b])
671               gfc->pe[chn] -= gfc->numlines_l[b] * log(thrpe / eb[b]);
672           }
673           
674             if ( gfp->VBR == vbr_rh || gfp->VBR == vbr_mtrh ) {
675                 thr[b] = Min(ecb, rpelev*gfc->nb_1[chn][b]);
676                 if (gfc->blocktype_old[chn>1 ? chn-2 : chn] != SHORT_TYPE )
677                     thr[b] = Min(thr[b], rpelev2*gfc->nb_2[chn][b]);
678                 thr[b] = Max( thr[b], 1e-37 );
679             }
680           
681           gfc->nb_2[chn][b] = gfc->nb_1[chn][b];
682           gfc->nb_1[chn][b] = ecb;
683         }
684     }
685
686     /*************************************************************** 
687      * determine the block type (window type) based on L & R channels
688      * 
689      ***************************************************************/
690     {  /* compute PE for all 4 channels */
691       FLOAT mn,mx,ma=0,mb=0,mc=0;
692       
693       for ( j = HBLKSIZE_s/2; j < HBLKSIZE_s; j ++)
694         {
695           ma += gfc->energy_s[0][j];
696           mb += gfc->energy_s[1][j];
697           mc += gfc->energy_s[2][j];
698         }
699       mn = Min(ma,mb);
700       mn = Min(mn,mc);
701       mx = Max(ma,mb);
702       mx = Max(mx,mc);
703       
704       /* bit allocation is based on pe.  */
705       if (mx>mn) {
706         FLOAT8 tmp = 400*log(mx/(1e-12+mn));
707         if (tmp>gfc->pe[chn]) gfc->pe[chn]=tmp;
708       }
709
710       /* block type is based just on L or R channel */      
711       if (chn<2) {
712         uselongblock[chn] = 1;
713         
714         /* tuned for t1.wav.  doesnt effect most other samples */
715         if (gfc->pe[chn] > 3000) 
716             uselongblock[chn]=0;
717         
718         if ( mx > 30*mn ) 
719           {/* big surge of energy - always use short blocks */
720             uselongblock[chn] = 0;
721           } 
722         else if ((mx > 10*mn) && (gfc->pe[chn] > 1000))
723           {/* medium surge, medium pe - use short blocks */
724             uselongblock[chn] = 0;
725           }
726         
727         /* disable short blocks */
728         if (gfp->short_blocks == short_block_dispensed)
729           uselongblock[chn]=1;
730         if (gfp->short_blocks == short_block_forced)
731           uselongblock[chn]=0;
732       }
733     }
734
735 #if defined(HAVE_GTK)
736     if (gfp->analysis) {
737       FLOAT mn,mx,ma=0,mb=0,mc=0;
738
739       for ( j = HBLKSIZE_s/2; j < HBLKSIZE_s; j ++)
740       {
741         ma += gfc->energy_s[0][j];
742         mb += gfc->energy_s[1][j];
743         mc += gfc->energy_s[2][j];
744       }
745       mn = Min(ma,mb);
746       mn = Min(mn,mc);
747       mx = Max(ma,mb);
748       mx = Max(mx,mc);
749
750       gfc->pinfo->ers[gr_out][chn]=gfc->ers_save[chn];
751       gfc->ers_save[chn]=(mx/(1e-12+mn));
752       gfc->pinfo->pe[gr_out][chn]=gfc->pe_save[chn];
753       gfc->pe_save[chn]=gfc->pe[chn];
754     }
755 #endif
756
757
758     /*************************************************************** 
759      * compute masking thresholds for both short and long blocks
760      ***************************************************************/
761     /* longblock threshold calculation (part 2) */
762     for ( sb = 0; sb < NBPSY_l; sb++ )
763       {
764         FLOAT8 enn = gfc->w1_l[sb] * eb[gfc->bu_l[sb]] + gfc->w2_l[sb] * eb[gfc->bo_l[sb]];
765         FLOAT8 thmm = gfc->w1_l[sb] *thr[gfc->bu_l[sb]] + gfc->w2_l[sb] * thr[gfc->bo_l[sb]];
766
767         for ( b = gfc->bu_l[sb]+1; b < gfc->bo_l[sb]; b++ )
768           {
769             enn  += eb[b];
770             thmm += thr[b];
771           }
772
773         gfc->en [chn].l[sb] = enn;
774         gfc->thm[chn].l[sb] = thmm;
775       }
776     
777
778     /* threshold calculation for short blocks */
779     for ( sblock = 0; sblock < 3; sblock++ )
780       {
781         j = 0;
782         for ( b = 0; b < gfc->npart_s_orig; b++ )
783           {
784             FLOAT ecb = gfc->energy_s[sblock][j++];
785             for (i = 1 ; i<gfc->numlines_s[b]; ++i)
786               {
787                 ecb += gfc->energy_s[sblock][j++];
788               }
789             eb[b] = ecb;
790           }
791         {
792           int kk = 0;
793           for ( b = 0; b < gfc->npart_s; b++ )
794             {
795               FLOAT8 ecb = 0;
796               for ( k = gfc->s3ind_s[b][0]; k <= gfc->s3ind_s[b][1]; k++ ) {
797                 ecb += gfc->s3_ss[kk++] * eb[k];
798               }
799               ecb *= gfc->SNR_s[b];
800
801 /* 2001-07-13 */
802         if ( gfp->VBR == vbr_off || gfp->VBR == vbr_abr ) {
803             /* this looks like a BUG to me. robert */
804             thr[b] = Max (1e-6, ecb);
805         }
806         else {
807             thr[b] = Min( ecb, rpelev_s  * gfc->nb_s1[chn][b] );
808             if (gfc->blocktype_old[chn>1 ? chn-2 : chn] == SHORT_TYPE ) {
809                 thr[b] = Min( thr[b], rpelev2_s * gfc->nb_s2[chn][b] );
810             }
811             thr[b] = Max( thr[b], 1e-37 );
812             gfc->nb_s2[chn][b] = gfc->nb_s1[chn][b];
813             gfc->nb_s1[chn][b] = ecb;
814         }
815         
816             }
817
818           for ( sb = 0; sb < NBPSY_s; sb++ )
819             {
820               FLOAT8 enn  = gfc->w1_s[sb] * eb[gfc->bu_s[sb]] + gfc->w2_s[sb] * eb[gfc->bo_s[sb]];
821               FLOAT8 thmm = gfc->w1_s[sb] *thr[gfc->bu_s[sb]] + gfc->w2_s[sb] * thr[gfc->bo_s[sb]];
822
823               for ( b = gfc->bu_s[sb]+1; b < gfc->bo_s[sb]; b++ ) {
824                 enn  += eb[b];
825                 thmm += thr[b];
826               }
827
828               gfc->en [chn].s[sb][sblock] = enn;
829               gfc->thm[chn].s[sb][sblock] = thmm;
830             }
831         }
832       }
833   } /* end loop over chn */
834
835
836
837   /*************************************************************** 
838    * compute M/S thresholds
839    ***************************************************************/
840   /* compute M/S thresholds from Johnston & Ferreira 1992 ICASSP paper */
841   if (gfp->mode == JOINT_STEREO) {
842     FLOAT8 rside,rmid,mld;
843     int chmid=2,chside=3; 
844     
845     for ( sb = 0; sb < NBPSY_l; sb++ ) {
846       /* use this fix if L & R masking differs by 2db or less */
847       /* if db = 10*log10(x2/x1) < 2 */
848       /* if (x2 < 1.58*x1) { */
849       if (gfc->thm[0].l[sb] <= 1.58*gfc->thm[1].l[sb]
850           && gfc->thm[1].l[sb] <= 1.58*gfc->thm[0].l[sb]) {
851
852         mld = gfc->mld_l[sb]*gfc->en[chside].l[sb];
853         rmid = Max(gfc->thm[chmid].l[sb], Min(gfc->thm[chside].l[sb],mld));
854
855         mld = gfc->mld_l[sb]*gfc->en[chmid].l[sb];
856         rside = Max(gfc->thm[chside].l[sb],Min(gfc->thm[chmid].l[sb],mld));
857
858         gfc->thm[chmid].l[sb]=rmid;
859         gfc->thm[chside].l[sb]=rside;
860       }
861     }
862     for ( sb = 0; sb < NBPSY_s; sb++ ) {
863       for ( sblock = 0; sblock < 3; sblock++ ) {
864         if (gfc->thm[0].s[sb][sblock] <= 1.58*gfc->thm[1].s[sb][sblock]
865             && gfc->thm[1].s[sb][sblock] <= 1.58*gfc->thm[0].s[sb][sblock]) {
866
867           mld = gfc->mld_s[sb]*gfc->en[chside].s[sb][sblock];
868           rmid = Max(gfc->thm[chmid].s[sb][sblock],Min(gfc->thm[chside].s[sb][sblock],mld));
869
870           mld = gfc->mld_s[sb]*gfc->en[chmid].s[sb][sblock];
871           rside = Max(gfc->thm[chside].s[sb][sblock],Min(gfc->thm[chmid].s[sb][sblock],mld));
872
873           gfc->thm[chmid].s[sb][sblock]=rmid;
874           gfc->thm[chside].s[sb][sblock]=rside;
875         }
876       }
877     }
878   }
879
880
881
882   /*************************************************************** 
883    * Adjust M/S maskings if user set "msfix"
884    ***************************************************************/
885   /* Naoki Shibata 2000 */
886   if (numchn == 4 && gfp->msfix!=0) {
887       FLOAT msfix = gfp->msfix;
888
889     for ( sb = 0; sb < NBPSY_l; sb++ )
890       {
891         FLOAT8 thmL,thmR,thmM,thmS,ath;
892         ath  = (gfc->ATH->cb[(gfc->bu_l[sb] + gfc->bo_l[sb])/2])*pow(10,-gfp->ATHlower/10.0);
893         thmL = Max(gfc->thm[0].l[sb],ath);
894         thmR = Max(gfc->thm[1].l[sb],ath);
895         thmM = Max(gfc->thm[2].l[sb],ath);
896         thmS = Max(gfc->thm[3].l[sb],ath);
897
898         if (thmL*msfix < (thmM+thmS)/2) {
899           FLOAT8 f = thmL*msfix / ((thmM+thmS)/2);
900           thmM *= f;
901           thmS *= f;
902         }
903         if (thmR*msfix < (thmM+thmS)/2) {
904           FLOAT8 f = thmR*msfix / ((thmM+thmS)/2);
905           thmM *= f;
906           thmS *= f;
907         }
908
909         gfc->thm[2].l[sb] = Min(thmM,gfc->thm[2].l[sb]);
910         gfc->thm[3].l[sb] = Min(thmS,gfc->thm[3].l[sb]);
911       }
912
913     for ( sb = 0; sb < NBPSY_s; sb++ ) {
914       for ( sblock = 0; sblock < 3; sblock++ ) {
915         FLOAT8 thmL,thmR,thmM,thmS,ath;
916         ath  = (gfc->ATH->cb[(gfc->bu_s[sb] + gfc->bo_s[sb])/2])*pow(10,-gfp->ATHlower/10.0);
917         thmL = Max(gfc->thm[0].s[sb][sblock],ath);
918         thmR = Max(gfc->thm[1].s[sb][sblock],ath);
919         thmM = Max(gfc->thm[2].s[sb][sblock],ath);
920         thmS = Max(gfc->thm[3].s[sb][sblock],ath);
921
922         if (thmL*msfix < (thmM+thmS)/2) {
923           FLOAT8 f = thmL*msfix / ((thmM+thmS)/2);
924           thmM *= f;
925           thmS *= f;
926         }
927         if (thmR*msfix < (thmM+thmS)/2) {
928           FLOAT8 f = thmR*msfix / ((thmM+thmS)/2);
929           thmM *= f;
930           thmS *= f;
931         }
932
933         gfc->thm[2].s[sb][sblock] = Min(gfc->thm[2].s[sb][sblock],thmM);
934         gfc->thm[3].s[sb][sblock] = Min(gfc->thm[3].s[sb][sblock],thmS);
935       }
936     }
937   }
938
939
940
941
942
943
944
945
946
947
948
949   if (gfp->mode == JOINT_STEREO)  {
950     /* determin ms_ratio from masking thresholds*/
951     /* use ms_stereo (ms_ratio < .35) if average thresh. diff < 5 db */
952     FLOAT8 db,x1,x2,sidetot=0,tot=0;
953     for (sb= NBPSY_l/4 ; sb< NBPSY_l; sb ++ ) {
954       x1 = Min(gfc->thm[0].l[sb],gfc->thm[1].l[sb]);
955       x2 = Max(gfc->thm[0].l[sb],gfc->thm[1].l[sb]);
956       /* thresholds difference in db */
957       if (x2 >= 1000*x1)  db=3;
958       else db = log10(x2/x1);  
959       /*  DEBUGF(gfc,"db = %f %e %e  \n",db,gfc->thm[0].l[sb],gfc->thm[1].l[sb]);*/
960       sidetot += db;
961       tot++;
962     }
963     ms_ratio_l= (sidetot/tot)*0.7; /* was .35*(sidetot/tot)/5.0*10 */
964     ms_ratio_l = Min(ms_ratio_l,0.5);
965     
966     sidetot=0; tot=0;
967     for ( sblock = 0; sblock < 3; sblock++ )
968       for ( sb = NBPSY_s/4; sb < NBPSY_s; sb++ ) {
969         x1 = Min(gfc->thm[0].s[sb][sblock],gfc->thm[1].s[sb][sblock]);
970         x2 = Max(gfc->thm[0].s[sb][sblock],gfc->thm[1].s[sb][sblock]);
971         /* thresholds difference in db */
972         if (x2 >= 1000*x1)  db=3;
973         else db = log10(x2/x1);  
974         sidetot += db;
975         tot++;
976       }
977     ms_ratio_s = (sidetot/tot)*0.7; /* was .35*(sidetot/tot)/5.0*10 */
978     ms_ratio_s = Min(ms_ratio_s,.5);
979   }
980
981   /*************************************************************** 
982    * determine final block type
983    ***************************************************************/
984
985   for (chn=0; chn<gfc->channels_out; chn++) {
986     blocktype[chn] = NORM_TYPE;
987   }
988
989
990   if (gfp->short_blocks == short_block_coupled) {
991       /* force both channels to use the same block type */
992       /* this is necessary if the frame is to be encoded in ms_stereo.  */
993       /* But even without ms_stereo, FhG  does this */
994       int bothlong= (uselongblock[0] && uselongblock[1]);
995       if (!bothlong) {
996         uselongblock[0]=0;
997         uselongblock[1]=0;
998       }
999   }
1000
1001   
1002   
1003   /* update the blocktype of the previous granule, since it depends on what
1004    * happend in this granule */
1005   for (chn=0; chn<gfc->channels_out; chn++) {
1006     if ( uselongblock[chn])
1007       {                         /* no attack : use long blocks */
1008         assert( gfc->blocktype_old[chn] != START_TYPE );
1009         switch( gfc->blocktype_old[chn] ) 
1010           {
1011           case NORM_TYPE:
1012           case STOP_TYPE:
1013             blocktype[chn] = NORM_TYPE;
1014             break;
1015           case SHORT_TYPE:
1016             blocktype[chn] = STOP_TYPE; 
1017             break;
1018           }
1019       } else   {
1020         /* attack : use short blocks */
1021         blocktype[chn] = SHORT_TYPE;
1022         if ( gfc->blocktype_old[chn] == NORM_TYPE ) {
1023           gfc->blocktype_old[chn] = START_TYPE;
1024         }
1025         if ( gfc->blocktype_old[chn] == STOP_TYPE ) {
1026           gfc->blocktype_old[chn] = SHORT_TYPE ;
1027         }
1028       }
1029     
1030     blocktype_d[chn] = gfc->blocktype_old[chn];  /* value returned to calling program */
1031     gfc->blocktype_old[chn] = blocktype[chn];    /* save for next call to l3psy_anal */
1032   }
1033   
1034   if (blocktype_d[0]==2 && blocktype_d[1]==2)
1035     *ms_ratio = gfc->ms_ratio_s_old;
1036   else
1037     *ms_ratio = gfc->ms_ratio_l_old;
1038
1039   gfc->ms_ratio_s_old = ms_ratio_s;
1040   gfc->ms_ratio_l_old = ms_ratio_l;
1041
1042   /* we dont know the block type of this frame yet - assume long */
1043   *ms_ratio_next = ms_ratio_l;
1044
1045   return 0;
1046 }
1047
1048 /* addition of simultaneous masking   Naoki Shibata 2000/7 */
1049 inline static FLOAT8 mask_add(FLOAT8 m1,FLOAT8 m2,int k,int b, lame_internal_flags * const gfc)
1050 {
1051   static const FLOAT8 table1[] = {
1052     3.3246 *3.3246 ,3.23837*3.23837,3.15437*3.15437,3.00412*3.00412,2.86103*2.86103,2.65407*2.65407,2.46209*2.46209,2.284  *2.284  ,
1053     2.11879*2.11879,1.96552*1.96552,1.82335*1.82335,1.69146*1.69146,1.56911*1.56911,1.46658*1.46658,1.37074*1.37074,1.31036*1.31036,
1054     1.25264*1.25264,1.20648*1.20648,1.16203*1.16203,1.12765*1.12765,1.09428*1.09428,1.0659 *1.0659 ,1.03826*1.03826,1.01895*1.01895,
1055     1
1056   };
1057
1058   static const FLOAT8 table2[] = {
1059     1.33352*1.33352,1.35879*1.35879,1.38454*1.38454,1.39497*1.39497,1.40548*1.40548,1.3537 *1.3537 ,1.30382*1.30382,1.22321*1.22321,
1060     1.14758*1.14758
1061   };
1062
1063   static const FLOAT8 table3[] = {
1064     2.35364*2.35364,2.29259*2.29259,2.23313*2.23313,2.12675*2.12675,2.02545*2.02545,1.87894*1.87894,1.74303*1.74303,1.61695*1.61695,
1065     1.49999*1.49999,1.39148*1.39148,1.29083*1.29083,1.19746*1.19746,1.11084*1.11084,1.03826*1.03826
1066   };
1067
1068
1069   int i;
1070   FLOAT8 m;
1071
1072   if (m1 == 0) return m2;
1073
1074   if (b < 0) b = -b;
1075
1076   i = 10*log10(m2 / m1)/10*16;
1077   m = 10*log10((m1+m2)/gfc->ATH->cb[k]);
1078
1079   if (i < 0) i = -i;
1080
1081   if (b <= 3) {  /* approximately, 1 bark = 3 partitions */
1082     if (i > 8) return m1+m2;
1083     return (m1+m2)*table2[i];
1084   }
1085
1086   if (m<15) {
1087     if (m > 0) {
1088       FLOAT8 f=1.0,r;
1089       if (i > 24) return m1+m2;
1090       if (i > 13) f = 1; else f = table3[i];
1091       r = (m-0)/15;
1092       return (m1+m2)*(table1[i]*r+f*(1-r));
1093     }
1094     if (i > 13) return m1+m2;
1095     return (m1+m2)*table3[i];
1096   }
1097
1098   if (i > 24) return m1+m2;
1099   return (m1+m2)*table1[i];
1100 }
1101
1102 int L3psycho_anal_ns( lame_global_flags * gfp,
1103                     const sample_t *buffer[2], int gr_out, 
1104                     FLOAT8 *ms_ratio,
1105                     FLOAT8 *ms_ratio_next,
1106                     III_psy_ratio masking_ratio[2][2],
1107                     III_psy_ratio masking_MS_ratio[2][2],
1108                     FLOAT8 percep_entropy[2],FLOAT8 percep_MS_entropy[2], 
1109                     FLOAT8 energy[4], 
1110                     int blocktype_d[2])
1111 {
1112 /* to get a good cache performance, one has to think about
1113  * the sequence, in which the variables are used.  
1114  * (Note: these static variables have been moved to the gfc-> struct,
1115  * and their order in memory is layed out in util.h)
1116  */
1117   lame_internal_flags *gfc=gfp->internal_flags;
1118
1119   /* fft and energy calculation   */
1120   FLOAT (*wsamp_l)[BLKSIZE];
1121   FLOAT (*wsamp_s)[3][BLKSIZE_s];
1122
1123   /* convolution   */
1124   FLOAT8 eb[CBANDS],eb2[CBANDS];
1125   FLOAT8 thr[CBANDS];
1126   
1127   FLOAT8 max[CBANDS],avg[CBANDS],tonality2[CBANDS];
1128
1129   /* ratios    */
1130   FLOAT8 ms_ratio_l=0,ms_ratio_s=0;
1131
1132   /* block type  */
1133   int blocktype[2],uselongblock[2];
1134   
1135   /* usual variables like loop indices, etc..    */
1136   int numchn, chn;
1137   int   b, i, j, k;
1138   int   sb,sblock;
1139
1140   /* variables used for --nspsytune */
1141   int ns_attacks[4];
1142   FLOAT ns_hpfsmpl[4][576+576/3+NSFIRLEN];
1143   FLOAT pe_l[4],pe_s[4];
1144   FLOAT pcfact;
1145
1146
1147   if(gfc->psymodel_init==0) {
1148     psymodel_init(gfp);
1149     init_fft(gfc);
1150     gfc->psymodel_init=1;
1151   }
1152
1153
1154   numchn = gfc->channels_out;
1155   /* chn=2 and 3 = Mid and Side channels */
1156   if (gfp->mode == JOINT_STEREO) numchn=4;
1157
1158   if (gfp->VBR==vbr_off) pcfact = gfc->ResvMax == 0 ? 0 : ((FLOAT)gfc->ResvSize)/gfc->ResvMax*0.5;
1159   else if (gfp->VBR == vbr_rh  ||  gfp->VBR == vbr_mtrh  ||  gfp->VBR == vbr_mt) {
1160     static const FLOAT8 pcQns[10]={1.0,1.0,1.0,0.8,0.6,0.5,0.4,0.3,0.2,0.1};
1161     pcfact = pcQns[gfp->VBR_q];
1162   } else pcfact = 1;
1163
1164   /**********************************************************************
1165    *  Apply HPF of fs/4 to the input signal.
1166    *  This is used for attack detection / handling.
1167    **********************************************************************/
1168
1169   {
1170     static const FLOAT fircoef[] = {
1171       -8.65163e-18,-0.00851586,-6.74764e-18, 0.0209036,
1172       -3.36639e-17,-0.0438162 ,-1.54175e-17, 0.0931738,
1173       -5.52212e-17,-0.313819  , 0.5        ,-0.313819,
1174       -5.52212e-17, 0.0931738 ,-1.54175e-17,-0.0438162,
1175       -3.36639e-17, 0.0209036 ,-6.74764e-18,-0.00851586,
1176       -8.65163e-18,
1177     };
1178
1179     for(chn=0;chn<gfc->channels_out;chn++)
1180       {
1181         FLOAT firbuf[576+576/3+NSFIRLEN];
1182
1183         /* apply high pass filter of fs/4 */
1184         
1185         for(i=-NSFIRLEN;i<576+576/3;i++)
1186           firbuf[i+NSFIRLEN] = buffer[chn][576-350+(i)];
1187
1188         for(i=0;i<576+576/3-NSFIRLEN;i++)
1189           {
1190             FLOAT sum = 0;
1191             for(j=0;j<NSFIRLEN;j++)
1192               sum += fircoef[j] * firbuf[i+j];
1193             ns_hpfsmpl[chn][i] = sum;
1194           }
1195         for(;i<576+576/3;i++)
1196           ns_hpfsmpl[chn][i] = 0;
1197       }
1198
1199     if (gfp->mode == JOINT_STEREO) {
1200       for(i=0;i<576+576/3;i++)
1201         {
1202           ns_hpfsmpl[2][i] = ns_hpfsmpl[0][i]+ns_hpfsmpl[1][i];
1203           ns_hpfsmpl[3][i] = ns_hpfsmpl[0][i]-ns_hpfsmpl[1][i];
1204         }
1205     }
1206   }
1207   
1208
1209
1210   /* there is a one granule delay.  Copy maskings computed last call
1211    * into masking_ratio to return to calling program.
1212    */
1213   for (chn=0; chn<numchn; chn++) {
1214       for (i=0; i<numchn; ++i) {
1215           energy[chn]=gfc->tot_ener[chn];
1216       }
1217   }
1218
1219
1220   for (chn=0; chn<numchn; chn++) {
1221     /* there is a one granule delay.  Copy maskings computed last call
1222      * into masking_ratio to return to calling program.
1223      */
1224     pe_l[chn] = gfc->nsPsy.pe_l[chn];
1225     pe_s[chn] = gfc->nsPsy.pe_s[chn];
1226
1227     if (chn < 2) {    
1228       /* LR maskings  */
1229       //percep_entropy            [chn]       = gfc -> pe  [chn]; 
1230       masking_ratio    [gr_out] [chn]  .en  = gfc -> en  [chn];
1231       masking_ratio    [gr_out] [chn]  .thm = gfc -> thm [chn];
1232     } else {
1233       /* MS maskings  */
1234       //percep_MS_entropy         [chn-2]     = gfc -> pe  [chn]; 
1235       masking_MS_ratio [gr_out] [chn-2].en  = gfc -> en  [chn];
1236       masking_MS_ratio [gr_out] [chn-2].thm = gfc -> thm [chn];
1237     }
1238   }
1239
1240   for (chn=0; chn<numchn; chn++) {
1241
1242     /**********************************************************************
1243      *  compute FFTs
1244      **********************************************************************/
1245
1246     wsamp_s = gfc->wsamp_S+(chn & 1);
1247     wsamp_l = gfc->wsamp_L+(chn & 1);
1248
1249     if (chn<2) {    
1250       fft_long ( gfc, *wsamp_l, chn, buffer);
1251       fft_short( gfc, *wsamp_s, chn, buffer);
1252     } 
1253
1254     /* FFT data for mid and side channel is derived from L & R */
1255
1256     if (chn == 2)
1257       {
1258         for (j = BLKSIZE-1; j >=0 ; --j)
1259           {
1260             FLOAT l = gfc->wsamp_L[0][j];
1261             FLOAT r = gfc->wsamp_L[1][j];
1262             gfc->wsamp_L[0][j] = (l+r)*(FLOAT)(SQRT2*0.5);
1263             gfc->wsamp_L[1][j] = (l-r)*(FLOAT)(SQRT2*0.5);
1264           }
1265         for (b = 2; b >= 0; --b)
1266           {
1267             for (j = BLKSIZE_s-1; j >= 0 ; --j)
1268               {
1269                 FLOAT l = gfc->wsamp_S[0][b][j];
1270                 FLOAT r = gfc->wsamp_S[1][b][j];
1271                 gfc->wsamp_S[0][b][j] = (l+r)*(FLOAT)(SQRT2*0.5);
1272                 gfc->wsamp_S[1][b][j] = (l-r)*(FLOAT)(SQRT2*0.5);
1273               }
1274           }
1275       }
1276
1277
1278     /**********************************************************************
1279      *  compute energies for each spectral line
1280      **********************************************************************/
1281     
1282     /* long block */
1283
1284     gfc->energy[0]  = (*wsamp_l)[0];
1285     gfc->energy[0] *= gfc->energy[0];
1286     
1287     gfc->tot_ener[chn] = gfc->energy[0]; /* sum total energy at nearly no extra cost */
1288     
1289     for (j=BLKSIZE/2-1; j >= 0; --j)
1290     {
1291       FLOAT re = (*wsamp_l)[BLKSIZE/2-j];
1292       FLOAT im = (*wsamp_l)[BLKSIZE/2+j];
1293       gfc->energy[BLKSIZE/2-j] = (re * re + im * im) * (FLOAT)0.5;
1294
1295       if (BLKSIZE/2-j > 10)
1296         gfc->tot_ener[chn] += gfc->energy[BLKSIZE/2-j];
1297     }
1298
1299
1300     /* short block */
1301
1302     for (b = 2; b >= 0; --b)
1303     {
1304       gfc->energy_s[b][0]  = (*wsamp_s)[b][0];
1305       gfc->energy_s[b][0] *=  gfc->energy_s [b][0];
1306       for (j=BLKSIZE_s/2-1; j >= 0; --j)
1307       {
1308         FLOAT re = (*wsamp_s)[b][BLKSIZE_s/2-j];
1309         FLOAT im = (*wsamp_s)[b][BLKSIZE_s/2+j];
1310         gfc->energy_s[b][BLKSIZE_s/2-j] = (re * re + im * im) * (FLOAT)0.5;
1311       }
1312     }
1313
1314
1315     /* output data for analysis */
1316
1317 #if defined(HAVE_GTK)
1318     if (gfp->analysis) {
1319       for (j=0; j<HBLKSIZE ; j++) {
1320         gfc->pinfo->energy[gr_out][chn][j]=gfc->energy_save[chn][j];
1321         gfc->energy_save[chn][j]=gfc->energy[j];
1322       }
1323     }
1324 #endif
1325     
1326
1327     /**********************************************************************
1328      * compute loudness approximation (used for ATH auto-level adjustment) 
1329      **********************************************************************/
1330     if( gfp->athaa_loudapprox == 2 ) {
1331       if( chn < 2 ) {           /* no loudness for mid and side channels */
1332         gfc->loudness_sq[gr_out][chn] = gfc->loudness_sq_save[chn];
1333         gfc->loudness_sq_save[chn]
1334           = psycho_loudness_approx( gfc->energy, gfp);
1335       }
1336     }
1337
1338
1339
1340     /**********************************************************************
1341      *    Calculate the energy and the tonality of each partition.
1342      **********************************************************************/
1343
1344     for (b=0, j=0; b<gfc->npart_l_orig; b++)
1345       {
1346         FLOAT8 ebb,m,a;
1347   
1348         ebb = gfc->energy[j];
1349         m = a = gfc->energy[j];
1350         j++;
1351   
1352         for (i = gfc->numlines_l[b] - 1; i > 0; i--)
1353           {
1354             FLOAT8 el = gfc->energy[j];
1355             ebb += gfc->energy[j];
1356             a += el;
1357             m = m < el ? el : m;
1358             j++;
1359           }
1360         eb[b] = ebb;
1361         max[b] = m;
1362         avg[b] = a / gfc->numlines_l[b];
1363       }
1364   
1365     j = 0;
1366     for (b=0; b < gfc->npart_l_orig; b++ )
1367       {
1368         int c1,c2;
1369         FLOAT8 m,a;
1370         tonality2[b] = 0;
1371         c1 = c2 = 0;
1372         m = a = 0;
1373         for(k=b-1;k<=b+1;k++)
1374           {
1375             if (k >= 0 && k < gfc->npart_l_orig) {
1376               c1++;
1377               c2 += gfc->numlines_l[k];
1378               a += avg[k];
1379               m = m < max[k] ? max[k] : m;
1380             }
1381           }
1382  
1383         a /= c1;
1384         tonality2[b] = a == 0 ? 0 : (m / a - 1)/(c2-1);
1385       }
1386
1387     for (b=0; b < gfc->npart_l_orig; b++ )
1388       {
1389 #if 0
1390         static FLOAT8 tab[20] =
1391         {  0,  1,  2,  2,  2,  2,  2,  6,9.3,9.3,9.3,9.3,9.3,9.3,9.3,9.3,9.3,9.3,9.3,9.3};
1392
1393         static int init = 1;
1394         if (init) {
1395           int j;
1396           for(j=0;j<20;j++) {
1397             tab[j] = pow(10.0,-tab[j]/10.0);
1398           }
1399           init = 0;
1400         }
1401 #else
1402         static FLOAT8 tab[20] = {
1403           1,0.79433,0.63096,0.63096,0.63096,0.63096,0.63096,0.25119,0.11749,0.11749,
1404           0.11749,0.11749,0.11749,0.11749,0.11749,0.11749,0.11749,0.11749,0.11749,0.11749
1405         };
1406 #endif
1407
1408         int t = 20*tonality2[b];
1409         if (t > 19) t = 19;
1410         eb2[b] = eb[b] * tab[t];
1411       }
1412
1413
1414     /**********************************************************************
1415      *      convolve the partitioned energy and unpredictability
1416      *      with the spreading function, s3_l[b][k]
1417      ******************************************************************** */
1418     {
1419     int kk = 0;
1420     for ( b = 0;b < gfc->npart_l; b++ )
1421       {
1422         FLOAT8 ecb;
1423
1424         /****   convolve the partitioned energy with the spreading function   ****/
1425
1426         ecb = 0;
1427
1428 #if 1
1429         for ( k = gfc->s3ind[b][0]; k <= gfc->s3ind[b][1]; k++ )
1430           {
1431             ecb = mask_add(ecb,gfc->s3_ll[kk++] * eb2[k],k,k-b,gfc);
1432           }
1433
1434         ecb *= 0.158489319246111; // pow(10,-0.8)
1435 #endif
1436
1437 #if 0
1438         for ( k = gfc->s3ind[b][0]; k <= gfc->s3ind[b][1]; k++ )
1439           {
1440             ecb += gfc->s3_ll[kk++] * eb2[k];
1441           }
1442
1443         ecb *= 0.223872113856834; // pow(10,-0.65);
1444 #endif
1445
1446         /****   long block pre-echo control   ****/
1447
1448         /* dont use long block pre-echo control if previous granule was 
1449          * a short block.  This is to avoid the situation:   
1450          * frame0:  quiet (very low masking)  
1451          * frame1:  surge  (triggers short blocks)
1452          * frame2:  regular frame.  looks like pre-echo when compared to 
1453          *          frame0, but all pre-echo was in frame1.
1454          */
1455
1456         /* chn=0,1   L and R channels
1457            chn=2,3   S and M channels.  
1458         */
1459
1460 #define NS_INTERP(x,y,r) (pow((x),(r))*pow((y),1-(r)))
1461
1462         if (gfc->blocktype_old[chn>1 ? chn-2 : chn] == SHORT_TYPE )
1463           thr[b] = ecb; /* Min(ecb, rpelev*gfc->nb_1[chn][b]); */
1464         else
1465           thr[b] = NS_INTERP(Min(ecb, Min(rpelev*gfc->nb_1[chn][b],rpelev2*gfc->nb_2[chn][b])),ecb,pcfact);
1466
1467         gfc->nb_2[chn][b] = gfc->nb_1[chn][b];
1468         gfc->nb_1[chn][b] = ecb;
1469       }
1470     }
1471
1472     /*************************************************************** 
1473      * determine the block type (window type)
1474      ***************************************************************/
1475
1476     {
1477       static int count=0;
1478       FLOAT en_subshort[12];
1479       FLOAT attack_intensity[12];
1480       int ns_uselongblock = 1;
1481
1482       /* calculate energies of each sub-shortblocks */
1483
1484       k = 0;
1485       for(i=0;i<12;i++)
1486         {
1487           en_subshort[i] = 0;
1488           for(j=0;j<576/9;j++)
1489             {
1490               en_subshort[i] += ns_hpfsmpl[chn][k] * ns_hpfsmpl[chn][k];
1491               k++;
1492             }
1493
1494           if (en_subshort[i] < 100) en_subshort[i] = 100;
1495         }
1496
1497       /* compare energies between sub-shortblocks */
1498
1499 #define NSATTACKTHRE 150
1500 #define NSATTACKTHRE_S 300
1501
1502       for(i=0;i<2;i++) {
1503         attack_intensity[i] = en_subshort[i] / gfc->nsPsy.last_en_subshort[chn][7+i];
1504       }
1505
1506       for(;i<12;i++) {
1507         attack_intensity[i] = en_subshort[i] / en_subshort[i-2];
1508       }
1509
1510       ns_attacks[0] = ns_attacks[1] = ns_attacks[2] = ns_attacks[3] = 0;
1511
1512       for(i=0;i<12;i++)
1513         {
1514           if (!ns_attacks[i/3] && attack_intensity[i] > (chn == 3 ? (gfc->presetTune.use ? gfc->presetTune.attackthre_s : NSATTACKTHRE_S)
1515                                                               : (gfc->presetTune.use ? gfc->presetTune.attackthre   : NSATTACKTHRE))) ns_attacks[i/3] = (i % 3)+1;
1516         }
1517
1518       if (ns_attacks[0] && gfc->nsPsy.last_attacks[chn][2]) ns_attacks[0] = 0;
1519       if (ns_attacks[1] && ns_attacks[0]) ns_attacks[1] = 0;
1520       if (ns_attacks[2] && ns_attacks[1]) ns_attacks[2] = 0;
1521       if (ns_attacks[3] && ns_attacks[2]) ns_attacks[3] = 0;
1522
1523       if (gfc->nsPsy.last_attacks[chn][2] == 3 ||
1524           ns_attacks[0] || ns_attacks[1] || ns_attacks[2] || ns_attacks[3]) ns_uselongblock = 0;
1525
1526       if (chn < 4) count++;
1527
1528       for(i=0;i<9;i++)
1529         {
1530           gfc->nsPsy.last_en_subshort[chn][i] = en_subshort[i];
1531           gfc->nsPsy.last_attack_intensity[chn][i] = attack_intensity[i];
1532         }
1533
1534       if (gfp->short_blocks == short_block_dispensed) {
1535         uselongblock[chn] = 1;
1536       } 
1537       else if (gfp->short_blocks == short_block_forced) {
1538         uselongblock[chn] = 0;
1539       }
1540       else {
1541         if (chn < 2) {
1542           uselongblock[chn] = ns_uselongblock;
1543         } else {
1544           if (ns_uselongblock == 0) uselongblock[0] = uselongblock[1] = 0;
1545         }
1546       }
1547     }
1548
1549 #if defined(HAVE_GTK)
1550     if (gfp->analysis) {
1551       FLOAT mn,mx,ma=0,mb=0,mc=0;
1552
1553       for ( j = HBLKSIZE_s/2; j < HBLKSIZE_s; j ++)
1554       {
1555         ma += gfc->energy_s[0][j];
1556         mb += gfc->energy_s[1][j];
1557         mc += gfc->energy_s[2][j];
1558       }
1559       mn = Min(ma,mb);
1560       mn = Min(mn,mc);
1561       mx = Max(ma,mb);
1562       mx = Max(mx,mc);
1563
1564       gfc->pinfo->ers[gr_out][chn]=gfc->ers_save[chn];
1565       gfc->ers_save[chn]=(mx/(1e-12+mn));
1566     }
1567 #endif
1568
1569
1570     /*************************************************************** 
1571      * compute masking thresholds for long blocks
1572      ***************************************************************/
1573
1574     for ( sb = 0; sb < NBPSY_l; sb++ )
1575       {
1576         FLOAT8 enn = gfc->w1_l[sb] * eb[gfc->bu_l[sb]] + gfc->w2_l[sb] * eb[gfc->bo_l[sb]];
1577         FLOAT8 thmm = gfc->w1_l[sb] *thr[gfc->bu_l[sb]] + gfc->w2_l[sb] * thr[gfc->bo_l[sb]];
1578
1579         for ( b = gfc->bu_l[sb]+1; b < gfc->bo_l[sb]; b++ )
1580           {
1581             enn  += eb[b];
1582             thmm += thr[b];
1583           }
1584
1585         gfc->en [chn].l[sb] = enn;
1586         gfc->thm[chn].l[sb] = thmm;
1587       }
1588     
1589
1590     /*************************************************************** 
1591      * compute masking thresholds for short blocks
1592      ***************************************************************/
1593
1594     for ( sblock = 0; sblock < 3; sblock++ )
1595       {
1596         j = 0;
1597         for ( b = 0; b < gfc->npart_s_orig; b++ )
1598           {
1599             FLOAT ecb = gfc->energy_s[sblock][j++];
1600             for (i = 1 ; i<gfc->numlines_s[b]; ++i)
1601               {
1602                 ecb += gfc->energy_s[sblock][j++];
1603               }
1604             eb[b] = ecb;
1605           }
1606
1607         {
1608           int kk = 0;
1609           for ( b = 0; b < gfc->npart_s; b++ )
1610             {
1611               FLOAT8 ecb = 0;
1612               for ( k = gfc->s3ind_s[b][0]; k <= gfc->s3ind_s[b][1]; k++ )
1613                 {
1614                   ecb += gfc->s3_ss[kk++] * eb[k];
1615                 }
1616
1617 /* 2001-07-13 */
1618             /* this looks like a BUG  */
1619             thr[b] = Max (1e-6, ecb);
1620             
1621             if (gfp->VBR == vbr_mtrh) {
1622                 thr[b] = Min( ecb, rpelev_s  * gfc->nb_s1[chn][b] );
1623                 if (gfc->blocktype_old[chn>1 ? chn-2 : chn] == SHORT_TYPE ) {
1624                    thr[b] = Min( thr[b], rpelev2_s * gfc->nb_s2[chn][b] );
1625                 }
1626                 thr[b] = Max( thr[b], 1e-37 );
1627                 gfc->nb_s2[chn][b] = gfc->nb_s1[chn][b];
1628                 gfc->nb_s1[chn][b] = ecb;
1629                 }
1630             }
1631         }
1632         for ( sb = 0; sb < NBPSY_s; sb++ )
1633           {
1634             FLOAT8 enn  = gfc->w1_s[sb] * eb[gfc->bu_s[sb]] + gfc->w2_s[sb] * eb[gfc->bo_s[sb]];
1635             FLOAT8 thmm = gfc->w1_s[sb] *thr[gfc->bu_s[sb]] + gfc->w2_s[sb] * thr[gfc->bo_s[sb]];
1636             
1637             for ( b = gfc->bu_s[sb]+1; b < gfc->bo_s[sb]; b++ )
1638               {
1639                 enn  += eb[b];
1640                 thmm += thr[b];
1641               }
1642
1643             /****   short block pre-echo control   ****/
1644
1645 #define NS_PREECHO_ATT0 0.8
1646 #define NS_PREECHO_ATT1 0.6
1647 #define NS_PREECHO_ATT2 0.3
1648
1649             thmm *= NS_PREECHO_ATT0;
1650
1651             if (ns_attacks[sblock] >= 2) {
1652               if (sblock != 0) {
1653                 double p = NS_INTERP(gfc->thm[chn].s[sb][sblock-1],thmm,NS_PREECHO_ATT1*pcfact);
1654                 thmm = Min(thmm,p);
1655               } else {
1656                 double p = NS_INTERP(gfc->nsPsy.last_thm[chn][sb][2],thmm,NS_PREECHO_ATT1*pcfact);
1657                 thmm = Min(thmm,p);
1658               }
1659             } else if (ns_attacks[sblock+1] == 1) {
1660               if (sblock != 0) {
1661                 double p = NS_INTERP(gfc->thm[chn].s[sb][sblock-1],thmm,NS_PREECHO_ATT1*pcfact);
1662                 thmm = Min(thmm,p);
1663               } else {
1664                 double p = NS_INTERP(gfc->nsPsy.last_thm[chn][sb][2],thmm,NS_PREECHO_ATT1*pcfact);
1665                 thmm = Min(thmm,p);
1666               }
1667             }
1668
1669             if (ns_attacks[sblock] == 1) {
1670               double p = sblock == 0 ? gfc->nsPsy.last_thm[chn][sb][2] : gfc->thm[chn].s[sb][sblock-1];
1671               p = NS_INTERP(p,thmm,NS_PREECHO_ATT2*pcfact);
1672               thmm = Min(thmm,p);
1673             } else if ((sblock != 0 && ns_attacks[sblock-1] == 3) ||
1674                        (sblock == 0 && gfc->nsPsy.last_attacks[chn][2] == 3)) {
1675               double p = sblock <= 1 ? gfc->nsPsy.last_thm[chn][sb][sblock+1] : gfc->thm[chn].s[sb][0];
1676               p = NS_INTERP(p,thmm,NS_PREECHO_ATT2*pcfact);
1677               thmm = Min(thmm,p);
1678             }
1679
1680             gfc->en [chn].s[sb][sblock] = enn;
1681             gfc->thm[chn].s[sb][sblock] = thmm;
1682           }
1683       }
1684
1685
1686     /*************************************************************** 
1687      * save some values for analysis of the next granule
1688      ***************************************************************/
1689
1690     for ( sblock = 0; sblock < 3; sblock++ )
1691       {
1692         for ( sb = 0; sb < NBPSY_s; sb++ )
1693           {
1694             gfc->nsPsy.last_thm[chn][sb][sblock] = gfc->thm[chn].s[sb][sblock];
1695           }
1696       }
1697
1698     for(i=0;i<3;i++)
1699       gfc->nsPsy.last_attacks[chn][i] = ns_attacks[i];
1700
1701   } /* end loop over chn */
1702
1703
1704
1705   /*************************************************************** 
1706    * compute M/S thresholds
1707    ***************************************************************/
1708
1709   /* from Johnston & Ferreira 1992 ICASSP paper */
1710
1711   if ( numchn==4 /* mid/side and r/l */) {
1712     FLOAT8 rside,rmid,mld;
1713     int chmid=2,chside=3; 
1714     
1715     for ( sb = 0; sb < NBPSY_l; sb++ ) {
1716       /* use this fix if L & R masking differs by 2db or less */
1717       /* if db = 10*log10(x2/x1) < 2 */
1718       /* if (x2 < 1.58*x1) { */
1719       if (gfc->thm[0].l[sb] <= 1.58*gfc->thm[1].l[sb]
1720           && gfc->thm[1].l[sb] <= 1.58*gfc->thm[0].l[sb]) {
1721
1722         mld = gfc->mld_l[sb]*gfc->en[chside].l[sb];
1723         rmid = Max(gfc->thm[chmid].l[sb], Min(gfc->thm[chside].l[sb],mld));
1724
1725         mld = gfc->mld_l[sb]*gfc->en[chmid].l[sb];
1726         rside = Max(gfc->thm[chside].l[sb],Min(gfc->thm[chmid].l[sb],mld));
1727
1728         gfc->thm[chmid].l[sb]=rmid;
1729         gfc->thm[chside].l[sb]=rside;
1730       }
1731     }
1732     for ( sb = 0; sb < NBPSY_s; sb++ ) {
1733       for ( sblock = 0; sblock < 3; sblock++ ) {
1734         if (gfc->thm[0].s[sb][sblock] <= 1.58*gfc->thm[1].s[sb][sblock]
1735             && gfc->thm[1].s[sb][sblock] <= 1.58*gfc->thm[0].s[sb][sblock]) {
1736
1737           mld = gfc->mld_s[sb]*gfc->en[chside].s[sb][sblock];
1738           rmid = Max(gfc->thm[chmid].s[sb][sblock],Min(gfc->thm[chside].s[sb][sblock],mld));
1739
1740           mld = gfc->mld_s[sb]*gfc->en[chmid].s[sb][sblock];
1741           rside = Max(gfc->thm[chside].s[sb][sblock],Min(gfc->thm[chmid].s[sb][sblock],mld));
1742
1743           gfc->thm[chmid].s[sb][sblock]=rmid;
1744           gfc->thm[chside].s[sb][sblock]=rside;
1745         }
1746       }
1747     }
1748   }
1749
1750
1751   /* Naoki Shibata 2000 */
1752
1753 #define NS_MSFIX 3.5
1754   
1755   if (numchn == 4) {
1756     FLOAT msfix = NS_MSFIX;
1757     if (gfc->nsPsy.safejoint) msfix = 1;
1758     if (gfp->msfix) msfix = gfp->msfix;
1759
1760     if (gfc->presetTune.use && gfc->ATH->adjust >=
1761                                        gfc->presetTune.athadjust_switch_level && 
1762                                                            gfc->presetTune.athadjust_msfix > 0)
1763                 msfix = gfc->presetTune.athadjust_msfix;
1764     
1765     for ( sb = 0; sb < NBPSY_l; sb++ )
1766       {
1767         FLOAT8 thmL,thmR,thmM,thmS,ath;
1768         ath  = (gfc->ATH->cb[(gfc->bu_l[sb] + gfc->bo_l[sb])/2])*pow(10,-gfp->ATHlower/10.0);
1769         thmL = Max(gfc->thm[0].l[sb],ath);
1770         thmR = Max(gfc->thm[1].l[sb],ath);
1771         thmM = Max(gfc->thm[2].l[sb],ath);
1772         thmS = Max(gfc->thm[3].l[sb],ath);
1773
1774         if (thmL*msfix < (thmM+thmS)/2) {
1775           FLOAT8 f = thmL * (gfc->presetTune.use ? gfc->presetTune.ms_maskadjust : msfix) / ((thmM+thmS)/2);
1776           thmM *= f;
1777           thmS *= f;
1778         }
1779         if (thmR*msfix < (thmM+thmS)/2) {
1780           FLOAT8 f = thmR * (gfc->presetTune.use ? gfc->presetTune.ms_maskadjust : msfix) / ((thmM+thmS)/2);
1781           thmM *= f;
1782           thmS *= f;
1783         }
1784
1785         gfc->thm[2].l[sb] = Min(thmM,gfc->thm[2].l[sb]);
1786         gfc->thm[3].l[sb] = Min(thmS,gfc->thm[3].l[sb]);
1787       }
1788
1789     for ( sb = 0; sb < NBPSY_s; sb++ ) {
1790       for ( sblock = 0; sblock < 3; sblock++ ) {
1791         FLOAT8 thmL,thmR,thmM,thmS,ath;
1792         ath  = (gfc->ATH->cb[(gfc->bu_s[sb] + gfc->bo_s[sb])/2])*pow(10,-gfp->ATHlower/10.0);
1793         thmL = Max(gfc->thm[0].s[sb][sblock],ath);
1794         thmR = Max(gfc->thm[1].s[sb][sblock],ath);
1795         thmM = Max(gfc->thm[2].s[sb][sblock],ath);
1796         thmS = Max(gfc->thm[3].s[sb][sblock],ath);
1797
1798         if (thmL*msfix < (thmM+thmS)/2) {
1799           FLOAT8 f = thmL*msfix / ((thmM+thmS)/2);
1800           thmM *= f;
1801           thmS *= f;
1802         }
1803         if (thmR*msfix < (thmM+thmS)/2) {
1804           FLOAT8 f = thmR*msfix / ((thmM+thmS)/2);
1805           thmM *= f;
1806           thmS *= f;
1807         }
1808
1809         gfc->thm[2].s[sb][sblock] = Min(gfc->thm[2].s[sb][sblock],thmM);
1810         gfc->thm[3].s[sb][sblock] = Min(gfc->thm[3].s[sb][sblock],thmS);
1811       }
1812     }
1813   }
1814
1815   ms_ratio_l = 0;
1816   ms_ratio_s = 0;
1817
1818
1819   /*************************************************************** 
1820    * compute estimation of the amount of bit used in the granule
1821    ***************************************************************/
1822
1823   for(chn=0;chn<numchn;chn++)
1824     {
1825       {
1826         static FLOAT8 regcoef[] = {
1827           1124.23,10.0583,10.7484,7.29006,16.2714,6.2345,4.09743,3.05468,3.33196,2.54688,
1828           3.68168,5.83109,2.93817,-8.03277,-10.8458,8.48777,9.13182,2.05212,8.6674,50.3937,73.267,97.5664,0
1829         };
1830
1831         FLOAT8 msum = regcoef[0]/4;
1832         int sb;
1833
1834         for ( sb = 0; sb < NBPSY_l; sb++ )
1835           {
1836             FLOAT8 t;
1837               
1838             if (gfc->thm[chn].l[sb]*gfc->masking_lower != 0 &&
1839                 gfc->en[chn].l[sb]/(gfc->thm[chn].l[sb]*gfc->masking_lower) > 1)
1840               t = log(gfc->en[chn].l[sb]/(gfc->thm[chn].l[sb]*gfc->masking_lower));
1841             else
1842               t = 0;
1843             msum += regcoef[sb+1] * t;
1844           }
1845
1846         gfc->nsPsy.pe_l[chn] = msum;
1847       }
1848
1849       {
1850         static FLOAT8 regcoef[] = {
1851           1236.28,0,0,0,0.434542,25.0738,0,0,0,19.5442,19.7486,60,100,0
1852         };
1853
1854         FLOAT8 msum = regcoef[0]/4;
1855         int sb,sblock;
1856
1857         for(sblock=0;sblock<3;sblock++)
1858           {
1859             for ( sb = 0; sb < NBPSY_s; sb++ )
1860               {
1861                 FLOAT8 t;
1862               
1863                 if (gfc->thm[chn].s[sb][sblock] * gfc->masking_lower != 0 &&
1864                     gfc->en[chn].s[sb][sblock] / (gfc->thm[chn].s[sb][sblock] * gfc->masking_lower) > 1)
1865                   t = log(gfc->en[chn].s[sb][sblock] / (gfc->thm[chn].s[sb][sblock] * gfc->masking_lower));
1866                 else
1867                   t = 0;
1868                 msum += regcoef[sb+1] * t;
1869               }
1870           }
1871
1872         gfc->nsPsy.pe_s[chn] = msum;
1873       }
1874
1875       //gfc->pe[chn] -= 150;
1876     }
1877
1878   /*************************************************************** 
1879    * determine final block type
1880    ***************************************************************/
1881
1882   for (chn=0; chn<gfc->channels_out; chn++) {
1883     blocktype[chn] = NORM_TYPE;
1884   }
1885
1886   if (gfp->short_blocks == short_block_coupled) {
1887       /* force both channels to use the same block type */
1888       /* this is necessary if the frame is to be encoded in ms_stereo.  */
1889       /* But even without ms_stereo, FhG  does this */
1890       int bothlong= (uselongblock[0] && uselongblock[1]);
1891       if (!bothlong) {
1892         uselongblock[0]=0;
1893         uselongblock[1]=0;
1894       }
1895   }
1896
1897   /* update the blocktype of the previous granule, since it depends on what
1898    * happend in this granule */
1899   for (chn=0; chn<gfc->channels_out; chn++) {
1900     if ( uselongblock[chn])
1901       {                         /* no attack : use long blocks */
1902         assert( gfc->blocktype_old[chn] != START_TYPE );
1903         switch( gfc->blocktype_old[chn] ) 
1904           {
1905           case NORM_TYPE:
1906           case STOP_TYPE:
1907             blocktype[chn] = NORM_TYPE;
1908             break;
1909           case SHORT_TYPE:
1910             blocktype[chn] = STOP_TYPE; 
1911             break;
1912           }
1913       } else   {
1914         /* attack : use short blocks */
1915         blocktype[chn] = SHORT_TYPE;
1916         if ( gfc->blocktype_old[chn] == NORM_TYPE ) {
1917           gfc->blocktype_old[chn] = START_TYPE;
1918         }
1919         if ( gfc->blocktype_old[chn] == STOP_TYPE ) {
1920           gfc->blocktype_old[chn] = SHORT_TYPE ;
1921         }
1922       }
1923     
1924     blocktype_d[chn] = gfc->blocktype_old[chn];  /* value returned to calling program */
1925     gfc->blocktype_old[chn] = blocktype[chn];    /* save for next call to l3psy_anal */
1926
1927     if (gfc->presetTune.use) {
1928         if (blocktype_d[chn] != NORM_TYPE)
1929             gfc->presetTune.quantcomp_current = gfc->presetTune.quantcomp_type_s;
1930         else
1931             gfc->presetTune.quantcomp_current = gfp->experimentalX;
1932     
1933         if (gfc->ATH->adjust >= gfc->presetTune.athadjust_switch_level && 
1934                                                      blocktype_d[chn] == NORM_TYPE &&
1935                                                                                  gfc->presetTune.quantcomp_alt_type > -1) {
1936                     gfc->presetTune.quantcomp_current = gfc->presetTune.quantcomp_alt_type;
1937                 }
1938     }
1939   }
1940   
1941   /*********************************************************************
1942    * compute the value of PE to return (one granule delay)
1943    *********************************************************************/
1944   for(chn=0;chn<numchn;chn++)
1945     {
1946       if (chn < 2) {
1947         if (blocktype_d[chn] == SHORT_TYPE) {
1948           percep_entropy[chn] = pe_s[chn];
1949         } else {
1950           percep_entropy[chn] = pe_l[chn];
1951         }
1952         if (gfp->analysis) gfc->pinfo->pe[gr_out][chn] = percep_entropy[chn];
1953       } else {
1954         if (blocktype_d[0] == SHORT_TYPE) {
1955           percep_MS_entropy[chn-2] = pe_s[chn];
1956         } else {
1957           percep_MS_entropy[chn-2] = pe_l[chn];
1958         }
1959         if (gfp->analysis) gfc->pinfo->pe[gr_out][chn] = percep_MS_entropy[chn-2];
1960       }
1961     }
1962
1963   return 0;
1964 }
1965
1966
1967
1968
1969
1970 /* 
1971  *   The spreading function.  Values returned in units of energy
1972  */
1973 FLOAT8 s3_func(FLOAT8 bark) {
1974     
1975     FLOAT8 tempx,x,tempy,temp;
1976     tempx = bark;
1977     if (tempx>=0) tempx *= 3;
1978     else tempx *=1.5; 
1979     
1980     if(tempx>=0.5 && tempx<=2.5)
1981         {
1982             temp = tempx - 0.5;
1983             x = 8.0 * (temp*temp - 2.0 * temp);
1984         }
1985     else x = 0.0;
1986     tempx += 0.474;
1987     tempy = 15.811389 + 7.5*tempx - 17.5*sqrt(1.0+tempx*tempx);
1988     
1989     if (tempy <= -60.0) return  0.0;
1990
1991     tempx = exp( (x + tempy)*LN_TO_LOG10 ); 
1992
1993     /* Normalization.  The spreading function should be normalized so that:
1994          +inf
1995            /
1996            |  s3 [ bark ]  d(bark)   =  1
1997            /
1998          -inf
1999     */
2000     tempx /= .6609193;
2001     return tempx;
2002     
2003 }
2004
2005
2006
2007
2008
2009
2010
2011
2012 int L3para_read(lame_global_flags * gfp, FLOAT8 sfreq, int *numlines_l,int *numlines_s, 
2013 FLOAT8 *minval,
2014 FLOAT8 s3_l[CBANDS][CBANDS], FLOAT8 s3_s[CBANDS][CBANDS],
2015 FLOAT8 *SNR, 
2016 int *bu_l, int *bo_l, FLOAT8 *w1_l, FLOAT8 *w2_l, 
2017 int *bu_s, int *bo_s, FLOAT8 *w1_s, FLOAT8 *w2_s,
2018 int *npart_l_orig,int *npart_l,int *npart_s_orig,int *npart_s)
2019 {
2020   lame_internal_flags *gfc=gfp->internal_flags;
2021
2022
2023   FLOAT8 bval_l[CBANDS], bval_s[CBANDS];
2024   FLOAT8 bval_l_width[CBANDS], bval_s_width[CBANDS];
2025   int  i,j;
2026   int partition[HBLKSIZE]; 
2027
2028
2029
2030   /* compute numlines, the number of spectral lines in each partition band */
2031   /* each partition band should be about DELBARK wide. */
2032   j=0;
2033   for(i=0;i<CBANDS;i++)
2034     {
2035       FLOAT8 ji, bark1,bark2;
2036       int k,j2;
2037
2038       j2 = j;
2039       j2 = Min(j2,BLKSIZE/2);
2040       
2041       do {
2042         /* find smallest j2 >= j so that  (bark - bark_l[i-1]) < DELBARK */
2043         ji = j;
2044         bark1 = freq2bark(sfreq*ji/BLKSIZE);
2045         
2046         ++j2;
2047         ji = j2;
2048         bark2  = freq2bark(sfreq*ji/BLKSIZE);
2049       } while ((bark2 - bark1) < DELBARK  && j2<=BLKSIZE/2);
2050
2051       for (k=j; k<j2; ++k)
2052         partition[k]=i;
2053       numlines_l[i]=(j2-j);
2054       j = j2;
2055       if (j > BLKSIZE/2) break;
2056     }
2057   *npart_l_orig = i+1;
2058   assert(*npart_l_orig <= CBANDS);
2059
2060   /* compute which partition bands are in which scalefactor bands */
2061   { int i1,i2,sfb,start,end;
2062     FLOAT8 freq1,freq2;
2063     for ( sfb = 0; sfb < SBMAX_l; sfb++ ) {
2064       start = gfc->scalefac_band.l[ sfb ];
2065       end   = gfc->scalefac_band.l[ sfb+1 ];
2066       freq1 = sfreq*(start-.5)/(2*576);
2067       freq2 = sfreq*(end-1+.5)/(2*576);
2068                      
2069       i1 = floor(.5 + BLKSIZE*freq1/sfreq);
2070       if (i1<0) i1=0;
2071       i2 = floor(.5 + BLKSIZE*freq2/sfreq);
2072       if (i2>BLKSIZE/2) i2=BLKSIZE/2;
2073
2074       //      DEBUGF(gfc,"longblock:  old: (%i,%i)  new: (%i,%i) %i %i \n",bu_l[sfb],bo_l[sfb],partition[i1],partition[i2],i1,i2);
2075
2076       w1_l[sfb]=.5;
2077       w2_l[sfb]=.5;
2078       bu_l[sfb]=partition[i1];
2079       bo_l[sfb]=partition[i2];
2080
2081     }
2082   }
2083
2084
2085   /* compute bark value and ATH of each critical band */
2086   j = 0;
2087   for ( i = 0; i < *npart_l_orig; i++ ) {
2088       int     k;
2089       FLOAT8  bark1,bark2;
2090       /* FLOAT8 mval,freq; */
2091
2092       // Calculating the medium bark scaled frequency of the spectral lines
2093       // from j ... j + numlines[i]-1  (=spectral lines in parition band i)
2094
2095       k         = numlines_l[i] - 1;
2096       bark1 = freq2bark(sfreq*(j+0)/BLKSIZE);
2097       bark2 = freq2bark(sfreq*(j+k)/BLKSIZE);
2098       bval_l[i] = .5*(bark1+bark2);
2099
2100       bark1 = freq2bark(sfreq*(j+0-.5)/BLKSIZE);
2101       bark2 = freq2bark(sfreq*(j+k+.5)/BLKSIZE);
2102       bval_l_width[i] = bark2-bark1;
2103
2104       gfc->ATH->cb [i] = 1.e37; // preinit for minimum search
2105       for (k=0; k < numlines_l[i]; k++, j++) {
2106         FLOAT8  freq = sfreq*j/(1000.0*BLKSIZE);
2107         FLOAT8  level;
2108         assert( freq <= 24 );              // or only '<'
2109         //      freq = Min(.1,freq);       // ATH below 100 Hz constant, not further climbing
2110         level  = ATHformula (freq*1000, gfp) - 20;   // scale to FFT units; returned value is in dB
2111         level  = pow ( 10., 0.1*level );   // convert from dB -> energy
2112         level *= numlines_l [i];
2113         if ( level < gfc->ATH->cb [i] )
2114             gfc->ATH->cb [i] = level;
2115       }
2116
2117
2118     }
2119
2120   /* MINVAL.  For low freq, the strength of the masking is limited by minval
2121    * this is an ISO MPEG1 thing, dont know if it is really needed */
2122   for(i=0;i<*npart_l_orig;i++){
2123     double x = (-20+bval_l[i]*20.0/10.0);
2124     if (bval_l[i]>10) x = 0;
2125     minval[i]=pow(10.0,x/10);
2126     gfc->PSY->prvTonRed[i] = minval[i];
2127   }
2128
2129
2130
2131
2132
2133
2134
2135   /************************************************************************/
2136   /* SHORT BLOCKS */
2137   /************************************************************************/
2138
2139   /* compute numlines */
2140   j=0;
2141   for(i=0;i<CBANDS;i++)
2142     {
2143       FLOAT8 ji, bark1,bark2;
2144       int k,j2;
2145
2146       j2 = j;
2147       j2 = Min(j2,BLKSIZE_s/2);
2148       
2149       do {
2150         /* find smallest j2 >= j so that  (bark - bark_s[i-1]) < DELBARK */
2151         ji = j;
2152         bark1  = freq2bark(sfreq*ji/BLKSIZE_s);
2153         
2154         ++j2;
2155         ji = j2;
2156         bark2  = freq2bark(sfreq*ji/BLKSIZE_s);
2157
2158       } while ((bark2 - bark1) < DELBARK  && j2<=BLKSIZE_s/2);
2159
2160       for (k=j; k<j2; ++k)
2161         partition[k]=i;
2162       numlines_s[i]=(j2-j);
2163       j = j2;
2164       if (j > BLKSIZE_s/2) break;
2165     }
2166   *npart_s_orig = i+1;
2167   assert(*npart_s_orig <= CBANDS);
2168
2169   /* compute which partition bands are in which scalefactor bands */
2170   { int i1,i2,sfb,start,end;
2171     FLOAT8 freq1,freq2;
2172     for ( sfb = 0; sfb < SBMAX_s; sfb++ ) {
2173       start = gfc->scalefac_band.s[ sfb ];
2174       end   = gfc->scalefac_band.s[ sfb+1 ];
2175       freq1 = sfreq*(start-.5)/(2*192);
2176       freq2 = sfreq*(end-1+.5)/(2*192);
2177                      
2178       i1 = floor(.5 + BLKSIZE_s*freq1/sfreq);
2179       if (i1<0) i1=0;
2180       i2 = floor(.5 + BLKSIZE_s*freq2/sfreq);
2181       if (i2>BLKSIZE_s/2) i2=BLKSIZE_s/2;
2182
2183       //DEBUGF(gfc,"shortblock: old: (%i,%i)  new: (%i,%i) %i %i \n",bu_s[sfb],bo_s[sfb], partition[i1],partition[i2],i1,i2);
2184
2185       w1_s[sfb]=.5;
2186       w2_s[sfb]=.5;
2187       bu_s[sfb]=partition[i1];
2188       bo_s[sfb]=partition[i2];
2189
2190     }
2191   }
2192
2193
2194
2195
2196
2197   /* compute bark values of each critical band */
2198   j = 0;
2199   for(i=0;i<*npart_s_orig;i++)
2200     {
2201       int     k;
2202       FLOAT8  bark1,bark2,snr;
2203       k    = numlines_s[i] - 1;
2204
2205       bark1 = freq2bark (sfreq*(j+0)/BLKSIZE_s);
2206       bark2 = freq2bark (sfreq*(j+k)/BLKSIZE_s); 
2207       bval_s[i] = .5*(bark1+bark2);
2208
2209       bark1 = freq2bark (sfreq*(j+0-.5)/BLKSIZE_s);
2210       bark2 = freq2bark (sfreq*(j+k+.5)/BLKSIZE_s); 
2211       bval_s_width[i] = bark2-bark1;
2212       j        += k+1;
2213       
2214       /* SNR formula */
2215       if (bval_s[i]<13)
2216           snr=-8.25;
2217       else 
2218           snr  = -4.5 * (bval_s[i]-13)/(24.0-13.0)  + 
2219               -8.25*(bval_s[i]-24)/(13.0-24.0);
2220
2221       SNR[i]=pow(10.0,snr/10.0);
2222     }
2223
2224
2225
2226
2227
2228
2229   /************************************************************************
2230    * Now compute the spreading function, s[j][i], the value of the spread-*
2231    * ing function, centered at band j, for band i, store for later use    *
2232    ************************************************************************/
2233   /* i.e.: sum over j to spread into signal barkval=i  
2234      NOTE: i and j are used opposite as in the ISO docs */
2235   for(i=0;i<*npart_l_orig;i++)    {
2236       for(j=0;j<*npart_l_orig;j++)      {
2237           s3_l[i][j]=s3_func(bval_l[i]-bval_l[j])*bval_l_width[j];
2238       }
2239   }
2240   for(i=0;i<*npart_s_orig;i++)     {
2241       for(j=0;j<*npart_s_orig;j++)      {
2242           s3_s[i][j]=s3_func(bval_s[i]-bval_s[j])*bval_s_width[j];
2243       }
2244   }
2245   
2246
2247
2248
2249   /* compute: */
2250   /* npart_l_orig   = number of partition bands before convolution */
2251   /* npart_l  = number of partition bands after convolution */
2252   
2253   *npart_l=bo_l[NBPSY_l-1]+1;
2254   *npart_s=bo_s[NBPSY_s-1]+1;
2255   
2256   assert(*npart_l <= *npart_l_orig);
2257   assert(*npart_s <= *npart_s_orig);
2258
2259
2260     /* setup stereo demasking thresholds */
2261     /* formula reverse enginerred from plot in paper */
2262     for ( i = 0; i < NBPSY_s; i++ ) {
2263       FLOAT8 arg,mld;
2264       arg = freq2bark(sfreq*gfc->scalefac_band.s[i]/(2*192));
2265       arg = (Min(arg, 15.5)/15.5);
2266
2267       mld = 1.25*(1-cos(PI*arg))-2.5;
2268       gfc->mld_s[i] = pow(10.0,mld);
2269     }
2270     for ( i = 0; i < NBPSY_l; i++ ) {
2271       FLOAT8 arg,mld;
2272       arg = freq2bark(sfreq*gfc->scalefac_band.l[i]/(2*576));
2273       arg = (Min(arg, 15.5)/15.5);
2274
2275       mld = 1.25*(1-cos(PI*arg))-2.5;
2276       gfc->mld_l[i] = pow(10.0,mld);
2277     }
2278
2279 #define temporalmask_sustain_sec 0.01
2280
2281     /* setup temporal masking */
2282     gfc->decay = exp(-1.0*LOG10/(temporalmask_sustain_sec*sfreq/192.0));
2283
2284     return 0;
2285 }
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297 int psymodel_init(lame_global_flags *gfp)
2298 {
2299     lame_internal_flags *gfc=gfp->internal_flags;
2300     int i,j,b,sb,k,samplerate;
2301
2302     FLOAT8 s3_s[CBANDS][CBANDS];
2303     FLOAT8 s3_l[CBANDS][CBANDS];
2304     int numberOfNoneZero;
2305
2306     samplerate = gfp->out_samplerate;
2307     gfc->ms_ener_ratio_old=.25;
2308     gfc->blocktype_old[0]=STOP_TYPE;
2309     gfc->blocktype_old[1]=STOP_TYPE;
2310     gfc->blocktype_old[0]=SHORT_TYPE;
2311     gfc->blocktype_old[1]=SHORT_TYPE;
2312
2313     for (i=0; i<4; ++i) {
2314       for (j=0; j<CBANDS; ++j) {
2315         gfc->nb_1[i][j]=1e20;
2316         gfc->nb_2[i][j]=1e20;
2317       }
2318       for ( sb = 0; sb < NBPSY_l; sb++ ) {
2319         gfc->en[i].l[sb] = 1e20;
2320         gfc->thm[i].l[sb] = 1e20;
2321       }
2322       for (j=0; j<3; ++j) {
2323         for ( sb = 0; sb < NBPSY_s; sb++ ) {
2324           gfc->en[i].s[sb][j] = 1e20;
2325           gfc->thm[i].s[sb][j] = 1e20;
2326         }
2327       }
2328     }
2329     for (i=0; i<4; ++i) {
2330       for (j=0; j<3; ++j) {
2331         for ( sb = 0; sb < NBPSY_s; sb++ ) {
2332           gfc->nsPsy.last_thm[i][sb][j] = 1e20;
2333         }
2334       }
2335     }
2336     for(i=0;i<4;i++) {
2337       for(j=0;j<9;j++)
2338         gfc->nsPsy.last_en_subshort[i][j] = 100;
2339       for(j=0;j<3;j++)
2340         gfc->nsPsy.last_attacks[i][j] = 0;
2341       gfc->nsPsy.pe_l[i] = gfc->nsPsy.pe_s[i] = 0;
2342     }
2343
2344
2345
2346     
2347     /*  gfp->cwlimit = sfreq*j/1024.0;  */
2348     gfc->cw_lower_index=6;
2349     gfc->cw_upper_index = gfc->PSY->cwlimit*1024.0/gfp->out_samplerate;
2350     gfc->cw_upper_index=Min(HBLKSIZE-4,gfc->cw_upper_index);      /* j+3 < HBLKSIZE-1 */
2351     gfc->cw_upper_index=Max(6,gfc->cw_upper_index);
2352
2353     for ( j = 0; j < HBLKSIZE; j++ )
2354       gfc->cw[j] = 0.4f;
2355     
2356     
2357
2358     i=L3para_read( gfp,(FLOAT8) samplerate,gfc->numlines_l,gfc->numlines_s,
2359           gfc->minval,s3_l,s3_s,gfc->SNR_s,gfc->bu_l,
2360           gfc->bo_l,gfc->w1_l,gfc->w2_l, gfc->bu_s,gfc->bo_s,
2361           gfc->w1_s,gfc->w2_s,&gfc->npart_l_orig,&gfc->npart_l,
2362           &gfc->npart_s_orig,&gfc->npart_s );
2363     if (i!=0) return -1;
2364     
2365
2366
2367     /* npart_l_orig   = number of partition bands before convolution */
2368     /* npart_l  = number of partition bands after convolution */
2369     
2370     numberOfNoneZero = 0;
2371     for (i=0; i<gfc->npart_l; i++) {
2372       for (j = 0; j < gfc->npart_l_orig; j++) {
2373         if (s3_l[i][j] != 0.0)
2374           break;
2375       }
2376       gfc->s3ind[i][0] = j;
2377       
2378       for (j = gfc->npart_l_orig - 1; j > 0; j--) {
2379         if (s3_l[i][j] != 0.0)
2380           break;
2381       }
2382       gfc->s3ind[i][1] = j;
2383       numberOfNoneZero += (gfc->s3ind[i][1] - gfc->s3ind[i][0] + 1);
2384     }
2385     gfc->s3_ll = malloc(sizeof(FLOAT8)*numberOfNoneZero);
2386     if (!gfc->s3_ll)
2387       return -1;
2388
2389     k = 0;
2390     for (i=0; i<gfc->npart_l; i++) {
2391       for (j = gfc->s3ind[i][0]; j <= gfc->s3ind[i][1]; j++) {
2392         gfc->s3_ll[k++] = s3_l[i][j];
2393       }
2394     }
2395
2396
2397
2398     numberOfNoneZero = 0;
2399     for (i=0; i<gfc->npart_s; i++) {
2400       for (j = 0; j < gfc->npart_s_orig; j++) {
2401         if (s3_s[i][j] != 0.0)
2402           break;
2403       }
2404       gfc->s3ind_s[i][0] = j;
2405       
2406       for (j = gfc->npart_s_orig - 1; j > 0; j--) {
2407         if (s3_s[i][j] != 0.0)
2408           break;
2409       }
2410       gfc->s3ind_s[i][1] = j;
2411       numberOfNoneZero += (gfc->s3ind_s[i][1] - gfc->s3ind_s[i][0] + 1);
2412     }
2413     gfc->s3_ss = malloc(sizeof(FLOAT8)*numberOfNoneZero);
2414     if (!gfc->s3_ss)
2415       return -1;
2416
2417
2418     
2419     
2420     /*  
2421       #include "debugscalefac.c"
2422     */
2423     
2424
2425
2426     if (gfc->nsPsy.use) {
2427         /* long block spreading function normalization */
2428         for ( b = 0;b < gfc->npart_l; b++ ) {
2429             for ( k = gfc->s3ind[b][0]; k <= gfc->s3ind[b][1]; k++ ) {
2430                 // spreading function has been properly normalized by
2431                 // multiplying by DELBARK/.6609193 = .515.  
2432                 // It looks like Naoki was
2433                 // way ahead of me and added this factor here!
2434                 // it is no longer needed.
2435                 //gfc->s3_l[b][k] *= 0.5;
2436             }
2437         }
2438         /* short block spreading function normalization */
2439         // no longer needs to be normalized, but nspsytune wants 
2440         // SNR_s applied here istead of later to save CPU cycles
2441         for ( b = 0;b < gfc->npart_s; b++ ) {
2442             FLOAT8 norm=0;
2443             for ( k = gfc->s3ind_s[b][0]; k <= gfc->s3ind_s[b][1]; k++ ) {
2444                 norm += s3_s[b][k];
2445             }
2446             for ( k = gfc->s3ind_s[b][0]; k <= gfc->s3ind_s[b][1]; k++ ) {
2447                 s3_s[b][k] *= gfc->SNR_s[b] /* / norm */;
2448             }
2449         }
2450     }
2451
2452
2453
2454     if (gfc->nsPsy.use) {
2455 #if 1
2456         /* spread only from npart_l bands.  Normally, we use the spreading
2457          * function to convolve from npart_l_orig down to npart_l bands 
2458          */
2459         for(b=0;b<gfc->npart_l;b++)
2460             if (gfc->s3ind[b][1] > gfc->npart_l-1) gfc->s3ind[b][1] = gfc->npart_l-1;
2461 #endif
2462     }
2463     k = 0;
2464     for (i=0; i<gfc->npart_s; i++) {
2465       for (j = gfc->s3ind_s[i][0]; j <= gfc->s3ind_s[i][1]; j++) {
2466         gfc->s3_ss[k++] = s3_s[i][j];
2467       }
2468     }
2469
2470
2471
2472                                 /* init. for loudness approx. -jd 2001 mar 27*/
2473     gfc->loudness_sq_save[0] = 0.0;
2474     gfc->loudness_sq_save[1] = 0.0;
2475
2476
2477
2478     return 0;
2479 }
2480
2481
2482
2483
2484
2485 /* psycho_loudness_approx
2486    jd - 2001 mar 12
2487 in:  energy   - BLKSIZE/2 elements of frequency magnitudes ^ 2
2488      gfp      - uses out_samplerate, ATHtype (also needed for ATHformula)
2489 returns: loudness^2 approximation, a positive value roughly tuned for a value
2490          of 1.0 for signals near clipping.
2491 notes:   When calibrated, feeding this function binary white noise at sample
2492          values +32767 or -32768 should return values that approach 3.
2493          ATHformula is used to approximate an equal loudness curve.
2494 future:  Data indicates that the shape of the equal loudness curve varies
2495          with intensity.  This function might be improved by using an equal
2496          loudness curve shaped for typical playback levels (instead of the
2497          ATH, that is shaped for the threshold).  A flexible realization might
2498          simply bend the existing ATH curve to achieve the desired shape.
2499          However, the potential gain may not be enough to justify an effort.
2500 */
2501 FLOAT
2502 psycho_loudness_approx( FLOAT *energy, lame_global_flags *gfp )
2503 {
2504   int i;
2505   static int eql_type = -1;
2506   static FLOAT eql_w[BLKSIZE/2];/* equal loudness weights (based on ATH) */
2507   const FLOAT vo_scale= 1./( 14752 ); /* tuned for output level */
2508                                       /* (sensitive to energy scale) */
2509   FLOAT loudness_power;
2510
2511   if( eql_type != gfp->ATHtype ) { 
2512                                 /* compute equal loudness weights (eql_w) */
2513     FLOAT freq;
2514     FLOAT freq_inc = gfp->out_samplerate / (BLKSIZE);
2515     FLOAT eql_balance = 0.0;
2516     eql_type = gfp->ATHtype;
2517     freq = 0.0;
2518     for( i = 0; i < BLKSIZE/2; ++i ) {
2519       freq += freq_inc;
2520                                 /* convert ATH dB to relative power (not dB) */
2521                                 /*  to determine eql_w */
2522       eql_w[i] = 1. / pow( 10, ATHformula( freq, gfp ) / 10 );
2523       eql_balance += eql_w[i];
2524     }
2525     eql_balance = 1 / eql_balance;
2526     for( i = BLKSIZE/2; --i >= 0; ) { /* scale weights */
2527       eql_w[i] *= eql_balance;
2528     }
2529   }
2530
2531   loudness_power = 0.0;
2532   for( i = 0; i < BLKSIZE/2; ++i ) { /* apply weights to power in freq. bands*/
2533     loudness_power += energy[i] * eql_w[i];
2534   }
2535   loudness_power /= (BLKSIZE/2);
2536   loudness_power *= vo_scale * vo_scale;
2537
2538   return( loudness_power );
2539 }