---

/root/src/subsynth/syn/Util/Generator.h

Go to the documentation of this file.

#ifndef SYN_GENERATOR_H
#define SYN_GENERATOR_H

#include <syn/Util/Math.h>

namespace syn
{
   class TriangleOsc
   {
   public:
      TriangleOsc() : mFreq( 80.0f ), mSamplingRateHz( 44100.0f ), dp( 1 )
      {
         this->reset();
      }

      inline float generate()
      {
         const float float_max = 1.0f;
         const float float_min = -1.0f;

         p += dp;
         if (p > float_max)
         {
            p = float_max;
            dp = -dp;
         }
         else if (p < float_min)
         {
            p = float_min;
            dp = -dp;
         }

         return p;
      }
      
      inline unsigned int samplesPerOsc()
      {
         // get samples per oscillation
         // mSamplingRateHz = samples/sec  and  mFreq = osc / sec
         // samples/sec  *  sec / osc
         return (unsigned int)(mSamplingRateHz / mFreq);
      }

      inline void setFreq( float freqHz )
      { 
         if (freqHz != mFreq)
         {
            mFreq = freqHz;
            on_change_of_freq_or_samprate();
         }
      }

      inline void setSampRate( float samplingRateHz )
      { 
         if (samplingRateHz != mSamplingRateHz)
         {
            mSamplingRateHz = samplingRateHz;
            on_change_of_freq_or_samprate();
         }
      }

      inline void reset()
      {
         p = 0.0f;
         dp = 1.0f;
         on_change_of_freq_or_samprate();
      }

   private:
      inline void on_change_of_freq_or_samprate()
      {
         // TODO: document this magic number... 
         //       it causes the generated wav to match 
         //       soundforge and other func gens.
         float delta = 2.00495f * mFreq / mSamplingRateHz;

         // set frequency...
         // 2 is the range of numbers dp will span [-1..1]
         const float float_range = 2.0f;
         if (dp > 0.0f) // preserve the direction we've been going
            dp = delta * float_range; 
         else
            dp = -delta * float_range;
      }

      /* func gen attributes. */
      float mFreq, mSamplingRateHz;
      float p, dp;
   };


   class SineOsc
   {
   public:
      SineOsc() : mFreq( 80.0f ), mSamplingRateHz( 44100.0f )
      {
         this->reset();
      }

      inline float generate()
      {
         const float float_range = 2.0f;
         s[0] = s[0] - a * s[1];   // sine == s[0]
         s[1] = s[1] + a * s[0];   // cos == s[1]
         return s[0] * float_range;
      }
      
      inline unsigned int samplesPerOsc()
      {
         // get samples per oscillation
         // mSamplingRateHz = samples/sec  and  mFreq = osc / sec
         // samples/sec  *  sec / osc
         return (unsigned int)(mSamplingRateHz / mFreq);
      }

      inline void setFreq( float freqHz )
      { 
         if (freqHz != mFreq)
         {
            mFreq = freqHz;
            on_change_of_freq_or_samprate();
         }
      }

      inline void setSampRate( float samplingRateHz )
      { 
         if (samplingRateHz != mSamplingRateHz)
         {
            mSamplingRateHz = samplingRateHz;
            on_change_of_freq_or_samprate();
         }
      }

      inline void reset()
      {
         s[0] = 0.5f; // sine yaxis begin
         s[1] = 0.0f; // cos yaxis begin
         on_change_of_freq_or_samprate();
      }

   private:
      inline void on_change_of_freq_or_samprate()
      {
         const float float_range = 2.0f;
         a = float_range * Math::sin( Math::PI * mFreq / mSamplingRateHz );
      }

      /* func gen attributes. */
      float mFreq, mSamplingRateHz;
      float s[2], a;
   };

   class SquareOsc
   {
   public:
      SquareOsc() : mFreq( 80.0f ), mSamplingRateHz( 44100.0f )
      {
         this->reset();
      }

      inline float generate()
      {
         (*((unsigned long *)&one)) &= 0x7FFFFFFF; // mask out sign bit 
         (*((unsigned long *)&one)) |= (intOver & 0x80000000); 
         intOver += intIncr;
         return float( long( intOver ) ) / float( long( 0x7FFFFFFF ) );
      }
      
      inline unsigned int samplesPerOsc()
      {
         // get samples per oscillation
         // mSamplingRateHz = samples/sec  and  mFreq = osc / sec
         // samples/sec  *  sec / osc
         return (unsigned int)( mSamplingRateHz / mFreq );
      }

      inline void setFreq( float freqHz )
      { 
         if (freqHz != mFreq)
         {
            mFreq = freqHz;
            on_change_of_freq_or_samprate();
         }
      }

