WDL/verbengine.h

   1 #ifndef _VERBENGINE_H_
   2 #define _VERBENGINE_H_
   3
   4
   5 /*
   6     WDL - verbengine.h
   7     Copyright (C) 2007 and later Cockos Incorporated
   8
   9     This is based on the public domain FreeVerb source:
  10       by Jezar at Dreampoint, June 2000
  11       http://www.dreampoint.co.uk
  12
  13     Filter tweaks and general guidance thanks to Thomas Scott Stillwell.
  14
  15     This software is provided 'as-is', without any express or implied
  16     warranty.  In no event will the authors be held liable for any damages
  17     arising from the use of this software.
  18
  19     Permission is granted to anyone to use this software for any purpose,
  20     including commercial applications, and to alter it and redistribute it
  21     freely, subject to the following restrictions:
  22
  23     1. The origin of this software must not be misrepresented; you must not
  24        claim that you wrote the original software. If you use this software
  25        in a product, an acknowledgment in the product documentation would be
  26        appreciated but is not required.
  27     2. Altered source versions must be plainly marked as such, and must not be
  28        misrepresented as being the original software.
  29     3. This notice may not be removed or altered from any source distribution.
  30
  31 */
  32
  33
  34 #include "heapbuf.h"
  35
  36
  37 #include "denormal.h"
  38
  39 class WDL_ReverbAllpass
  40 {
  41 public:
  42   WDL_ReverbAllpass() { feedback=0.5; setsize(1); }
  43   ~WDL_ReverbAllpass() { }
  44
  45   void setsize(int size)
  46   {
  47     if (size<1)size=1;
  48     if (buffer.GetSize()!=size)
  49     {
  50       bufidx=0;
  51       buffer.Resize(size);
  52       Reset();
  53     }
  54   }
  55
  56         double process(double inp)
  57   {
  58     double *bptr=buffer.Get()+bufidx;
  59
  60           double bufout = *bptr;
  61
  62           double output = bufout - inp;
  63           *bptr = denormal_filter_double(inp + (bufout*feedback));
  64
  65           if(++bufidx>=buffer.GetSize()) bufidx = 0;
  66
  67           return output;
  68   }
  69   void Reset() { memset(buffer.Get(),0,buffer.GetSize()*sizeof(double)); }
  70   void setfeedback(double val) { feedback=val; }
  71
  72 private:
  73         double  feedback;
  74         WDL_TypedBuf<double> buffer;
  75         int             bufidx;
  76 public:
  77   int __pad;
  78
  79 } WDL_FIXALIGN;
  80
  81
  82 class WDL_ReverbComb
  83 {
  84 public:
  85   WDL_ReverbComb() { feedback=0.5; damp=0.5; filterstore=0; setsize(1); }
  86   ~WDL_ReverbComb() { }
  87
  88   void setsize(int size)
  89   {
  90     if (size<1)size=1;
  91     if (buffer.GetSize()!=size)
  92     {
  93       bufidx=0;
  94       buffer.Resize(size);
  95       Reset();
  96     }
  97   }
  98
  99         double process(double inp)
 100   {
 101     double *bptr=buffer.Get()+bufidx;
 102           double output = *bptr;
 103           filterstore = denormal_filter_double((output*(1-damp)) + (filterstore*damp));
 104
 105           *bptr = inp + (filterstore*feedback);
 106
 107           if(++bufidx>=buffer.GetSize()) bufidx = 0;
 108
 109           return output;
 110   }
 111   void Reset() { memset(buffer.Get(),0,buffer.GetSize()*sizeof(double)); }
 112   void setdamp(double val) { damp=val;  }
 113   void setfeedback(double val) { feedback=val; }
 114
 115 private:
 116
 117         double  feedback;
 118         double  filterstore;
 119         double  damp;
 120         WDL_TypedBuf<double> buffer;
 121         int             bufidx;
 122 public:
 123   int __pad;
 124 } WDL_FIXALIGN;
 125
 126   // these represent lengths in samples at 44.1khz but are scaled accordingly
 127 const int wdl_verb__stereospread=23;
 128 const short wdl_verb__combtunings[]={1116,1188,1277,1356,1422,1491,1557,1617,1685,1748};
 129 const short wdl_verb__allpasstunings[]={556,441,341,225,180,153};
 130
 131
 132 class WDL_ReverbEngine
 133 {
 134 public:
 135   WDL_ReverbEngine()
 136   {
 137     m_srate=44100.0;
 138     m_roomsize=0.5;
 139     m_damp=0.5;
 140     SetWidth(1.0);
 141     Reset(false);
 142   }
 143   ~WDL_ReverbEngine()
 144   {
 145   }
 146   void SetSampleRate(double srate)
 147   {
 148     if (m_srate!=srate)
 149     {
 150       m_srate=srate;
 151       Reset(true);
 152     }
 153   }
 154
 155   void ProcessSampleBlock(double *spl0, double *spl1, double *outp0, double *outp1, int ns)
 156   {
 157     int x;
 158     memset(outp0,0,ns*sizeof(double));
 159     memset(outp1,0,ns*sizeof(double));
 160
 161     for (x = 0; x < sizeof(wdl_verb__combtunings)/sizeof(wdl_verb__combtunings[0]); x += 2)
 162     {
 163       int i=ns;
 164       double *p0=outp0,*p1=outp1,*i0=spl0,*i1=spl1;
 165       while (i--)
 166       {
 167         double a=*i0++,b=*i1++;
 168         *p0+=m_combs[x][0].process(a);
 169         *p1+=m_combs[x][1].process(b);
 170         *p0+++=m_combs[x+1][0].process(a);
 171         *p1+++=m_combs[x+1][1].process(b);
 172       }
 173     }
 174     for (x = 0; x < sizeof(wdl_verb__allpasstunings)/sizeof(wdl_verb__allpasstunings[0])-2; x += 2)
 175     {
 176       int i=ns;
 177       double *p0=outp0,*p1=outp1;
 178       while (i--)
 179       {
 180         double tmp=m_allpasses[x][0].process(*p0);
 181         double tmp2=m_allpasses[x][1].process(*p1);
 182         *p0++=m_allpasses[x+1][0].process(tmp);
 183         *p1++=m_allpasses[x+1][1].process(tmp2);
 184       }
 185     }
 186     int i=ns;
 187     double *p0=outp0,*p1=outp1;
 188     while (i--)
 189     {
 190       double a=m_allpasses[x+1][0].process(m_allpasses[x][0].process(*p0))*0.015;
 191       double b=m_allpasses[x+1][1].process(m_allpasses[x][1].process(*p1))*0.015;
 192
 193       if (m_wid<0)
 194       {
 195         double m=-m_wid;
 196         *p0 = b*m + a*(1.0-m);
 197         *p1 = a*m + b*(1.0-m);
 198       }
 199       else
 200       {
 201         double m=m_wid;
 202         *p0 = a*m + b*(1.0-m);
 203         *p1 = b*m + a*(1.0-m);
 204       }
 205       p0++;
 206       p1++;
 207     }
 208
 209   }
 210
 211   void ProcessSample(double *spl0, double *spl1)
 212   {
 213     int x;
 214     double in0=*spl0 * 0.015;
 215     double in1=*spl1 * 0.015;
 216
 217     double out0=0.0;
 218     double out1=0.0;
 219     for (x = 0; x < sizeof(wdl_verb__combtunings)/sizeof(wdl_verb__combtunings[0]); x ++)
 220     {
 221       out0+=m_combs[x][0].process(in0);
 222       out1+=m_combs[x][1].process(in1);
 223     }
 224     for (x = 0; x < sizeof(wdl_verb__allpasstunings)/sizeof(wdl_verb__allpasstunings[0]); x ++)
 225     {
 226       out0=m_allpasses[x][0].process(out0);
 227       out1=m_allpasses[x][1].process(out1);
 228     }
 229
 230     if (m_wid<0)
 231     {
 232       double m=-m_wid;
 233       *spl0 = out1*m + out0*(1.0-m);
 234       *spl1 = out0*m + out1*(1.0-m);
 235     }
 236     else
 237     {
 238       double m=m_wid;
 239       *spl0 = out0*m + out1*(1.0-m);
 240       *spl1 = out1*m + out0*(1.0-m);
 241     }
 242   }
 243
 244   void Reset(bool doclear=false) // call this after changing roomsize or dampening
 245   {
 246     int x;
 247     double sc=m_srate / 44100.0;
 248     for (x = 0; x < sizeof(wdl_verb__allpasstunings)/sizeof(wdl_verb__allpasstunings[0]); x ++)
 249     {
 250       m_allpasses[x][0].setsize((int) (wdl_verb__allpasstunings[x] * sc));
 251       m_allpasses[x][1].setsize((int) ((wdl_verb__allpasstunings[x]+wdl_verb__stereospread) * sc));
 252       m_allpasses[x][0].setfeedback(0.5);
 253       m_allpasses[x][1].setfeedback(0.5);
 254       if (doclear)
 255       {
 256         m_allpasses[x][0].Reset();
 257         m_allpasses[x][1].Reset();
 258       }
 259     }
 260     for (x = 0; x < sizeof(wdl_verb__combtunings)/sizeof(wdl_verb__combtunings[0]); x ++)
 261     {
 262       m_combs[x][0].setsize((int) (wdl_verb__combtunings[x] * sc));
 263       m_combs[x][1].setsize((int) ((wdl_verb__combtunings[x]+wdl_verb__stereospread) * sc));
 264       m_combs[x][0].setfeedback(m_roomsize);
 265       m_combs[x][1].setfeedback(m_roomsize);
 266       m_combs[x][0].setdamp(m_damp*0.4);
 267       m_combs[x][1].setdamp(m_damp*0.4);
 268       if (doclear)
 269       {
 270         m_combs[x][0].Reset();
 271         m_combs[x][1].Reset();
 272       }
 273     }
 274
 275   }
 276
 277   void SetRoomSize(double sz) { m_roomsize=sz;; } // 0.3..0.99 or so
 278   void SetDampening(double dmp) { m_damp=dmp; } // 0..1
 279   void SetWidth(double wid)
 280   {
 281     if (wid<-1) wid=-1;
 282     else if (wid>1) wid=1;
 283     wid*=0.5;
 284     if (wid>=0.0) wid+=0.5;
 285     else wid-=0.5;
 286     m_wid=wid;
 287   } // -1..1
 288
 289 private:
 290   double m_wid;
 291   double m_roomsize;
 292   double m_damp;
 293   double m_srate;
 294   WDL_ReverbAllpass m_allpasses[sizeof(wdl_verb__allpasstunings)/sizeof(wdl_verb__allpasstunings[0])][2];
 295   WDL_ReverbComb m_combs[sizeof(wdl_verb__combtunings)/sizeof(wdl_verb__combtunings[0])][2];
 296
 297 };
 298
 299
 300 #endif