X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=lib%2Fpsy.c;h=0d159934d52bc30da41f1068b769f407e5a52556;hb=a9eb99a5bd6f2d7da02d6cd13a428baf3a1bf48c;hp=4911b4ca97415eb7a6227d4cd40db8f671ae9b5a;hpb=2e04704e27b5819be1ce094d2a5e2471047d1990;p=platform%2Fupstream%2Flibvorbis.git

diff --git a/lib/psy.c b/lib/psy.c
index 4911b4c..0d15993 100644
--- a/lib/psy.c
+++ b/lib/psy.c
@@ -1,18 +1,16 @@
 /********************************************************************
  *                                                                  *
  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
- * THE GNU LESSER/LIBRARY PUBLIC LICENSE, WHICH IS INCLUDED WITH    *
- * THIS SOURCE. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.        *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  *                                                                  *
- * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2000             *
- * by Monty <monty@xiph.org> and the XIPHOPHORUS Company            *
- * http://www.xiph.org/                                             *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010             *
+ * by the Xiph.Org Foundation http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
  function: psychoacoustics not including preecho
- last mod: $Id: psy.c,v 1.32 2000/11/14 00:05:31 xiphmont Exp $
 
  ********************************************************************/
 
@@ -20,6 +18,7 @@
 #include <math.h>
 #include <string.h>
 #include "vorbis/codec.h"
+#include "codec_internal.h"
 
 #include "masking.h"
 #include "psy.h"
@@ -29,51 +28,51 @@
 #include "scales.h"
 #include "misc.h"
 
-/* Why Bark scale for encoding but not masking computation? Because
-   masking has a strong harmonic dependancy */
+#define NEGINF -9999.f
+static const double stereo_threshholds[]={0.0, .5, 1.0, 1.5, 2.5, 4.5, 8.5, 16.5, 9e10};
+static const double stereo_threshholds_limited[]={0.0, .5, 1.0, 1.5, 2.0, 2.5, 4.5, 8.5, 9e10};
 
