WDL/simple_pitchshift.h

   1 #ifndef _WDL_SIMPLEPITCHSHIFT_H_
   2 #define _WDL_SIMPLEPITCHSHIFT_H_
   3
   4
   5 #include "queue.h"
   6
   7 #ifndef WDL_SIMPLEPITCHSHIFT_SAMPLETYPE
   8 #define WDL_SIMPLEPITCHSHIFT_SAMPLETYPE double
   9 #endif
  10
  11
  12 #ifdef WDL_SIMPLEPITCHSHIFT_PARENTCLASS
  13 class WDL_SimplePitchShifter : public WDL_SIMPLEPITCHSHIFT_PARENTCLASS
  14 #else
  15 class WDL_SimplePitchShifter
  16 #endif
  17 {
  18 public:
  19   WDL_SimplePitchShifter()
  20   {
  21     m_last_nch=1;
  22     m_srate=44100.0;
  23     m_last_tempo=1.0;
  24     m_last_shift=1.0;
  25     m_qual=0;
  26
  27     Reset();
  28   }
  29   ~WDL_SimplePitchShifter() {   }
  30
  31   void Reset()
  32   {
  33     m_hadinput=0;
  34     m_pspos=0.0;
  35     m_pswritepos=0;
  36     m_latpos=0;
  37     m_tempo_fracpos=0.0;
  38     m_queue.Clear();
  39     m_rsbuf.Resize(0,false);
  40     m_psbuf.Resize(0,false);
  41   }
  42
  43   bool IsReset()
  44   {
  45     return !m_queue.Available() && !m_hadinput;
  46   }
  47
  48
  49
  50   void set_srate(double srate) { m_srate=srate; }
  51   void set_nch(int nch) { if (m_last_nch!=nch) { m_queue.Clear(); m_last_nch=nch; m_tempo_fracpos=0.0; } }
  52   void set_shift(double shift) { m_last_shift=shift; }
  53   void set_tempo(double tempo) { m_last_tempo=tempo; }
  54   void set_formant_shift(double shift)
  55   {
  56   }
  57
  58   WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *GetBuffer(int size)
  59   {
  60     return m_inbuf.Resize(size*m_last_nch);
  61   }
  62   void BufferDone(int input_filled);
  63   void FlushSamples() {}
  64
  65   static const char *enumQual(int q);
  66   static bool GetSizes(int qv, int *ws, int *os); // if ws or os is NULL, enumerate available ws/os
  67
  68   int GetSamples(int requested_output, WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *buffer);
  69
  70
  71  void SetQualityParameter(int parm)
  72  {
  73    m_qual=parm;
  74  }
  75
  76 #ifdef WDL_SIMPLEPITCHSHIFT_EXTRA_INTERFACE
  77  WDL_SIMPLEPITCHSHIFT_EXTRA_INTERFACE
  78 #endif
  79
  80 private:
  81   void PitchShiftBlock(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *inputs, WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *outputs, int nch, int length, double pitch, int bsize, int olsize, double srate);
  82
  83
  84 private:
  85   double m_pspos WDL_FIXALIGN;
  86   double m_tempo_fracpos;
  87   double m_srate,m_last_tempo,m_last_shift;
  88
  89   WDL_TypedBuf<WDL_SIMPLEPITCHSHIFT_SAMPLETYPE> m_psbuf;
  90   WDL_Queue m_queue;
  91   WDL_TypedBuf<WDL_SIMPLEPITCHSHIFT_SAMPLETYPE> m_inbuf;
  92   WDL_TypedBuf<WDL_SIMPLEPITCHSHIFT_SAMPLETYPE> m_rsbuf;
  93
  94   int m_pswritepos;
  95   int m_last_nch;
  96   int m_qual;
  97   int m_hadinput;
  98
  99   int m_latpos;
 100
 101 };
 102
 103
 104 #ifdef WDL_SIMPLEPITCHSHIFT_IMPLEMENT
 105 void WDL_SimplePitchShifter::BufferDone(int input_filled)
 106 {
 107   // perform pitch shifting
 108   if (input_filled>0)
 109   {
 110     m_hadinput=1;
 111     int ws,os;
 112     GetSizes(m_qual,&ws,&os);
 113
 114     int bsize=(int) (ws * 0.001 * m_srate);
 115     if (bsize<16) bsize=16;
 116     else if (bsize>128*1024)bsize=128*1024;
 117
 118     int olsize=(int) (os * 0.001 * m_srate);
 119     if (olsize > bsize/2) olsize=bsize/2;
 120     if (olsize<1)olsize=1;
 121     if (m_psbuf.GetSize() != bsize*m_last_nch)
 122     {
 123       memset(m_psbuf.Resize(bsize*m_last_nch,false),0,sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE)*bsize*m_last_nch);
 124       m_pspos=(double) (bsize/2);
 125       m_pswritepos=0;
 126     }
 127
 128     if (fabs(m_last_tempo-1.0)<0.0000000001)
 129     {
 130       PitchShiftBlock(m_inbuf.Get(),(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *)m_queue.Add(NULL,input_filled*m_last_nch*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE)),m_last_nch,input_filled,m_last_shift,bsize,olsize,m_srate);
 131     }
 132     else
 133     {
 134       int needclear=m_rsbuf.GetSize()<m_last_nch;
 135
 136       WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *bufi=m_rsbuf.Resize((input_filled+1)*m_last_nch,false);
 137       if (needclear)
 138         memset(bufi,0,m_last_nch*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE));
 139
 140       double tempo=m_last_tempo;
 141       double itempo=1.0/tempo;
 142       PitchShiftBlock(m_inbuf.Get(),bufi+m_last_nch,m_last_nch,input_filled,m_last_shift*itempo,bsize,olsize,m_srate);
 143
 144       double fp=m_tempo_fracpos;
 145
 146
 147       if (m_latpos < bsize/2)
 148       {
 149         int a = bsize/2-m_latpos;
 150         if (a > input_filled) a=input_filled;
 151         m_latpos+=a;
 152         fp += a;
 153       }
 154
 155       int outlen = (int) (input_filled*itempo-fp) + 128; // upper bound on possible sample count
 156       if (outlen<0)
 157       {
 158         outlen=0;
 159       }
 160
 161       WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *bufo = (WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *)m_queue.Add(NULL,outlen*m_last_nch*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE));
 162       // resample bufi to bufo
 163       int i,nch=m_last_nch;
 164       for (i = 0; i < outlen; i ++)
 165       {
 166         double rdpos=floor(fp);
 167         int idx=((int)rdpos);
 168         if (idx>=input_filled)
 169         {
 170           // un-add any missing samples
 171           m_queue.Add(NULL,(i-outlen)*m_last_nch*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE));
 172           break;
 173         }
 174         rdpos = (fp-rdpos);
 175         int a;
 176         idx*=nch;
 177         for (a = 0; a < nch; a ++)
 178         {
 179           *bufo++ = bufi[idx+a]*(1.0-rdpos)+bufi[idx+nch+a]*rdpos;
 180         }
 181         fp += tempo;
 182       }
 183
 184       memcpy(bufi,bufi+m_last_nch*input_filled,m_last_nch*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE)); // save last sample for interpolation later
 185       //
 186       m_tempo_fracpos=fp-floor(fp);
 187     }
 188   }
 189 }
 190
 191 const char *WDL_SimplePitchShifter::enumQual(int q)
 192 {
 193   int ws,os;
 194   if (!GetSizes(q,&ws,&os)) return NULL;
 195   static char buf[128];
 196   sprintf(buf,"%dms window, %dms fade",ws,os);
 197   return buf;
 198 }
 199
 200 bool WDL_SimplePitchShifter::GetSizes(int qv, int *ws, int *os)
 201 {
 202   static const short windows[]={50,75,100,150,225,300,40,30,20,10,5,3};
 203   static const char divs[]={2,3,5,7};
 204   const int nwindows = (int) (sizeof(windows) / sizeof(windows[0]));
 205   const int ndivs = (int) (sizeof(divs) / sizeof(divs[0]));
 206
 207   if (!os)
 208   {
 209     if (qv < 0 || qv >= nwindows) return false;
 210     *ws = windows[qv];
 211     return true;
 212   }
 213   if (!ws)
 214   {
 215     if (qv < 0 || qv >= ndivs) return false;
 216     *os = divs[qv];
 217     return true;
 218   }
 219
 220   int wd=qv/ndivs;
 221   if (wd >= nwindows) wd=-1;
 222
 223   *ws=windows[wd>=0?wd:0];
 224   *os = *ws / divs[qv >= 0 ? qv%ndivs : 0];
 225   if (*os<1) *os=1;
 226
 227   return wd>=0;
 228 }
 229
 230 int WDL_SimplePitchShifter::GetSamples(int requested_output, WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *buffer)
 231 {
 232   if (!m_last_nch||requested_output<1) return 0;
 233
 234   int l=m_queue.Available()/sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE)/m_last_nch;
 235
 236   if (requested_output>l) requested_output=l;
 237   int sz=requested_output*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE)*m_last_nch;
 238   memcpy(buffer,m_queue.Get(),sz);
 239   m_queue.Advance(sz);
 240   m_queue.Compact();
 241   return requested_output;
 242 }
 243
 244 void WDL_SimplePitchShifter::PitchShiftBlock(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *inputs, WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *outputs, int nch, int length, double pitch, int bsize, int olsize, double srate)
 245 {
 246   double iolsize=1.0/olsize;
 247
 248   WDL_SIMPLEPITCHSHIFT_SAMPLETYPE *psbuf=m_psbuf.Get();
 249
 250   double dpi=pitch;
 251
 252   double pspos=m_pspos;
 253   int writepos=m_pswritepos;
 254   int writeposnch = writepos*nch;
 255   int bsizench = bsize*nch;
 256   int olsizench = olsize*nch;
 257
 258   int i=length;
 259   while (i--)
 260   {
 261     int ipos1=(int)pspos;
 262     double frac0=pspos-ipos1;
 263
 264     ipos1*=nch;
 265
 266     int ipos2=ipos1+nch;
 267
 268     if (ipos2 >= bsizench) ipos2=0;
 269
 270     int a;
 271     for(a=0;a<nch;a++) outputs[a]=(psbuf[ipos1+a]*(1-frac0)+psbuf[ipos2+a]*frac0);
 272
 273     double tv=pspos;
 274     if (dpi >= 1.0)
 275     {
 276       if (tv > writepos) tv-=bsize;
 277
 278       if (tv >= writepos-olsize && tv < writepos)
 279       {
 280         double tfrac=(writepos-tv)*iolsize;
 281         int tmp=ipos1+olsizench;
 282         if (tmp>=bsizench) tmp-=bsizench;
 283         int tmp2=tmp+nch;
 284         if (tmp2 >= bsizench) tmp2=0;
 285
 286         for(a=0;a<nch;a++) outputs[a]= outputs[a]*tfrac + (1-tfrac)*(psbuf[tmp+a]*(1-frac0)+psbuf[tmp2+a]*frac0);
 287
 288         if (tv+pitch >= writepos) pspos+=olsize;
 289       }
 290
 291     }
 292     else
 293     {
 294       if (tv<writepos) tv+=bsize;
 295
 296       if (tv >= writepos && tv < writepos+olsize)
 297       {
 298         double tfrac=(tv-writepos)*iolsize;
 299         int tmp=ipos1+olsizench;
 300         if (tmp>=bsizench) tmp -= bsizench;
 301         int tmp2= tmp+nch;
 302         if (tmp2 >= bsizench) tmp2=0;
 303         for(a=0;a<nch;a++) outputs[a] = outputs[a]*tfrac + (1-tfrac)*(psbuf[tmp+a]*(1-frac0)+psbuf[tmp2+a]*frac0);
 304
 305         // this is wrong, but blehhh?
 306         if (tv+pitch < writepos+1) pspos += olsize;
 307 //        if (tv+pitch >= writepos+olsize) pspos += olsize;
 308       }
 309     }
 310
 311
 312     if ((pspos+=pitch) >= bsize) pspos -= bsize;
 313
 314
 315     memcpy(psbuf+writeposnch,inputs,nch*sizeof(WDL_SIMPLEPITCHSHIFT_SAMPLETYPE));
 316
 317     writeposnch += nch;
 318     if (++writepos >= bsize) writeposnch = writepos=0;
 319
 320     inputs += nch;
 321     outputs += nch;
 322   } // sample loop
 323   m_pspos=pspos;
 324   m_pswritepos=writepos;
 325 }
 326
 327 #endif
 328
 329 #endif