---

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

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.h,v $
 * Date modified: $Date: 2002/04/15 07:28:46 $
 * Version:       $Revision: 1.16 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/

#ifndef SUBSYNTH_WAVETABLE_OSC_MODULE_H
#define SUBSYNTH_WAVETABLE_OSC_MODULE_H

#include <map>
#include "syn/Stream/AudioIStreamPtr.h"
#include "syn/Stream/WavAudioIStream.h"
#include "syn/Core/SampleBuffer.h"
#include "syn/Core/SampleBufferQueue.h"
#include "syn/Core/Module.h"
#include "syn/Core/Terminal.h"

namespace syn
{
   class WaveTableOscModule : public Module
   {
   public:
      WaveTableOscModule();
   
      virtual ~WaveTableOscModule();

      virtual void update();

      virtual bool open();

      virtual bool isOpen();
      
      virtual void close();

      virtual Module* clone() const
      {
         WaveTableOscModule* mod = new WaveTableOscModule;
         mod->setWaveTable( mWaveTable );
         mod->setFreq( this->freq() );
         mod->setFreqControl( this->freqControl() );
         mod->setFreqControlSensitivity( this->freqControlSensitivity() );
         mod->setInterp( this->interp() );
         mod->setLoop( this->loop() );
         mod->setRetriggerable( this->retriggerable() );
         return mod;
      }
       
      void loadStream( AudioIStreamPtr stream, int numsamps )
      {
         mWaveTable.resize( numsamps );
         stream->read( mWaveTable.data(), mWaveTable.size() );
         
         mWaveTableIterator = 0;
      }
      
      void loadFile( const std::string& name )
      {
         WavAudioIStream* wav = new WavAudioIStream;
         wav->setName( name );
         wav->open( AudioFormat( AudioFormat::FLOAT32, 1, 44100 ) );
         AudioIStreamPtr stream = syn::AudioIStreamPtr( wav );
         this->loadStream( stream, wav->numsamps() );
         wav->close();
         
         mWaveTableIterator = 0;
      }

      void setWaveTable( const SampleBuffer1f& wt )
      {
         mWaveTable = wt;
      }
      
      virtual void setFreq( float freq )
      {
         // be graceful (ignore bad input, don't dump)
         if (freq <= 0.0f) 
            return;
         
         mFreq = freq;
         
         // get the floor (because the size of the wavetable
         // is often calculated from the floor of samprate / freq)
         // then invert it to get the freq / samprate for the EQ
         // this ensures that a wavetable produces from 80Hz wave
         // played back at 80hz will produce an increment of exactly 1
         float x = 1.0f / (float)(int)(44100.0f / freq);
         
         // equation can be found in CMT p.93 eq #1
         mIncrement = ((float)mWaveTable.size()) * x;
      }
      
      void setFreqControl( float param )
      {
         mFreqControl = param;
         mIncrementScalar = Math::fast_exp2( mFreqControl * mFreqControlSens );
      }    
      
      void setFreqControlSensitivity( float octaves = 1.0f )
      {
         mFreqControlSens = octaves;
         mIncrementScalar = Math::fast_exp2( mFreqControl * mFreqControlSens );
      } 
      
      enum Interp
      {
         NONE, LINEAR
      };
         
      void setInterp( Interp in )
      {
         mInterp = in;
      }
      
      void setLoop( bool state )
      {
         mLoop = state;
      }
      
      void setRetriggerable( bool state )
      {
         mRetrig = state;
      }
      
      void trigger()
      {
         if (mRetrig == true || mPlaying == false)
            mWaveTableIterator = 0; // reset wave pointer
         mPlaying = true;
      }
      
      void release()
      {
         mPlaying = false;
      }
      

      float freq() const { return mFreq; }
      float freqControl() const { return mFreqControl; }
      float freqControlSensitivity() const { return mFreqControlSens; }
      Interp interp() const { return mInterp; }
      bool loop() const { return mLoop; }
      bool retriggerable() const { return mRetrig; }
      

      virtual void getParam( const std::string& key, MultivariateType& value )
      {
         if (key == "freq")
            value.setValue<float>( mFreq );
         else if (key == "freqcontrol")
            value.setValue<float>( mFreqControl );
         else if (key == "freqcontrolsens")
            value.setValue<float>( mFreqControlSens );
         else if (key == "interp")
            value.setValue<unsigned int>( mInterp );
         else if (key == "loop")
            value.setValue<bool>( mLoop );
         else if (key == "filename")
            value.setValue<std::string>( "unknown" );
      }

      virtual void setParam( const std::string& key, const MultivariateType& value )
      {
         if (key == "freq")
            this->setFreq( value.getValue<float>() );
         else if (key == "freqcontrol")
            this->setFreqControl( value.getValue<float>() );
         else if (key == "trigger")
            this->trigger();
         else if (key == "release")
            this->release();
         else if (key == "freqcontrolsens")
            this->setFreqControl( value.getValue<float>() );
         else if (key == "interp")
            this->setInterp( (Interp)value.getValue<unsigned int>() );
         else if (key == "loop")
            this->setLoop( value.getValue<bool>() );
         else if (key == "filename")
            this->loadFile( value );
      }
      
   private:
      TerminalPtr mFreqControlInput;
      TerminalPtr mMonoAudioOutput;

      int mTrigger;
      SampleBuffer1f mWaveTable;
      float mWaveTableIterator;
      SampleBuffer1f* mWriteBuf, *mReadBuf;
      unsigned int mWriteBufIt, mReadBufIt;
      float mFreqControl, mFreqControlSens;
      bool mRetrig, mPlaying, mLoop;
      
      Interp mInterp;
      unsigned int mSkipFreqInputs;

      float mIncrement, mIncrementScalar;
      float mFreq;
      
      /*#  Terminal lnkTerminal; */

      /*#  Terminal lnkTerminal; */
   };  
}
#endif

---