---

/root/src/subsynth/syn/Core/SampleBuffer.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: SampleBuffer.h,v $
 * Date modified: $Date: 2002/04/15 01:55:54 $
 * Version:       $Revision: 1.15 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/
#ifndef SUBSYNTH_SAMPLE_BUFFER
#define SUBSYNTH_SAMPLE_BUFFER

#include <vector>
#include <string>

#include "syn/Util/Math.h"
#include "syn/Util/AudioFormat.h"

namespace syn
{
   template <typename DATA_TYPE = float, int CHAN = 1>
   class SampleBuffer
   {
   public:
         typedef DATA_TYPE DataType;

         SampleBuffer() : mSize( 0 )
         {  
         }
         
         unsigned int size() const
         {
            return mSize;
         }         

         void resize( unsigned int x )
         {
            if (x > mBuffer.size())
               this->recapacity( x );
            mSize = x;
         }  
         
         unsigned int bytes() const
         {
            return mSize * (unsigned int)syn::audio_data_traits<DATA_TYPE>::bytes();
         }

         unsigned int capacity() const
         {
            return mBuffer.size();
         }         

         void recapacity( unsigned int x )
         {
            if (x != mBuffer.size())
               mBuffer.resize( x * CHAN );
         }         

         DATA_TYPE* data()
         {
            return (DATA_TYPE*)&mBuffer[0];
         }
         
         DATA_TYPE& operator[]( unsigned int x )
         {
            return mBuffer[x];
         }
         
         const DATA_TYPE& operator[]( unsigned int x ) const 
         {
            return mBuffer[x];
         }   
         
         DATA_TYPE* frame( unsigned int x )
         {
            return &mBuffer[x * CHAN];
         }
         
         const DATA_TYPE* frame( unsigned int x ) const
         {
            return &mBuffer[x * CHAN];
         }

         class iterator
         {
         public:
            iterator( std::vector<DATA_TYPE>* ptr = NULL, unsigned int index = 0)
            {
               mBufferPtr = ptr;
               mIndex = index;
            }         
            inline void operator++()
            {
               ++mIndex;
            }
            inline DATA_TYPE& operator*()
            {
               return (*mBufferPtr)[mIndex];
            }    
            bool operator==( const iterator& rhs )
            {
               return bool( this->mBufferPtr == rhs.mBufferPtr && 
                     this->mIndex == rhs.mIndex );
            }
            bool operator!=( const iterator& rhs )
            {
               return bool( !this->operator==( rhs ) );
            }
         protected:
            friend class SampleBuffer<DATA_TYPE, CHAN>;
            std::vector<DATA_TYPE>* mBufferPtr;
            unsigned int mIndex;
         };         
         
         iterator begin()
         {
            return iterator( &mBuffer, 0 );
         }
         iterator end()
         {
            return iterator( &mBuffer, mBuffer.size() );
         }
         
         class frame_iterator
         {
         public:
            frame_iterator( std::vector<DATA_TYPE>* ptr = NULL, unsigned int index = 0)
            {
               mBufferPtr = ptr;
               mIndex = index;
            }         
            inline void operator++()
            {
               ++mIndex;
            }
            inline DATA_TYPE* operator*()
            {
               return &(*mBufferPtr)[mIndex * CHAN];
            }
            bool operator==( const frame_iterator& rhs )
            {
               return bool( this->mBufferPtr == rhs.mBufferPtr && 
                     this->mIndex == rhs.mIndex );
            }
            bool operator!=( const frame_iterator& rhs )
            {
               return bool( !this->operator==( rhs ) );
            }
         protected:
            friend class SampleBuffer<DATA_TYPE, CHAN>;
            std::vector<DATA_TYPE>* mBufferPtr;
            unsigned int mIndex;
         };         
         
         frame_iterator fbegin()
         {
            return frame_iterator( &mBuffer, 0 );
         }
         frame_iterator fend()
         {
            return frame_iterator( &mBuffer, mSize/2 );
         }
         
         
         void fill( iterator pos, iterator f, iterator l )
         {
            unsigned int size = (l.mIndex - f.mIndex);
            assert( pos.mBufferPtr == &mBuffer && "not my iterator" );
            assert( f.mIndex <= l.mIndex && (size + pos.mIndex) < mSize && "out of bounds" );
            memcpy( &(*pos), &(*f), sizeof( DATA_TYPE ) * size );
         }
         
         void fill( iterator pos, DATA_TYPE* d, unsigned int size )
         {
            assert( pos.mBufferPtr == &mBuffer && "not my iterator" );
            assert( (size + pos.mIndex) <= mSize && "out of bounds" );
            memcpy( &(*pos), d, sizeof( DATA_TYPE ) * size );
         }
                
   private:
      std::vector<DATA_TYPE> mBuffer;
      unsigned int mSize;
   };
  

   typedef SampleBuffer<float, 1> SampleBuffer1f;
   typedef SampleBuffer<float, 2> SampleBuffer2f;
   typedef SampleBuffer<signed short, 1> SampleBuffer1ss;
   typedef SampleBuffer<signed short, 2> SampleBuffer2ss;
   typedef SampleBuffer<unsigned short, 1> SampleBuffer1us;
   typedef SampleBuffer<unsigned short, 2> SampleBuffer2us;

    
   template <typename DATA_TYPE, unsigned CHAN>
   inline SampleBuffer<DATA_TYPE, CHAN>& clamp( SampleBuffer<DATA_TYPE, CHAN>& buf )
   {
      SampleBuffer<DATA_TYPE, CHAN>::iterator it;
      for (it = buf.begin(); it != buf.end(); ++it)
      {
         (*it) = audio_clamp<DATA_TYPE>( (*it) );
      }
      return buf;
   }
   
   inline SampleBuffer1f& operator+=( SampleBuffer1f& lhs, const SampleBuffer1f& rhs )
   {
      assert( lhs.size() == rhs.size() && "+= between different sizes undefined..." );
      for (unsigned int x = 0; x < rhs.size(); ++x)
         lhs.frame(x)[0] += rhs.frame(x)[0];
      return lhs;
   }

   inline SampleBuffer1f& operator*=( SampleBuffer1f& lhs, const SampleBuffer1f& rhs )
   {
      assert( lhs.size() == rhs.size() && "*= between different sizes undefined..." );
      for (unsigned int x = 0; x < rhs.size(); ++x)
         lhs.frame(x)[0] *= rhs.frame(x)[0];
      return lhs;
   }
   
} // end syn namespace...

#endif

---