-/* the beginnings of real psychoacoustic infrastructure.  This is
-   still not tightly tuned */
-void _vi_psy_free(vorbis_info_psy *i){
-  if(i){
-    memset(i,0,sizeof(vorbis_info_psy));
-    _ogg_free(i);
-  }
+vorbis_look_psy_global *_vp_global_look(vorbis_info *vi){
+  codec_setup_info *ci=vi->codec_setup;
+  vorbis_info_psy_global *gi=&ci->psy_g_param;
+  vorbis_look_psy_global *look=_ogg_calloc(1,sizeof(*look));
+
+  look->channels=vi->channels;
+
+  look->ampmax=-9999.;
+  look->gi=gi;
+  return(look);
 }
 
-vorbis_info_psy *_vi_psy_copy(vorbis_info_psy *i){
-  vorbis_info_psy *ret=_ogg_malloc(sizeof(vorbis_info_psy));
-  memcpy(ret,i,sizeof(vorbis_info_psy));
-  return(ret);
+void _vp_global_free(vorbis_look_psy_global *look){
+  if(look){
+    memset(look,0,sizeof(*look));
+    _ogg_free(look);
+  }
 }
 
-/* Set up decibel threshhold slopes on a Bark frequency scale */
-/* ATH is the only bit left on a Bark scale.  No reason to change it
-   right now */
-static void set_curve(float *ref,float *c,int n, float crate){
-  int i,j=0;
+void _vi_gpsy_free(vorbis_info_psy_global *i){
+  if(i){
+    memset(i,0,sizeof(*i));
+    _ogg_free(i);
+  }
+}
 
-  for(i=0;i<MAX_BARK-1;i++){
-    int endpos=rint(fromBARK(i+1)*2*n/crate);
-    float base=ref[i];
-    if(j<endpos){
-      float delta=(ref[i+1]-base)/(endpos-j);
-      for(;j<endpos && j<n;j++){
-	c[j]=base;
-	base+=delta;
-      }
-    }
+void _vi_psy_free(vorbis_info_psy *i){
+  if(i){
+    memset(i,0,sizeof(*i));
+    _ogg_free(i);
   }
 }
 
 static void min_curve(float *c,
-		       float *c2){
-  int i;  
+                       float *c2){
+  int i;
   for(i=0;i<EHMER_MAX;i++)if(c2[i]<c[i])c[i]=c2[i];
 }
 static void max_curve(float *c,
-		       float *c2){
-  int i;  
+                       float *c2){
+  int i;
   for(i=0;i<EHMER_MAX;i++)if(c2[i]>c[i])c[i]=c2[i];
 }
 
@@ -83,208 +82,279 @@ static void attenuate_curve(float *c,float att){
     c[i]+=att;
 }
 
-static void linear_curve(float *c){
-  int i;  
-  for(i=0;i<EHMER_MAX;i++)
-    if(c[i]<=-200.)
-      c[i]=0.;
-    else
-      c[i]=fromdB(c[i]);
-}
+static float ***setup_tone_curves(float curveatt_dB[P_BANDS],float binHz,int n,
+                                  float center_boost, float center_decay_rate){
+  int i,j,k,m;
+  float ath[EHMER_MAX];
+  float workc[P_BANDS][P_LEVELS][EHMER_MAX];
+  float athc[P_LEVELS][EHMER_MAX];
+  float *brute_buffer=alloca(n*sizeof(*brute_buffer));
 
-static void interp_curve(float *c,float *c1,float *c2,float del){
-  int i;
-  for(i=0;i<EHMER_MAX;i++)
-    c[i]=c2[i]*del+c1[i]*(1.-del);
-}
+  float ***ret=_ogg_malloc(sizeof(*ret)*P_BANDS);
 
-static void setup_curve(float **c,
-			int band,
-			float *curveatt_dB){
-  int i,j;
-  float ath[EHMER_MAX];
-  float tempc[P_LEVELS][EHMER_MAX];
-
-  memcpy(c[0],c[4],sizeof(float)*EHMER_MAX);
-  memcpy(c[2],c[4],sizeof(float)*EHMER_MAX);
-
-  /* we add back in the ATH to avoid low level curves falling off to
-     -infinity and unneccessarily cutting off high level curves in the
-     curve limiting (last step).  But again, remember... a half-band's
-     settings must be valid over the whole band, and it's better to
-     mask too little than too much, so be pessimal. */
-
-  for(i=0;i<EHMER_MAX;i++){
-    float oc_min=band*.5-1+(i-EHMER_OFFSET)*.125;
-    float oc_max=band*.5-1+(i-EHMER_OFFSET+1)*.125;
-    float bark=toBARK(fromOC(oc_min));
-    int ibark=floor(bark);
-    float del=bark-ibark;
-    float ath_min,ath_max;
-
-    if(ibark<26)
-      ath_min=ATH_Bark_dB[ibark]*(1.-del)+ATH_Bark_dB[ibark+1]*del;
-    else
-      ath_min=200.;
+  memset(workc,0,sizeof(workc));
 
-    bark=toBARK(fromOC(oc_max));
-    ibark=floor(bark);
-    del=bark-ibark;
+  for(i=0;i<P_BANDS;i++){
+    /* we add back in the ATH to avoid low level curves falling off to
+       -infinity and unnecessarily cutting off high level curves in the
+       curve limiting (last step). */
+
+    /* A half-band's settings must be valid over the whole band, and
+       it's better to mask too little than too much */
+    int ath_offset=i*4;
+    for(j=0;j<EHMER_MAX;j++){
+      float min=999.;
+      for(k=0;k<4;k++)
+        if(j+k+ath_offset<MAX_ATH){
+          if(min>ATH[j+k+ath_offset])min=ATH[j+k+ath_offset];
+        }else{
+          if(min>ATH[MAX_ATH-1])min=ATH[MAX_ATH-1];
+        }
+      ath[j]=min;
+    }
 
-    if(ibark<26)
-      ath_max=ATH_Bark_dB[ibark]*(1.-del)+ATH_Bark_dB[ibark+1]*del;
-    else
-      ath_max=200.;
+    /* copy curves into working space, replicate the 50dB curve to 30
+       and 40, replicate the 100dB curve to 110 */
+    for(j=0;j<6;j++)
+      memcpy(workc[i][j+2],tonemasks[i][j],EHMER_MAX*sizeof(*tonemasks[i][j]));
+    memcpy(workc[i][0],tonemasks[i][0],EHMER_MAX*sizeof(*tonemasks[i][0]));
+    memcpy(workc[i][1],tonemasks[i][0],EHMER_MAX*sizeof(*tonemasks[i][0]));
 
-    ath[i]=min(ath_min,ath_max);
-  }
+    /* apply centered curve boost/decay */
+    for(j=0;j<P_LEVELS;j++){
+      for(k=0;k<EHMER_MAX;k++){
+        float adj=center_boost+abs(EHMER_OFFSET-k)*center_decay_rate;
+        if(adj<0. && center_boost>0)adj=0.;
+        if(adj>0. && center_boost<0)adj=0.;
+        workc[i][j][k]+=adj;
+      }
+    }
 
-  /* The c array is comes in as dB curves at 20 40 60 80 100 dB.
-     interpolate intermediate dB curves */
-  for(i=1;i<P_LEVELS;i+=2){
-    interp_curve(c[i],c[i-1],c[i+1],.5);
-  }
+    /* normalize curves so the driving amplitude is 0dB */
+    /* make temp curves with the ATH overlayed */
+    for(j=0;j<P_LEVELS;j++){
+      attenuate_curve(workc[i][j],curveatt_dB[i]+100.-(j<2?2:j)*10.-P_LEVEL_0);
+      memcpy(athc[j],ath,EHMER_MAX*sizeof(**athc));
+      attenuate_curve(athc[j],+100.-j*10.f-P_LEVEL_0);
+      max_curve(athc[j],workc[i][j]);
+    }
+
+    /* Now limit the louder curves.
+
+       the idea is this: We don't know what the playback attenuation
+       will be; 0dB SL moves every time the user twiddles the volume
+       knob. So that means we have to use a single 'most pessimal' curve
+       for all masking amplitudes, right?  Wrong.  The *loudest* sound
+       can be in (we assume) a range of ...+100dB] SL.  However, sounds
+       20dB down will be in a range ...+80], 40dB down is from ...+60],
+       etc... */
 
-  /* normalize curves so the driving amplitude is 0dB */
-  /* make temp curves with the ATH overlayed */
-  for(i=0;i<P_LEVELS;i++){
-    attenuate_curve(c[i],curveatt_dB[i]);
-    memcpy(tempc[i],ath,EHMER_MAX*sizeof(float));
-    attenuate_curve(tempc[i],-i*10.);
-    max_curve(tempc[i],c[i]);
+    for(j=1;j<P_LEVELS;j++){
+      min_curve(athc[j],athc[j-1]);
+      min_curve(workc[i][j],athc[j]);
+    }
   }
 
-  /* Now limit the louder curves.
+  for(i=0;i<P_BANDS;i++){
+    int hi_curve,lo_curve,bin;
+    ret[i]=_ogg_malloc(sizeof(**ret)*P_LEVELS);
+
+    /* low frequency curves are measured with greater resolution than
+       the MDCT/FFT will actually give us; we want the curve applied
+       to the tone data to be pessimistic and thus apply the minimum
+       masking possible for a given bin.  That means that a single bin
+       could span more than one octave and that the curve will be a
+       composite of multiple octaves.  It also may mean that a single
+       bin may span > an eighth of an octave and that the eighth
+       octave values may also be composited. */
+
+    /* which octave curves will we be compositing? */
+    bin=floor(fromOC(i*.5)/binHz);
+    lo_curve=  ceil(toOC(bin*binHz+1)*2);
+    hi_curve=  floor(toOC((bin+1)*binHz)*2);
+    if(lo_curve>i)lo_curve=i;
+    if(lo_curve<0)lo_curve=0;
+    if(hi_curve>=P_BANDS)hi_curve=P_BANDS-1;
+
+    for(m=0;m<P_LEVELS;m++){
+      ret[i][m]=_ogg_malloc(sizeof(***ret)*(EHMER_MAX+2));
+
+      for(j=0;j<n;j++)brute_buffer[j]=999.;
+
+      /* render the curve into bins, then pull values back into curve.
+         The point is that any inherent subsampling aliasing results in
+         a safe minimum */
+      for(k=lo_curve;k<=hi_curve;k++){
+        int l=0;
+
+        for(j=0;j<EHMER_MAX;j++){
+          int lo_bin= fromOC(j*.125+k*.5-2.0625)/binHz;
+          int hi_bin= fromOC(j*.125+k*.5-1.9375)/binHz+1;
+
+          if(lo_bin<0)lo_bin=0;
+          if(lo_bin>n)lo_bin=n;
+          if(lo_bin<l)l=lo_bin;
+          if(hi_bin<0)hi_bin=0;
+          if(hi_bin>n)hi_bin=n;
+
+          for(;l<hi_bin && l<n;l++)
+            if(brute_buffer[l]>workc[k][m][j])
+              brute_buffer[l]=workc[k][m][j];
+        }
+
+        for(;l<n;l++)
+          if(brute_buffer[l]>workc[k][m][EHMER_MAX-1])
+            brute_buffer[l]=workc[k][m][EHMER_MAX-1];
+
+      }
 
-     the idea is this: We don't know what the playback attenuation
-     will be; 0dB SL moves every time the user twiddles the volume
-     knob. So that means we have to use a single 'most pessimal' curve
-     for all masking amplitudes, right?  Wrong.  The *loudest* sound
-     can be in (we assume) a range of ...+100dB] SL.  However, sounds
-     20dB down will be in a range ...+80], 40dB down is from ...+60],
-     etc... */
+      /* be equally paranoid about being valid up to next half ocatve */
+      if(i+1<P_BANDS){
+        int l=0;
+        k=i+1;
+        for(j=0;j<EHMER_MAX;j++){
+          int lo_bin= fromOC(j*.125+i*.5-2.0625)/binHz;
+          int hi_bin= fromOC(j*.125+i*.5-1.9375)/binHz+1;
+
+          if(lo_bin<0)lo_bin=0;
+          if(lo_bin>n)lo_bin=n;
+          if(lo_bin<l)l=lo_bin;
+          if(hi_bin<0)hi_bin=0;
+          if(hi_bin>n)hi_bin=n;
+
+          for(;l<hi_bin && l<n;l++)
+            if(brute_buffer[l]>workc[k][m][j])
+              brute_buffer[l]=workc[k][m][j];
+        }
+
+        for(;l<n;l++)
+          if(brute_buffer[l]>workc[k][m][EHMER_MAX-1])
+            brute_buffer[l]=workc[k][m][EHMER_MAX-1];
+
+      }
 
-  for(j=1;j<P_LEVELS;j++){
-    min_curve(tempc[j],tempc[j-1]);
-    min_curve(c[j],tempc[j]);
-  }
 
-  /* take things out of dB domain into linear amplitude */
-  for(i=0;i<P_LEVELS;i++)
-    linear_curve(c[i]);
+      for(j=0;j<EHMER_MAX;j++){
+        int bin=fromOC(j*.125+i*.5-2.)/binHz;
+        if(bin<0){
+          ret[i][m][j+2]=-999.;
+        }else{
+          if(bin>=n){
+            ret[i][m][j+2]=-999.;
+          }else{
+            ret[i][m][j+2]=brute_buffer[bin];
+          }
+        }
+      }
+
+      /* add fenceposts */
+      for(j=0;j<EHMER_OFFSET;j++)
+        if(ret[i][m][j+2]>-200.f)break;
+      ret[i][m][0]=j;
 
+      for(j=EHMER_MAX-1;j>EHMER_OFFSET+1;j--)
+        if(ret[i][m][j+2]>-200.f)
+          break;
+      ret[i][m][1]=j;
+
+    }
+  }
+
+  return(ret);
 }
 
-void _vp_psy_init(vorbis_look_psy *p,vorbis_info_psy *vi,int n,long rate){
-  long i,j;
-  memset(p,0,sizeof(vorbis_look_psy));
-  p->ath=_ogg_malloc(n*sizeof(float));
-  p->octave=_ogg_malloc(n*sizeof(int));
-  p->bark=_ogg_malloc(n*sizeof(float));
+void _vp_psy_init(vorbis_look_psy *p,vorbis_info_psy *vi,
+                  vorbis_info_psy_global *gi,int n,long rate){
+  long i,j,lo=-99,hi=1;
+  long maxoc;
+  memset(p,0,sizeof(*p));
+
+  p->eighth_octave_lines=gi->eighth_octave_lines;
+  p->shiftoc=rint(log(gi->eighth_octave_lines*8.f)/log(2.f))-1;
+
+  p->firstoc=toOC(.25f*rate*.5/n)*(1<<(p->shiftoc+1))-gi->eighth_octave_lines;
+  maxoc=toOC((n+.25f)*rate*.5/n)*(1<<(p->shiftoc+1))+.5f;
+  p->total_octave_lines=maxoc-p->firstoc+1;
+  p->ath=_ogg_malloc(n*sizeof(*p->ath));
+
+  p->octave=_ogg_malloc(n*sizeof(*p->octave));
+  p->bark=_ogg_malloc(n*sizeof(*p->bark));
   p->vi=vi;
   p->n=n;
+  p->rate=rate;
+
+  /* AoTuV HF weighting */
+  p->m_val = 1.;
+  if(rate < 26000) p->m_val = 0;
+  else if(rate < 38000) p->m_val = .94;   /* 32kHz */
+  else if(rate > 46000) p->m_val = 1.275; /* 48kHz */
 
   /* set up the lookups for a given blocksize and sample rate */
-  /* Vorbis max sample rate is limited by 26 Bark (54kHz) */
-  set_curve(ATH_Bark_dB, p->ath,n,rate);
-  for(i=0;i<n;i++)
-    p->ath[i]=fromdB(p->ath[i]);
-  for(i=0;i<n;i++)
-    p->bark[i]=toBARK(rate/(2*n)*i); 
+
+  for(i=0,j=0;i<MAX_ATH-1;i++){
+    int endpos=rint(fromOC((i+1)*.125-2.)*2*n/rate);
+    float base=ATH[i];
+    if(j<endpos){
+      float delta=(ATH[i+1]-base)/(endpos-j);
+      for(;j<endpos && j<n;j++){
+        p->ath[j]=base+100.;
+        base+=delta;
+      }
+    }
+  }
+
+  for(;j<n;j++){
+    p->ath[j]=p->ath[j-1];
+  }
 
   for(i=0;i<n;i++){
-    int oc=toOC((i+.5)*rate/(2*n))*2.+2; /* half octaves, actually */
-    if(oc<0)oc=0;
-    if(oc>=P_BANDS)oc=P_BANDS-1;
-    p->octave[i]=oc;
-  }  
-
-  p->tonecurves=_ogg_malloc(P_BANDS*sizeof(float **));
-  p->noiseatt=_ogg_malloc(P_BANDS*sizeof(float **));
-  p->peakatt=_ogg_malloc(P_BANDS*sizeof(float *));
-  for(i=0;i<P_BANDS;i++){
-    p->tonecurves[i]=_ogg_malloc(P_LEVELS*sizeof(float *));
-    p->noiseatt[i]=_ogg_malloc(P_LEVELS*sizeof(float));
-    p->peakatt[i]=_ogg_malloc(P_LEVELS*sizeof(float));
+    float bark=toBARK(rate/(2*n)*i);
+
+    for(;lo+vi->noisewindowlomin<i &&
+          toBARK(rate/(2*n)*lo)<(bark-vi->noisewindowlo);lo++);
+
+    for(;hi<=n && (hi<i+vi->noisewindowhimin ||
+          toBARK(rate/(2*n)*hi)<(bark+vi->noisewindowhi));hi++);
+
+    p->bark[i]=((lo-1)<<16)+(hi-1);
+
   }
 
-  for(i=0;i<P_BANDS;i++)
-    for(j=0;j<P_LEVELS;j++){
-      p->tonecurves[i][j]=_ogg_malloc(EHMER_MAX*sizeof(float));
-    }
+  for(i=0;i<n;i++)
+    p->octave[i]=toOC((i+.25f)*.5*rate/n)*(1<<(p->shiftoc+1))+.5f;
 
-  /* OK, yeah, this was a silly way to do it */
-  memcpy(p->tonecurves[0][4],tone_125_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[0][6],tone_125_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[0][8],tone_125_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[0][10],tone_125_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[2][4],tone_125_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[2][6],tone_125_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[2][8],tone_125_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[2][10],tone_125_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[4][4],tone_250_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[4][6],tone_250_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[4][8],tone_250_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[4][10],tone_250_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[6][4],tone_500_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[6][6],tone_500_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[6][8],tone_500_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[6][10],tone_500_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[8][4],tone_1000_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[8][6],tone_1000_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[8][8],tone_1000_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[8][10],tone_1000_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[10][4],tone_2000_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[10][6],tone_2000_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[10][8],tone_2000_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[10][10],tone_2000_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[12][4],tone_4000_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[12][6],tone_4000_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[12][8],tone_4000_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[12][10],tone_4000_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[14][4],tone_8000_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[14][6],tone_8000_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[14][8],tone_8000_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[14][10],tone_8000_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  memcpy(p->tonecurves[16][4],tone_8000_40dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[16][6],tone_8000_60dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[16][8],tone_8000_80dB_SL,sizeof(float)*EHMER_MAX);
-  memcpy(p->tonecurves[16][10],tone_8000_100dB_SL,sizeof(float)*EHMER_MAX);
-
-  /* interpolate curves between */
-  for(i=1;i<P_BANDS;i+=2)
-    for(j=4;j<P_LEVELS;j+=2){
-      memcpy(p->tonecurves[i][j],p->tonecurves[i-1][j],EHMER_MAX*sizeof(float));
-      /*interp_curve(p->tonecurves[i][j],
-		   p->tonecurves[i-1][j],
-		   p->tonecurves[i+1][j],.5);*/
-      min_curve(p->tonecurves[i][j],p->tonecurves[i+1][j]);
-      /*min_curve(p->tonecurves[i][j],p->tonecurves[i-1][j]);*/
-    }
+  p->tonecurves=setup_tone_curves(vi->toneatt,rate*.5/n,n,
+                                  vi->tone_centerboost,vi->tone_decay);
 
-  /*for(i=0;i<P_BANDS-1;i++)
-    for(j=4;j<P_LEVELS;j+=2)
-    min_curve(p->tonecurves[i][j],p->tonecurves[i+1][j]);*/
+  /* set up rolling noise median */
+  p->noiseoffset=_ogg_malloc(P_NOISECURVES*sizeof(*p->noiseoffset));
+  for(i=0;i<P_NOISECURVES;i++)
+    p->noiseoffset[i]=_ogg_malloc(n*sizeof(**p->noiseoffset));
 
-  /* set up the final curves */
-  for(i=0;i<P_BANDS;i++)
-    setup_curve(p->tonecurves[i],i,vi->toneatt[i]);
+  for(i=0;i<n;i++){
+    float halfoc=toOC((i+.5)*rate/(2.*n))*2.;
+    int inthalfoc;
+    float del;
 
-  /* set up attenuation levels */
-  for(i=0;i<P_BANDS;i++)
-    for(j=0;j<P_LEVELS;j++){
-      p->peakatt[i][j]=fromdB(p->vi->peakatt[i][j]);
-      p->noiseatt[i][j]=fromdB(p->vi->noiseatt[i][j]);
-    }
+    if(halfoc<0)halfoc=0;
+    if(halfoc>=P_BANDS-1)halfoc=P_BANDS-1;
+    inthalfoc=(int)halfoc;
+    del=halfoc-inthalfoc;
+
+    for(j=0;j<P_NOISECURVES;j++)
+      p->noiseoffset[j][i]=
+        p->vi->noiseoff[j][inthalfoc]*(1.-del) +
+        p->vi->noiseoff[j][inthalfoc+1]*del;
 
+  }
+#if 0
+  {
+    static int ls=0;
+    _analysis_output_always("noiseoff0",ls,p->noiseoffset[0],n,1,0,0);
+    _analysis_output_always("noiseoff1",ls,p->noiseoffset[1],n,1,0,0);
+    _analysis_output_always("noiseoff2",ls++,p->noiseoffset[2],n,1,0,0);
+  }
+#endif
 }
 
 void _vp_psy_clear(vorbis_look_psy *p){
@@ -292,172 +362,97 @@ void _vp_psy_clear(vorbis_look_psy *p){
   if(p){
     if(p->ath)_ogg_free(p->ath);
     if(p->octave)_ogg_free(p->octave);
+    if(p->bark)_ogg_free(p->bark);
     if(p->tonecurves){
       for(i=0;i<P_BANDS;i++){
-	for(j=0;j<P_LEVELS;j++){
-	  _ogg_free(p->tonecurves[i][j]);
-	}
-	_ogg_free(p->noiseatt[i]);
-	_ogg_free(p->tonecurves[i]);
-	_ogg_free(p->peakatt[i]);
+        for(j=0;j<P_LEVELS;j++){
+          _ogg_free(p->tonecurves[i][j]);
+        }
+        _ogg_free(p->tonecurves[i]);
       }
       _ogg_free(p->tonecurves);
-      _ogg_free(p->noiseatt);
-      _ogg_free(p->peakatt);
     }
-    memset(p,0,sizeof(vorbis_look_psy));
-  }
-}
-
-static void compute_decay_fixed(vorbis_look_psy *p,float *f, float *decay, int n){
-  /* handle decay */
-  int i;
-  float decscale=fromdB(p->vi->decay_coeff*n); 
-  float attscale=1./fromdB(p->vi->attack_coeff); 
-
-  for(i=10;i<n;i++){
-    float pre=decay[i];
-    if(decay[i]){
-      float val=decay[i]*decscale;
-      float att=fabs(f[i]/val);
-
-      if(att>attscale)
-	decay[i]=fabs(f[i]/attscale);
-      else
-	decay[i]=val;
-    }else{
-      decay[i]=fabs(f[i]/attscale);
+    if(p->noiseoffset){
+      for(i=0;i<P_NOISECURVES;i++){
+        _ogg_free(p->noiseoffset[i]);
+      }
+      _ogg_free(p->noiseoffset);
     }
-    if(pre>f[i])f[i]=pre;
+    memset(p,0,sizeof(*p));
   }
 }
 
-static long _eights[EHMER_MAX+1]={
-  981,1069,1166,1272,
-  1387,1512,1649,1798,
-  1961,2139,2332,2543,
-  2774,3025,3298,3597,
-  3922,4277,4664,5087,
-  5547,6049,6597,7194,
-  7845,8555,9329,10173,
-  11094,12098,13193,14387,
-  15689,17109,18658,20347,
-  22188,24196,26386,28774,
-  31379,34219,37316,40693,
-  44376,48393,52772,57549,
-  62757,68437,74631,81386,
-  88752,96785,105545,115097,
-  125515};
-
-static int seed_curve(float *flr,
-		      float **curves,
-		       float amp,float specmax,
-		       int x,int n,float specatt,
-		       int maxEH){
-  int i;
-  float *curve;
-
-  /* make this attenuation adjustable */
-  int choice=(int)((todB(amp)-specmax+specatt)/10.+.5);
+/* octave/(8*eighth_octave_lines) x scale and dB y scale */
+static void seed_curve(float *seed,
+                       const float **curves,
+                       float amp,
+                       int oc, int n,
+                       int linesper,float dBoffset){
+  int i,post1;
+  int seedptr;
+  const float *posts,*curve;
+
+  int choice=(int)((amp+dBoffset-P_LEVEL_0)*.1f);
   choice=max(choice,0);
   choice=min(choice,P_LEVELS-1);
-
-  for(i=maxEH;i>=0;i--)
-    if(((x*_eights[i])>>12)<n)break;
-  maxEH=i;
-  curve=curves[choice];
-
-  for(;i>=0;i--)
-    if(curve[i]>0.)break;
-  
-  for(;i>=0;i--){
-    float lin=curve[i];
-    if(lin>0.){
-      float *fp=flr+((x*_eights[i])>>12);
-      lin*=amp;	
-      if(*fp<lin)*fp=lin;
-    }else break;
-  }    
-  return(maxEH);
-}
-
-static void seed_peak(float *flr,
-		      float *att,
-		      float amp,float specmax,
-		      int x,int n,float specatt){
-  int prevx=(x*_eights[16])>>12;
-
-  /* make this attenuation adjustable */
-  int choice=rint((todB(amp)-specmax+specatt)/10.+.5);
-  if(choice<0)choice=0;
-  if(choice>=P_LEVELS)choice=P_LEVELS-1;
-
-  if(prevx<n){
-    float lin=att[choice];
-    if(lin){
-      lin*=amp;	
-      if(flr[prevx]<lin)flr[prevx]=lin;
+  posts=curves[choice];
+  curve=posts+2;
+  post1=(int)posts[1];
+  seedptr=oc+(posts[0]-EHMER_OFFSET)*linesper-(linesper>>1);
+
+  for(i=posts[0];i<post1;i++){
+    if(seedptr>0){
+      float lin=amp+curve[i];
+      if(seed[seedptr]<lin)seed[seedptr]=lin;
     }
+    seedptr+=linesper;
+    if(seedptr>=n)break;
   }
 }
 
-static void seed_generic(vorbis_look_psy *p,
-			 float ***curves,
-			 float *f, 
-			 float *flr,
-			 float *seeds,
-			 float specmax){
+static void seed_loop(vorbis_look_psy *p,
+                      const float ***curves,
+                      const float *f,
+                      const float *flr,
+                      float *seed,
+                      float specmax){
   vorbis_info_psy *vi=p->vi;
   long n=p->n,i;
-  int maxEH=EHMER_MAX-1;
+  float dBoffset=vi->max_curve_dB-specmax;
 
   /* prime the working vector with peak values */
-  /* Use the 125 Hz curve up to 125 Hz and 8kHz curve after 8kHz. */
-  for(i=0;i<n;i++)
-    if(f[i]>flr[i])
-      maxEH=seed_curve(seeds,curves[p->octave[i]],
-		       f[i],specmax,i,n,vi->max_curve_dB,maxEH);
-}
-
-static void seed_att(vorbis_look_psy *p,
-		     float **att,
-		     float *f, 
-		     float *flr,
-		     float specmax){
-  vorbis_info_psy *vi=p->vi;
-  long n=p->n,i;
-  
-  for(i=0;i<n;i++)
-    if(f[i]>flr[i])
-      seed_peak(flr,att[p->octave[i]],f[i],
-		specmax,i,n,vi->max_curve_dB);
-}
 
-static void seed_point(vorbis_look_psy *p,
-		     float **att,
-		     float *f, 
-		     float *flr,
-		     float specmax){
-  vorbis_info_psy *vi=p->vi;
-  long n=p->n,i;
-  
   for(i=0;i<n;i++){
-    /* make this attenuation adjustable */
-    int choice=rint((todB(f[i])-specmax+vi->max_curve_dB)/10.+.5);
-    float lin;
-    if(choice<0)choice=0;
-    if(choice>=P_LEVELS)choice=P_LEVELS-1;
-    lin=att[p->octave[i]][choice]*f[i];
-    if(flr[i]<lin)flr[i]=lin;
+    float max=f[i];
+    long oc=p->octave[i];
+    while(i+1<n && p->octave[i+1]==oc){
+      i++;
+      if(f[i]>max)max=f[i];
+    }
+
+    if(max+6.f>flr[i]){
+      oc=oc>>p->shiftoc;
+
+      if(oc>=P_BANDS)oc=P_BANDS-1;
+      if(oc<0)oc=0;
+
+      seed_curve(seed,
+                 curves[oc],
+                 max,
+                 p->octave[i]-p->firstoc,
+                 p->total_octave_lines,
+                 p->eighth_octave_lines,
+                 dBoffset);
+    }
   }
 }
 
-/* bleaugh, this is more complicated than it needs to be */
-static void max_seeds(vorbis_look_psy *p,float *seeds,float *flr){
-  long n=p->n,i,j;
-  long *posstack=alloca(n*sizeof(long));
-  float *ampstack=alloca(n*sizeof(float));
-  long stack=0;
+static void seed_chase(float *seeds, int linesper, long n){
+  long  *posstack=alloca(n*sizeof(*posstack));
+  float *ampstack=alloca(n*sizeof(*ampstack));
+  long   stack=0;
+  long   pos=0;
+  long   i;
 
   for(i=0;i<n;i++){
     if(stack<2){
@@ -465,254 +460,750 @@ static void max_seeds(vorbis_look_psy *p,float *seeds,float *flr){
       ampstack[stack++]=seeds[i];
     }else{
       while(1){
-	if(seeds[i]<ampstack[stack-1]){
-	  posstack[stack]=i;
-	  ampstack[stack++]=seeds[i];
-	  break;
-	}else{
-	  if(i<posstack[stack-1]*1.0905077080){
-	    if(stack>1 && ampstack[stack-1]<ampstack[stack-2] &&
-	       i<posstack[stack-2]*1.0905077080){
-	      /* we completely overlap, making stack-1 irrelevant.  pop it */
-	      stack--;
-	      continue;
-	    }
-	  }
-	  posstack[stack]=i;
-	  ampstack[stack++]=seeds[i];
-	  break;
-
-	}
+        if(seeds[i]<ampstack[stack-1]){
+          posstack[stack]=i;
+          ampstack[stack++]=seeds[i];
+          break;
+        }else{
+          if(i<posstack[stack-1]+linesper){
+            if(stack>1 && ampstack[stack-1]<=ampstack[stack-2] &&
+               i<posstack[stack-2]+linesper){
+              /* we completely overlap, making stack-1 irrelevant.  pop it */
+              stack--;
+              continue;
+            }
+          }
+          posstack[stack]=i;
+          ampstack[stack++]=seeds[i];
+          break;
+
+        }
       }
     }
   }
 
   /* the stack now contains only the positions that are relevant. Scan
      'em straight through */
-  {
-    long pos=0;
-    for(i=0;i<stack;i++){
-      long endpos;
-      if(i<stack-1 && ampstack[i+1]>ampstack[i]){
-	endpos=posstack[i+1];
-      }else{
-	endpos=posstack[i]*1.0905077080+1; /* +1 is important, else bin 0 is
-                                       discarded in short frames */
-      }
-      if(endpos>n)endpos=n;
-      for(j=pos;j<endpos;j++)
-	if(flr[j]<ampstack[i])
-	  flr[j]=ampstack[i];
-      pos=endpos;
+
+  for(i=0;i<stack;i++){
+    long endpos;
+    if(i<stack-1 && ampstack[i+1]>ampstack[i]){
+      endpos=posstack[i+1];
+    }else{
+      endpos=posstack[i]+linesper+1; /* +1 is important, else bin 0 is
+                                        discarded in short frames */
     }
-  }   
+    if(endpos>n)endpos=n;
+    for(;pos<endpos;pos++)
+      seeds[pos]=ampstack[i];
+  }
 
   /* there.  Linear time.  I now remember this was on a problem set I
      had in Grad Skool... I didn't solve it at the time ;-) */
+
 }
 
-static void bark_noise(long n,float *b,float *f,float *noise){
-  long i=1,lo=0,hi=2;
-  float acc=0.,val,del=0.;
+/* bleaugh, this is more complicated than it needs to be */
+#include<stdio.h>
+static void max_seeds(vorbis_look_psy *p,
+                      float *seed,
+                      float *flr){
+  long   n=p->total_octave_lines;
+  int    linesper=p->eighth_octave_lines;
+  long   linpos=0;
+  long   pos;
+
+  seed_chase(seed,linesper,n); /* for masking */
+
+  pos=p->octave[0]-p->firstoc-(linesper>>1);
+
+  while(linpos+1<p->n){
+    float minV=seed[pos];
+    long end=((p->octave[linpos]+p->octave[linpos+1])>>1)-p->firstoc;
+    if(minV>p->vi->tone_abs_limit)minV=p->vi->tone_abs_limit;
+    while(pos+1<=end){
+      pos++;
+      if((seed[pos]>NEGINF && seed[pos]<minV) || minV==NEGINF)
+        minV=seed[pos];
+    }
+
+    end=pos+p->firstoc;
+    for(;linpos<p->n && p->octave[linpos]<=end;linpos++)
+      if(flr[linpos]<minV)flr[linpos]=minV;
+  }
+
+  {
+    float minV=seed[p->total_octave_lines-1];
+    for(;linpos<p->n;linpos++)
+      if(flr[linpos]<minV)flr[linpos]=minV;
+  }
+
+}
+
+static void bark_noise_hybridmp(int n,const long *b,
+                                const float *f,
+                                float *noise,
+                                const float offset,
+                                const int fixed){
+
+  float *N=alloca(n*sizeof(*N));
+  float *X=alloca(n*sizeof(*N));
+  float *XX=alloca(n*sizeof(*N));
+  float *Y=alloca(n*sizeof(*N));
+  float *XY=alloca(n*sizeof(*N));
+
+  float tN, tX, tXX, tY, tXY;
+  int i;
+
+  int lo, hi;
+  float R=0.f;
+  float A=0.f;
+  float B=0.f;
+  float D=1.f;
+  float w, x, y;
+
+  tN = tX = tXX = tY = tXY = 0.f;
+
+  y = f[0] + offset;
+  if (y < 1.f) y = 1.f;
+
+  w = y * y * .5;
 
-  float *norm=alloca(n*sizeof(float));
+  tN += w;
+  tX += w;
+  tY += w * y;
 
-  memset(noise,0,n*sizeof(float));
-  memset(norm,0,n*sizeof(float));
+  N[0] = tN;
+  X[0] = tX;
+  XX[0] = tXX;
+  Y[0] = tY;
+  XY[0] = tXY;
 
-  while(hi<n){
-    val=todB_nn(f[i]*f[i])+400.;
-    del=1./(i-lo);
-    noise[lo]+=val*del;
-    noise[i]-=val*del;
-    norm[lo]+=del;
-    norm[i]-=del;
- 
-    del=1./(hi-i);
-    noise[i]-=val*del;
-    noise[hi]+=val*del;
-    norm[hi]+=del;
-    norm[i]-=del;
-    
+  for (i = 1, x = 1.f; i < n; i++, x += 1.f) {
 
-    i++;
-    for(;hi<n && b[hi]-.3<b[i];hi++);
-    for(;lo<i-1 && b[lo]+.3<b[i];lo++);
-    if(i==hi)hi++;
+    y = f[i] + offset;
+    if (y < 1.f) y = 1.f;
+
+    w = y * y;
+
+    tN += w;
+    tX += w * x;
+    tXX += w * x * x;
+    tY += w * y;
+    tXY += w * x * y;
+
+    N[i] = tN;
+    X[i] = tX;
+    XX[i] = tXX;
+    Y[i] = tY;
+    XY[i] = tXY;
   }
 
-  {
-    long ilo=i-lo;
-    long hii=hi-i;
-
-    for(;i<n;i++){
-      val=todB_nn(f[i]*f[i])+400.;
-      del=1./(hii);
-      noise[i]-=val*del;
-      norm[i]-=del;
-     
-      del=1./(ilo);
-      noise[i-ilo]+=val*del;
-      noise[i]-=val*del;      
-      norm[i-ilo]+=del;
-      norm[i]-=del;      
-    }
-    for(i=1,lo=n-ilo;lo<n;lo++,i++){
-      val=todB_nn(f[n-i]*f[n-i])+400.;
-      del=1./ilo;
-      noise[lo]+=val*del;
-      norm[lo]+=del;
-    }
+  for (i = 0, x = 0.f; i < n; i++, x += 1.f) {
+
+    lo = b[i] >> 16;
+    hi = b[i] & 0xffff;
+    if( lo>=0 || -lo>=n ) break;
+    if( hi>=n ) break;
+
+    tN = N[hi] + N[-lo];
+    tX = X[hi] - X[-lo];
+    tXX = XX[hi] + XX[-lo];
+    tY = Y[hi] + Y[-lo];
+    tXY = XY[hi] - XY[-lo];
+
+    A = tY * tXX - tX * tXY;
+    B = tN * tXY - tX * tY;
+    D = tN * tXX - tX * tX;
+    R = (A + x * B) / D;
+    if (R < 0.f) R = 0.f;
+
+    noise[i] = R - offset;
   }
 
+  for ( ; i < n; i++, x += 1.f) {
 
-  acc=0;
-  val=0;
+    lo = b[i] >> 16;
+    hi = b[i] & 0xffff;
+    if( lo<0 || lo>=n ) break;
+    if( hi>=n ) break;
 
-  for(i=0;i<n;i++){
-    val+=norm[i];
-    norm[i]=val;
-    acc+=noise[i];
-    noise[i]=acc;
+    tN = N[hi] - N[lo];
+    tX = X[hi] - X[lo];
+    tXX = XX[hi] - XX[lo];
+    tY = Y[hi] - Y[lo];
+    tXY = XY[hi] - XY[lo];
+
+    A = tY * tXX - tX * tXY;
+    B = tN * tXY - tX * tY;
+    D = tN * tXX - tX * tX;
+    R = (A + x * B) / D;
+    if (R < 0.f) R = 0.f;
+
+    noise[i] = R - offset;
   }
 
-  val=0;
-  acc=0;
-  for(i=0;i<n;i++){
-    val+=norm[i];
-    acc+=noise[i];
-    if(val==0){
-      noise[i]=0.;
-      norm[i]=0;
-    }else{
-      float v=acc/val-400;
-      noise[i]=sqrt(fromdB(v));
-    }
+  for ( ; i < n; i++, x += 1.f) {
+
+    R = (A + x * B) / D;
+    if (R < 0.f) R = 0.f;
+
+    noise[i] = R - offset;
   }
-}
 
-void _vp_compute_mask(vorbis_look_psy *p,float *f, 
-		      float *flr, 
-		      float *decay){
-  float *smooth=alloca(sizeof(float)*p->n);
-  int i,n=p->n;
-  float specmax=0.;
-  static int seq=0;
-
-  float *seed=alloca(sizeof(float)*p->n);
-  float *seed2=alloca(sizeof(float)*p->n);
-
-  _analysis_output("mdct",seq,f,n,1,1);
-  memset(flr,0,n*sizeof(float));
-
-  /* noise masking */
-  if(p->vi->noisemaskp){
-    memset(seed,0,n*sizeof(float));
-    bark_noise(n,p->bark,f,seed);
-    seed_point(p,p->noiseatt,seed,flr,specmax);
-
-  }
-
-  /* smooth the data is that's called for ********************************/
-  for(i=0;i<n;i++)smooth[i]=fabs(f[i]);
-  if(p->vi->smoothp){
-    /* compute power^.5 of three neighboring bins to smooth for peaks
-       that get split twixt bins/peaks that nail the bin.  This evens
-       out treatment as we're not doing additive masking any longer. */
-    float acc=smooth[0]*smooth[0]+smooth[1]*smooth[1];
-    float prev=smooth[0];
-
-    smooth[0]=sqrt(acc);
-    for(i=1;i<n-1;i++){
-      float this=smooth[i];
-      acc+=smooth[i+1]*smooth[i+1];
-      if(acc<0)acc=0; /* it can happen due to finite precision */
-      smooth[i]=sqrt(acc);
-      acc-=prev*prev;
-      prev=this;
-    }
-    if(acc<0)acc=0; /* in case it happens on the final iteration */
-    smooth[n-1]=sqrt(acc);
+  if (fixed <= 0) return;
+
+  for (i = 0, x = 0.f; i < n; i++, x += 1.f) {
+    hi = i + fixed / 2;
+    lo = hi - fixed;
+    if ( hi>=n ) break;
+    if ( lo>=0 ) break;
+
+    tN = N[hi] + N[-lo];
+    tX = X[hi] - X[-lo];
+    tXX = XX[hi] + XX[-lo];
+    tY = Y[hi] + Y[-lo];
+    tXY = XY[hi] - XY[-lo];
+
+
+    A = tY * tXX - tX * tXY;
+    B = tN * tXY - tX * tY;
+    D = tN * tXX - tX * tX;
+    R = (A + x * B) / D;
+
+    if (R - offset < noise[i]) noise[i] = R - offset;
   }
+  for ( ; i < n; i++, x += 1.f) {
 
-  _analysis_output("smooth",seq,smooth,n,1,1);
+    hi = i + fixed / 2;
+    lo = hi - fixed;
+    if ( hi>=n ) break;
+    if ( lo<0 ) break;
 
-  /* find the highest peak so we know the limits *************************/
-  for(i=0;i<n;i++){
-    if(smooth[i]>specmax)specmax=smooth[i];
+    tN = N[hi] - N[lo];
+    tX = X[hi] - X[lo];
+    tXX = XX[hi] - XX[lo];
+    tY = Y[hi] - Y[lo];
+    tXY = XY[hi] - XY[lo];
+
+    A = tY * tXX - tX * tXY;
+    B = tN * tXY - tX * tY;
+    D = tN * tXX - tX * tX;
+    R = (A + x * B) / D;
+
+    if (R - offset < noise[i]) noise[i] = R - offset;
+  }
+  for ( ; i < n; i++, x += 1.f) {
+    R = (A + x * B) / D;
+    if (R - offset < noise[i]) noise[i] = R - offset;
   }
-  specmax=todB(specmax);
+}
+
+void _vp_noisemask(vorbis_look_psy *p,
+                   float *logmdct,
+                   float *logmask){
+
+  int i,n=p->n;
+  float *work=alloca(n*sizeof(*work));
 
-  /* set the ATH (floating below specmax by a specified att) */
-  if(p->vi->athp){
-    float att=specmax+p->vi->ath_adjatt;
-    if(att<p->vi->ath_maxatt)att=p->vi->ath_maxatt;
-    att=fromdB(att);
+  bark_noise_hybridmp(n,p->bark,logmdct,logmask,
+                      140.,-1);
 
+  for(i=0;i<n;i++)work[i]=logmdct[i]-logmask[i];
+
+  bark_noise_hybridmp(n,p->bark,work,logmask,0.,
+                      p->vi->noisewindowfixed);
+
+  for(i=0;i<n;i++)work[i]=logmdct[i]-work[i];
+
+#if 0
+  {
+    static int seq=0;
+
+    float work2[n];
     for(i=0;i<n;i++){
-      float av=p->ath[i]*att;
-      if(av>flr[i])flr[i]=av;
+      work2[i]=logmask[i]+work[i];
     }
-  }
 
-  _analysis_output("ath",seq,flr,n,1,1);
+    if(seq&1)
+      _analysis_output("median2R",seq/2,work,n,1,0,0);
+    else
+      _analysis_output("median2L",seq/2,work,n,1,0,0);
+
+    if(seq&1)
+      _analysis_output("envelope2R",seq/2,work2,n,1,0,0);
+    else
+      _analysis_output("envelope2L",seq/2,work2,n,1,0,0);
+    seq++;
+  }
+#endif
 
-  /* peak attenuation ******/
-  if(p->vi->peakattp){
-    memset(seed,0,n*sizeof(float));
-    seed_att(p,p->peakatt,smooth,seed,specmax);
-    max_seeds(p,seed,flr);
+  for(i=0;i<n;i++){
+    int dB=logmask[i]+.5;
+    if(dB>=NOISE_COMPAND_LEVELS)dB=NOISE_COMPAND_LEVELS-1;
+    if(dB<0)dB=0;
+    logmask[i]= work[i]+p->vi->noisecompand[dB];
   }
 
+}
+
+void _vp_tonemask(vorbis_look_psy *p,
+                  float *logfft,
+                  float *logmask,
+                  float global_specmax,
+                  float local_specmax){
+
+  int i,n=p->n;
+
+  float *seed=alloca(sizeof(*seed)*p->total_octave_lines);
+  float att=local_specmax+p->vi->ath_adjatt;
+  for(i=0;i<p->total_octave_lines;i++)seed[i]=NEGINF;
+
+  /* set the ATH (floating below localmax, not global max by a
+     specified att) */
+  if(att<p->vi->ath_maxatt)att=p->vi->ath_maxatt;
+
+  for(i=0;i<n;i++)
+    logmask[i]=p->ath[i]+att;
+
   /* tone masking */
-  if(p->vi->tonemaskp){
-    memset(seed,0,n*sizeof(float));
-    memset(seed2,0,n*sizeof(float));
+  seed_loop(p,(const float ***)p->tonecurves,logfft,logmask,seed,global_specmax);
+  max_seeds(p,seed,logmask);
+
+}
 
-    seed_generic(p,p->tonecurves,smooth,flr,seed2,specmax);
-    max_seeds(p,seed2,seed2);
+void _vp_offset_and_mix(vorbis_look_psy *p,
+                        float *noise,
+                        float *tone,
+                        int offset_select,
+                        float *logmask,
+                        float *mdct,
+                        float *logmdct){
+  int i,n=p->n;
+  float de, coeffi, cx;/* AoTuV */
+  float toneatt=p->vi->tone_masteratt[offset_select];
 
-    for(i=0;i<n;i++)if(seed2[i]<flr[i])seed2[i]=flr[i];
-    for(i=0;i<n;i++)if(seed2[i]<decay[i])seed2[i]=decay[i];
+  cx = p->m_val;
 
-    seed_generic(p,p->tonecurves,smooth,seed2,seed,specmax);
-    max_seeds(p,seed,seed);
-    
-    if(p->vi->decayp)
-      compute_decay_fixed(p,seed,decay,n);
-    
-    for(i=0;i<n;i++)if(flr[i]<seed[i])flr[i]=seed[i];
-    
-  }
+  for(i=0;i<n;i++){
+    float val= noise[i]+p->noiseoffset[offset_select][i];
+    if(val>p->vi->noisemaxsupp)val=p->vi->noisemaxsupp;
+    logmask[i]=max(val,tone[i]+toneatt);
+
+
+    /* AoTuV */
+    /** @ M1 **
+        The following codes improve a noise problem.
+        A fundamental idea uses the value of masking and carries out
+        the relative compensation of the MDCT.
+        However, this code is not perfect and all noise problems cannot be solved.
+        by Aoyumi @ 2004/04/18
+    */
+
+    if(offset_select == 1) {
+      coeffi = -17.2;       /* coeffi is a -17.2dB threshold */
+      val = val - logmdct[i];  /* val == mdct line value relative to floor in dB */
+
+      if(val > coeffi){
+        /* mdct value is > -17.2 dB below floor */
+
+        de = 1.0-((val-coeffi)*0.005*cx);
+        /* pro-rated attenuation:
+           -0.00 dB boost if mdct value is -17.2dB (relative to floor)
+           -0.77 dB boost if mdct value is 0dB (relative to floor)
+           -1.64 dB boost if mdct value is +17.2dB (relative to floor)
+           etc... */
+
+        if(de < 0) de = 0.0001;
+      }else
+        /* mdct value is <= -17.2 dB below floor */
+
+        de = 1.0-((val-coeffi)*0.0003*cx);
+      /* pro-rated attenuation:
+         +0.00 dB atten if mdct value is -17.2dB (relative to floor)
+         +0.45 dB atten if mdct value is -34.4dB (relative to floor)
+         etc... */
+
+      mdct[i] *= de;
 
-  _analysis_output("final",seq,flr,n,1,1);
+    }
+  }
+}
 
-  /* doing this here is clean, but we need to find a faster way to do
-     it than to just tack it on */
+float _vp_ampmax_decay(float amp,vorbis_dsp_state *vd){
+  vorbis_info *vi=vd->vi;
+  codec_setup_info *ci=vi->codec_setup;
+  vorbis_info_psy_global *gi=&ci->psy_g_param;
 
-  for(i=0;i<n;i++)if(2.*f[i]>flr[i] || -2.*f[i]>flr[i])break;
-  if(i==n)memset(flr,0,sizeof(float)*n);
+  int n=ci->blocksizes[vd->W]/2;
+  float secs=(float)n/vi->rate;
 
-  seq++;
+  amp+=secs*gi->ampmax_att_per_sec;
+  if(amp<-9999)amp=-9999;
+  return(amp);
 }
 
+static float FLOOR1_fromdB_LOOKUP[256]={
+  1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
+  1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
+  1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
+  2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
+  2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
+  3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
+  4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
+  6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
+  7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
+  1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
+  1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
+  1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
+  2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
+  2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
+  3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
+  4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
+  5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
+  7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
+  9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
+  1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
+  1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
+  2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
+  2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
+  3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
+  4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
+  5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
+  7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
+  9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
+  0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
+  0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
+  0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
+  0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
+  0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
+  0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
+  0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
+  0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
+  0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
+  0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
+  0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
+  0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
+  0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
+  0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
+  0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
+  0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
+  0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
+  0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
+  0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
+  0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
+  0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
+  0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
+  0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
+  0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
+  0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
+  0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
+  0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
+  0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
+  0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
+  0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
+  0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
+  0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
+  0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
+  0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
+  0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
+  0.82788260F, 0.88168307F, 0.9389798F, 1.F,
+};
+
+/* this is for per-channel noise normalization */
+static int apsort(const void *a, const void *b){
+  float f1=**(float**)a;
+  float f2=**(float**)b;
+  return (f1<f2)-(f1>f2);
+}
 
-/* this applies the floor and (optionally) tries to preserve noise
-   energy in low resolution portions of the spectrum */
-/* f and flr are *linear* scale, not dB */
-void _vp_apply_floor(vorbis_look_psy *p,float *f, float *flr){
-  float *work=alloca(p->n*sizeof(float));
+static void flag_lossless(int limit, float prepoint, float postpoint, float *mdct,
+                         float *floor, int *flag, int i, int jn){
   int j;
-
-  /* subtract the floor */
-  for(j=0;j<p->n;j++){
-    if(flr[j]<=0)
-      work[j]=0.;
+  for(j=0;j<jn;j++){
+    float point = j>=limit-i ? postpoint : prepoint;
+    float r = fabs(mdct[j])/floor[j];
+    if(r<point)
+      flag[j]=0;
     else
-      work[j]=f[j]/flr[j];
+      flag[j]=1;
+  }
+}
+
+/* Overload/Side effect: On input, the *q vector holds either the
+   quantized energy (for elements with the flag set) or the absolute
+   values of the *r vector (for elements with flag unset).  On output,
+   *q holds the quantized energy for all elements */
+static float noise_normalize(vorbis_look_psy *p, int limit, float *r, float *q, float *f, int *flags, float acc, int i, int n, int *out){
+
+  vorbis_info_psy *vi=p->vi;
+  float **sort = alloca(n*sizeof(*sort));
+  int j,count=0;
+  int start = (vi->normal_p ? vi->normal_start-i : n);
+  if(start>n)start=n;
+
+  /* force classic behavior where only energy in the current band is considered */
+  acc=0.f;
+
+  /* still responsible for populating *out where noise norm not in
+     effect.  There's no need to [re]populate *q in these areas */
+  for(j=0;j<start;j++){
+    if(!flags || !flags[j]){ /* lossless coupling already quantized.
+                                Don't touch; requantizing based on
+                                energy would be incorrect. */
+      float ve = q[j]/f[j];
+      if(r[j]<0)
+        out[j] = -rint(sqrt(ve));
+      else
+        out[j] = rint(sqrt(ve));
+    }
   }
 
-  memcpy(f,work,p->n*sizeof(float));
+  /* sort magnitudes for noise norm portion of partition */
+  for(;j<n;j++){
+    if(!flags || !flags[j]){ /* can't noise norm elements that have
+                                already been loslessly coupled; we can
+                                only account for their energy error */
+      float ve = q[j]/f[j];
+      /* Despite all the new, more capable coupling code, for now we
+         implement noise norm as it has been up to this point. Only
+         consider promotions to unit magnitude from 0.  In addition
+         the only energy error counted is quantizations to zero. */
+      /* also-- the original point code only applied noise norm at > pointlimit */
+      if(ve<.25f && (!flags || j>=limit-i)){
+        acc += ve;
+        sort[count++]=q+j; /* q is fabs(r) for unflagged element */
+      }else{
+        /* For now: no acc adjustment for nonzero quantization.  populate *out and q as this value is final. */
+        if(r[j]<0)
+          out[j] = -rint(sqrt(ve));
+        else
+          out[j] = rint(sqrt(ve));
+        q[j] = out[j]*out[j]*f[j];
+      }
+    }/* else{
+        again, no energy adjustment for error in nonzero quant-- for now
+        }*/
+  }
+
+  if(count){
+    /* noise norm to do */
+    qsort(sort,count,sizeof(*sort),apsort);
+    for(j=0;j<count;j++){
+      int k=sort[j]-q;
+      if(acc>=vi->normal_thresh){
+        out[k]=unitnorm(r[k]);
+        acc-=1.f;
+        q[k]=f[k];
+      }else{
+        out[k]=0;
+        q[k]=0.f;
+      }
+    }
+  }
+
+  return acc;
 }
 
+/* Noise normalization, quantization and coupling are not wholly
+   seperable processes in depth>1 coupling. */
+void _vp_couple_quantize_normalize(int blobno,
+                                   vorbis_info_psy_global *g,
+                                   vorbis_look_psy *p,
+                                   vorbis_info_mapping0 *vi,
+                                   float **mdct,
+                                   int   **iwork,
+                                   int    *nonzero,
+                                   int     sliding_lowpass,
+                                   int     ch){
+
+  int i;
+  int n = p->n;
+  int partition=(p->vi->normal_p ? p->vi->normal_partition : 16);
+  int limit = g->coupling_pointlimit[p->vi->blockflag][blobno];
+  float prepoint=stereo_threshholds[g->coupling_prepointamp[blobno]];
+  float postpoint=stereo_threshholds[g->coupling_postpointamp[blobno]];
+#if 0
+  float de=0.1*p->m_val; /* a blend of the AoTuV M2 and M3 code here and below */
+#endif
+
+  /* mdct is our raw mdct output, floor not removed. */
+  /* inout passes in the ifloor, passes back quantized result */
+
+  /* unquantized energy (negative indicates amplitude has negative sign) */
+  float **raw = alloca(ch*sizeof(*raw));
+
+  /* dual pupose; quantized energy (if flag set), othersize fabs(raw) */
+  float **quant = alloca(ch*sizeof(*quant));
+
+  /* floor energy */
+  float **floor = alloca(ch*sizeof(*floor));
+
+  /* flags indicating raw/quantized status of elements in raw vector */
+  int   **flag  = alloca(ch*sizeof(*flag));
+
+  /* non-zero flag working vector */
+  int    *nz    = alloca(ch*sizeof(*nz));
+
+  /* energy surplus/defecit tracking */
+  float  *acc   = alloca((ch+vi->coupling_steps)*sizeof(*acc));
+
+  /* The threshold of a stereo is changed with the size of n */
+  if(n > 1000)
+    postpoint=stereo_threshholds_limited[g->coupling_postpointamp[blobno]];
+
+  raw[0]   = alloca(ch*partition*sizeof(**raw));
+  quant[0] = alloca(ch*partition*sizeof(**quant));
+  floor[0] = alloca(ch*partition*sizeof(**floor));
+  flag[0]  = alloca(ch*partition*sizeof(**flag));
+
+  for(i=1;i<ch;i++){
+    raw[i]   = &raw[0][partition*i];
+    quant[i] = &quant[0][partition*i];
+    floor[i] = &floor[0][partition*i];
+    flag[i]  = &flag[0][partition*i];
+  }
+  for(i=0;i<ch+vi->coupling_steps;i++)
+    acc[i]=0.f;
+
+  for(i=0;i<n;i+=partition){
+    int k,j,jn = partition > n-i ? n-i : partition;
+    int step,track = 0;
+
+    memcpy(nz,nonzero,sizeof(*nz)*ch);
+
+    /* prefill */
+    memset(flag[0],0,ch*partition*sizeof(**flag));
+    for(k=0;k<ch;k++){
+      int *iout = &iwork[k][i];
+      if(nz[k]){
 
+        for(j=0;j<jn;j++)
+          floor[k][j] = FLOOR1_fromdB_LOOKUP[iout[j]];
+
+        flag_lossless(limit,prepoint,postpoint,&mdct[k][i],floor[k],flag[k],i,jn);
+
+        for(j=0;j<jn;j++){
+          quant[k][j] = raw[k][j] = mdct[k][i+j]*mdct[k][i+j];
+          if(mdct[k][i+j]<0.f) raw[k][j]*=-1.f;
+          floor[k][j]*=floor[k][j];
+        }
+
+        acc[track]=noise_normalize(p,limit,raw[k],quant[k],floor[k],NULL,acc[track],i,jn,iout);
+
+      }else{
+        for(j=0;j<jn;j++){
+          floor[k][j] = 1e-10f;
+          raw[k][j] = 0.f;
+          quant[k][j] = 0.f;
+          flag[k][j] = 0;
+          iout[j]=0;
+        }
+        acc[track]=0.f;
+      }
+      track++;
+    }
+
+    /* coupling */
+    for(step=0;step<vi->coupling_steps;step++){
+      int Mi = vi->coupling_mag[step];
+      int Ai = vi->coupling_ang[step];
+      int *iM = &iwork[Mi][i];
+      int *iA = &iwork[Ai][i];
+      float *reM = raw[Mi];
+      float *reA = raw[Ai];
+      float *qeM = quant[Mi];
+      float *qeA = quant[Ai];
+      float *floorM = floor[Mi];
+      float *floorA = floor[Ai];
+      int *fM = flag[Mi];
+      int *fA = flag[Ai];
+
+      if(nz[Mi] || nz[Ai]){
+        nz[Mi] = nz[Ai] = 1;
+
+        for(j=0;j<jn;j++){
+
+          if(j<sliding_lowpass-i){
+            if(fM[j] || fA[j]){
+              /* lossless coupling */
+
+              reM[j] = fabs(reM[j])+fabs(reA[j]);
+              qeM[j] = qeM[j]+qeA[j];
+              fM[j]=fA[j]=1;
+
+              /* couple iM/iA */
+              {
+                int A = iM[j];
+                int B = iA[j];
+
+                if(abs(A)>abs(B)){
+                  iA[j]=(A>0?A-B:B-A);
+                }else{
+                  iA[j]=(B>0?A-B:B-A);
+                  iM[j]=B;
+                }
+
+                /* collapse two equivalent tuples to one */
+                if(iA[j]>=abs(iM[j])*2){
+                  iA[j]= -iA[j];
+                  iM[j]= -iM[j];
+                }
+
+              }
+
+            }else{
+              /* lossy (point) coupling */
+              if(j<limit-i){
+                /* dipole */
+                reM[j] += reA[j];
+                qeM[j] = fabs(reM[j]);
+              }else{
+#if 0
+                /* AoTuV */
+                /** @ M2 **
+                    The boost problem by the combination of noise normalization and point stereo is eased.
+                    However, this is a temporary patch.
+                    by Aoyumi @ 2004/04/18
+                */
+                float derate = (1.0 - de*((float)(j-limit+i) / (float)(n-limit)));
+                /* elliptical */
+                if(reM[j]+reA[j]<0){
+                  reM[j] = - (qeM[j] = (fabs(reM[j])+fabs(reA[j]))*derate*derate);
+                }else{
+                  reM[j] =   (qeM[j] = (fabs(reM[j])+fabs(reA[j]))*derate*derate);
+                }
+#else
+                /* elliptical */
+                if(reM[j]+reA[j]<0){
+                  reM[j] = - (qeM[j] = fabs(reM[j])+fabs(reA[j]));
+                }else{
+                  reM[j] =   (qeM[j] = fabs(reM[j])+fabs(reA[j]));
+                }
+#endif
+
+              }
+              reA[j]=qeA[j]=0.f;
+              fA[j]=1;
+              iA[j]=0;
+            }
+          }
+          floorM[j]=floorA[j]=floorM[j]+floorA[j];
+        }
+        /* normalize the resulting mag vector */
+        acc[track]=noise_normalize(p,limit,raw[Mi],quant[Mi],floor[Mi],flag[Mi],acc[track],i,jn,iM);
+        track++;
+      }
+    }
+  }
+
+  for(i=0;i<vi->coupling_steps;i++){
+    /* make sure coupling a zero and a nonzero channel results in two
+       nonzero channels. */
+    if(nonzero[vi->coupling_mag[i]] ||
+       nonzero[vi->coupling_ang[i]]){
+      nonzero[vi->coupling_mag[i]]=1;
+      nonzero[vi->coupling_ang[i]]=1;
+    }
+  }
+}