      inline void setSampRate( float samplingRateHz )
      { 
         if (samplingRateHz != mSamplingRateHz)
         {
            mSamplingRateHz = samplingRateHz;
            on_change_of_freq_or_samprate();
         }
      }

      inline void reset()
      {
         one = 1.0f; 
         on_change_of_freq_or_samprate();
      }

   private:
      inline void on_change_of_freq_or_samprate()
      {
         intOver = 0L;// 4294967296
         intIncr = ((unsigned long)0xffffffff) / (unsigned long)(mSamplingRateHz / mFreq); 
      }

      /* func gen attributes. */
      float mFreq, mSamplingRateHz;
      unsigned long intOver, intIncr;
      float one;
   };



   class WhiteNoiseOsc
   {
   public:
      WhiteNoiseOsc() : mSamplingRateHz( 44100.0f )
      {
         this->reset();
         // 16 == rows, 24 == bits... ?
         long pmax = 0x7fffffff; // largest
         mScalar = 1.0f / pmax;
      }

      inline float generate()
      {
         // Calculate pseudo-random 32 bit number based on linear 
         // congruential method... scale it to our -1..1 float32 range...
         return (mScalar * (float)(long)(mRand = (mRand * 196314165) + 907633515));
      }
      
      inline void reset()
      {
         mRandSeed = 22222;
         mRand = mRandSeed;
      }

      inline unsigned int samplesPerOsc()
      {
         // just return something (1sec)...
         return (unsigned int)( mSamplingRateHz );
      }

      inline void setFreq( float freqHz ) {}

      inline void setSampRate( float samplingRateHz )
      { 
         mSamplingRateHz = samplingRateHz;
      }

   private:
      enum 
      {
         mRandomRows = 16,
         mRandomBits = 24
      };
      /* func gen attributes. */
      unsigned long mRandSeed, mRand;
      float mSamplingRateHz;
      float mScalar;       // Used to scale within range of -1.0 to +1.0
   };

   class PinkNoiseOsc
   {
   public:
      PinkNoiseOsc() : mSamplingRateHz( 44100.0f ), 
                       mRandomBits( 24 ), 
                       mRandomShift( sizeof( long ) * 8 - mRandomBits )
      {
         this->reset();
      }

      inline float generate()
      {
         long newRandom;
         
         /* Increment and mask index. */
         mIndex = (mIndex + 1) & mIndexMask;
         
         /* If index is zero, don't update any random values. */
         if( mIndex != 0 ) 
         {
            /* Determine how many trailing zeros in PinkIndex. */
            /* This algorithm will hang if n==0 so test first. */
            int numZeros = 0;
            int n = mIndex;
            while ((n & 1) == 0) 
            {
               n = n >> 1;
               ++numZeros;
            }

            /* Replace the indexed ROWS random value.
             * Subtract and add back to RunningSum instead of adding all the random
             * values together. Only one changes each time.
             */
            mRunningSum -= mRows[numZeros];
            newRandom = ((long)this->generateWhiteNoise()) >> mRandomShift;
            mRunningSum += newRandom;
            mRows[numZeros] = newRandom;
         }
     
         /* Add extra white noise value. */
         newRandom = ((long)this->generateWhiteNoise()) >> mRandomShift;
         
         /* Scale the sum to our -1..1 range */
         return mScalar * (float)(mRunningSum + newRandom);
      }
      
      inline void reset()
      {
         this->initializeWhiteNoise();
         this->initializePinkNoise();
      }

      inline unsigned int samplesPerOsc()
      {
         // just return something (1sec)...
         return (unsigned int)( mSamplingRateHz );
      }

      inline void setFreq( float freqHz ) {}

      inline void setSampRate( float samplingRateHz )
      { 
         mSamplingRateHz = samplingRateHz;
      }

   private:
      inline void initializeWhiteNoise()
      {
         mRandSeed = 22222;
         mRand = mRandSeed;
      }
      inline unsigned long generateWhiteNoise()
      {
         // Calculate pseudo-random 32 bit number based on linear
         // congruential method.
         return mRand = (mRand * 196314165) + 907633515;
      }

      /* Setup PinkNoise structure for N rows of generators. */
      void initializePinkNoise() 
      {
         int i;
         mIndex = 0;
         mIndexMask = (1 << mRandomRows) - 1;

         /* Calculate maximum possible signed random value. Extra 1 for white noise always added. */
         long pmax = (mRandomRows + 1) * (1 << (mRandomBits - 1));
         mScalar = 1.0f / pmax;
         
         /* Initialize rows. */
         for( i = 0; i < mRandomRows; ++i )
         {
            mRows[i] = 0;
         }
         mRunningSum = 0;
      }

