---

/root/src/subsynth/syn/Module/WaveTableOscModule.cpp

Go to the documentation of this file.

/****************** <SYN heading BEGIN do not edit this line> *****************
 *
 * subsynth - modular audio synthesizer
 * subsynth is (C) Copyright 2001-2002 by Kevin Meinert
 *
 * Original Author: Kevin Meinert
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: WaveTableOscModule.cpp,v $
 * Date modified: $Date: 2002/04/14 18:03:17 $
 * Version:       $Revision: 1.16 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/
#include "syn/Util/Generator.h"
#include "syn/Core/SampleBufferRepos.h"
#include "syn/Module/WaveTableOscModule.h"

namespace syn
{

   WaveTableOscModule::WaveTableOscModule(): Module(), 
                           mWriteBuf( NULL ), mReadBuf( NULL ), 
                           mFreqControl( 0.0f ), mFreqControlSens( 1.0f ),
                           mRetrig( true ), mPlaying( false ), mLoop( true ),
                           mInterp( LINEAR ), mSkipFreqInputs( 0 ),
                           mIncrement( 1.0f ), mIncrementScalar( 1.0f )
   {
      mFreqControlInput = this->createInput( "freq" );
      mMonoAudioOutput = this->createOutput( "mono audio" );
      this->setFreqControl( 0 );
   }
   
   WaveTableOscModule::~WaveTableOscModule()
   {
   }

   bool WaveTableOscModule::isOpen() { return true; }
   
   bool WaveTableOscModule::open()
   {
      // init the wavetable to some default tri wave......
      if (mWaveTable.size() == 0)
      {
         TriangleOsc osc;
         mWaveTable.resize( osc.samplesPerOsc() );
         for (unsigned int x = 0; x < osc.samplesPerOsc(); ++x)
         {
            mWaveTable[x] = osc.generate();
         }
      }

      // configure the output terminals
      mMonoAudioOutput->setHighMark( 2 ); 
      mMonoAudioOutput->setLowMark( 1 );

      return true;
   }
   
   void WaveTableOscModule::close()
   {
   }

   void WaveTableOscModule::update()
   {  
      // wait for input if it isn't here yet.
      // if we need to wait, but it is empty - or
      // if the output is already too full...
      if ((!mFreqControlInput->done() && mFreqControlInput->empty()) || mMonoAudioOutput->high())
      {
         mMonoAudioOutput->setDone( false );
         return;
      }

      //std::cout<<"wto] increment:"<<mIncrement<<" freq:"<<mFreqControl<<" sens:"<<mFreqControlSens<<std::endl;
      
      this->setPutCount( 0 );
      
      // emit data only when playing...
      if (mPlaying == true)
      {
         // Freq input terminal is connected case...
         if (!mFreqControlInput->done())
         {
            if (mReadBuf == NULL)
            {
               mReadBuf = mFreqControlInput->front();
               mFreqControlInput->pop();
               mReadBufIt = 0;
            }

            if (mWriteBuf == NULL)
            {
               SampleBufferRepos::instance()->take( mWriteBuf );
               mWriteBufIt = 0;
            }

            // fill the buffer with what was in the wave table.
            switch (mInterp)
            {
               // no interpolation (select nearest)
               case NONE:
               {
                  while (mReadBufIt < mReadBuf->size() && mWriteBufIt < mWriteBuf->size() && mPlaying)
                  {
                     // read freqcontrol from the frequency control stream...
                     // recalculate increment from this.
                     mSkipFreqInputs = (mSkipFreqInputs + 1) % 10;
                     if (mSkipFreqInputs == 0)
                     {
                        mFreqControl = (*(mReadBuf))[mReadBufIt];
                        mIncrementScalar = Math::fast_exp2( mFreqControl * mFreqControlSens );
                     }

                     // copy from wavetable to the output terminal
                     (*mWriteBuf)[mWriteBufIt] = mWaveTable[(int)mWaveTableIterator];

                     // advance wavetable ptr, loop back to beginning if at end
                     // keep the current, and the next sample for linear interpolation
                     mWaveTableIterator += mIncrement * mIncrementScalar;
                     float next_wt_it = fmod( mWaveTableIterator, (float)mWaveTable.size() );
                     if (mWaveTableIterator != next_wt_it)
                     {
                        mWaveTableIterator = next_wt_it;
                        if (mLoop == false) 
                           mPlaying = false; // done playing in the single shot case.
                     }
                     
                     ++mReadBufIt;
                     ++mWriteBufIt;
                  }
               }
               break;

               // linear interpolation
               case LINEAR:
               {
                  while (mReadBufIt < mReadBuf->size() && mWriteBufIt < mWriteBuf->size() && mPlaying)
                  {
                     // read freqcontrol from the frequency control stream...
                     // recalculate increment from this.
                     mSkipFreqInputs = (mSkipFreqInputs + 1) % 10;
                     if (mSkipFreqInputs == 0)
                     {
                        mFreqControl = (*(mReadBuf))[mReadBufIt];
                        mIncrement = Math::fast_exp2( mFreqControl * mFreqControlSens );
                     }

                     // get the next sample for interpolation
                     float next = mWaveTableIterator + 1.0f; 
                     if (next >= (float)mWaveTable.size())
                        next = next - (float)mWaveTable.size();

                     float first = mWaveTable[(int)mWaveTableIterator];
                     float second = mWaveTable[(int)next];
                     float weight = mWaveTableIterator - (float)(int)mWaveTableIterator;
                     (*mWriteBuf)[mWriteBufIt] = first + ((second - first) * weight);

                     // advance wavetable ptr, loop back to beginning if at end
                     // keep the current, and the next sample for linear interpolation
                     mWaveTableIterator += mIncrement * mIncrementScalar;
                     float next_wt_it = fmod( mWaveTableIterator, (float)mWaveTable.size() );
                     if (mWaveTableIterator != next_wt_it)
                     {
                        mWaveTableIterator = next_wt_it;
                        if (mLoop == false) 
                           mPlaying = false; // done playing in the single shot case.
                     }
                     
                     ++mReadBufIt;
                     ++mWriteBufIt;
                  }
               }
               break;

               default:
                  assert( false && "undefined interpolation param" );
                  break;
            }

            // if buffer has been emptied, then put it back so we can get a new one next.
            if (mReadBufIt >= mReadBuf->size())
            {
               SampleBufferRepos::instance()->putback( mReadBuf );
               mReadBufIt = 0;
               mReadBuf = NULL;
            }

            // if buffer has been filled, then send it
            if (mWriteBufIt >= mWriteBuf->size())
            {
               mMonoAudioOutput->push( mWriteBuf );
               mMonoAudioOutput->setDone( false );
               this->setPutCount( mWriteBuf->size() );
               mWriteBuf = NULL;
               mWriteBufIt = 0;
            }
         }

         // use constant instead
         else
         {
            SampleBufferRepos::instance()->take( mWriteBuf );

            // fill the buffer with what was in the wave table.
            switch (mInterp)
            {
               // no interpolation (select nearest)
               case NONE:
               {
                  for (unsigned int x = 0; x < mWriteBuf->size() && mPlaying; ++x)
                  {
                     (*mWriteBuf)[x] = mWaveTable[(int)mWaveTableIterator];

                     // advance wavetable ptr, loop back to beginning if at end
                     // keep the current, and the next sample for linear interpolation
                     mWaveTableIterator += mIncrement * mIncrementScalar;
                     float next_wt_it = fmod( mWaveTableIterator, (float)mWaveTable.size() );
                     if (mWaveTableIterator != next_wt_it)
                     {
                        mWaveTableIterator = next_wt_it;
                        if (mLoop == false) 
                           mPlaying = false; // done playing in the single shot case.
                     }
                  }
               }
               break;

               // linear interpolation
               case LINEAR:
               {
                  for (unsigned int x = 0; x < mWriteBuf->size() && mPlaying; ++x)
                  {
                     // get the next sample for interpolation
                     float next = mWaveTableIterator + 1.0f; 
                     if (next >= (float)mWaveTable.size())
                        next = next - (float)mWaveTable.size();

                     float first = mWaveTable[(int)mWaveTableIterator];
                     float second = mWaveTable[(int)next];
                     float weight = mWaveTableIterator - (float)(int)mWaveTableIterator;
                     (*mWriteBuf)[x] = first + ((second - first) * weight);

                     // advance wavetable ptr, loop back to beginning if at end
                     // keep the current, and the next sample for linear interpolation
                     mWaveTableIterator += mIncrement * mIncrementScalar;
                     float next_wt_it = fmod( mWaveTableIterator, (float)mWaveTable.size() );
                     if (mWaveTableIterator != next_wt_it)
                     {
                        mWaveTableIterator = next_wt_it;
                        if (mLoop == false) 
                           mPlaying = false; // done playing in the single shot case.
                     }
                  }
               }
               break;

               default:
                  assert( false && "undefined interpolation param" );
                  break;
            }

            this->setPutCount( mWriteBuf->size() );
            mMonoAudioOutput->push( mWriteBuf );
            mWriteBuf = NULL;
            mMonoAudioOutput->setDone( false ); // never done...
         }
      }
      
      // if not playing
      else
      {
         mMonoAudioOutput->setDone( true ); // done...
      }
   }
}// end of namespace.

---