      /* func gen attributes. */
      enum
      {
         mRandomRows = 16
      };
      float mSamplingRateHz;
      const int mRandomBits;
      const int mRandomShift;
      unsigned long mRandSeed, mRand;
      long      mRows[mRandomRows];     
      long      mRunningSum;   // Used to optimize summing of generators.
      int       mIndex;        // Incremented each sample.
      int       mIndexMask;    // Index wrapped by ANDing with this mask.
      float     mScalar;       // Used to scale within range of -1.0 to +1.0 
   };

   class AdsrEnvOsc
   {
   public:
      AdsrEnvOsc() : mSamplingRateHz( 44100.0f ), 
                     mAttackTime( 0.01f ), 
                     mDecayTime( 0.03f ), 
                     mSustainLevel( 0.5f ), 
                     mReleaseTime( 0.04f )
      {
         this->reset();
      }

      inline float lerp( const float lerpVal, const float from, const float to )
      {
          return from + (to - from) * lerpVal;
      }

      inline float generate()
      {
         // auto release() based on specified duration
         if (mDurationTime != -1)
         {
            ++mTotalTimeSamps;
            if (mTotalTimeSamps > mDurationSamps)
            {
               this->release();
            }
         }
         
         float count = mCount;// prev count...
         switch (mState)
         {
         case 0: // attack
            if (mCount++ >= mAttackSamps) 
            {
               mState = 1;
               mCount = 0;
            }
            return lerp( count / mAttackSamps, 0.0f, 1.0f );
            break;
         case 1: // decay
            if (mCount++ >= mDecaySamps)
            {
               mState = 2;
               mCount = 0;
            }
            return lerp( count / mDecaySamps, 1.0f, mSustainLevel );
            break;
         case 2: // sustain
            if (mReleased)
            {
               mState = 3;
               mReleased = false;
            }
            return mSustainLevel;
            break;
         case 3: // release
            if (mCount++ >= mReleaseSamps)
            {
               mState = 4;
               mCount = 0;
            }
            return lerp( count / mReleaseSamps, mSustainLevel, 0.0f );
            break;
         default:
         case 4: // done...
            return 0.0f;
            break;
         }
      }
      
      void trigger( float duration = -1 )
      {
         mState = 0;
         mDurationTime = duration;
         mDurationSamps = mDurationTime * mSamplingRateHz;
         mTotalTimeSamps = 0;
      }

      void release()
      {
         mReleased = true;
      }

      void setAttackTime( float t )
      {
         mAttackTime = t;
         // samps = sec * samps/sec
         mAttackSamps = mAttackTime * mSamplingRateHz;
      }
      float getAttackTime() { return mAttackTime; }

      void setDecayTime( float t )
      {
         mDecayTime = t;
         // samps = sec * samps/sec
         mDecaySamps = mDecayTime * mSamplingRateHz;
      }
      float getDecayTime() { return mDecayTime; }

      void setSustainLevel( float sustain )
      {
         mSustainLevel = sustain;
      }
      float getSustainLevel() { return mSustainLevel; }

      void setReleaseTime( float t )
      {
         mReleaseTime = t;
         mReleaseSamps = mReleaseTime * mSamplingRateHz;
      }

      float getReleaseTime() { return mReleaseTime; }
      
      inline unsigned int samplesPerOsc()
      {
         // get samples per oscillation
         // mSamplingRateHz = samples/sec  and  mFreq = osc / sec
         // samples/sec  *  sec / osc

         //sustain can go infinately, just choose something.
         return (unsigned int)( mAttackSamps + mDecaySamps + mDecaySamps + mReleaseSamps ); 
      }

      inline void setFreq( float freqHz ) {}

      inline void setSampRate( float samplingRateHz )
      { 
         if (samplingRateHz != mSamplingRateHz)
         {
            mSamplingRateHz = samplingRateHz;
            on_change_of_samprate();
         }
      }

      inline void reset()
      {
         mState = 4;
         mCount = 0.0f;
         mReleased = false;
         on_change_of_samprate();
      }

   private:
      inline void on_change_of_samprate()
      {
         this->setAttackTime( mAttackTime );
         this->setDecayTime( mDecayTime );
         this->setSustainLevel( mSustainLevel );
         this->setReleaseTime( mReleaseTime );
         mDurationSamps = mDurationTime * mSamplingRateHz;
      }

      /* func gen attributes. */
      float mSamplingRateHz;
      float mAttackTime, mDecayTime, mSustainLevel, mReleaseTime;
      float mCount;
      float mAttackSamps, mDecaySamps, mReleaseSamps;
      unsigned int mState;
      bool mTriggered;
      bool mReleased;
      float mDurationSamps, mDurationTime, mTotalTimeSamps;
   };
} // end namespace syn

#endif

---