beeps 0.1.11 → 0.1.16

data/src/stk/src/FileWvIn.cpp

@@ -1,260 +0,0 @@
-/***************************************************/
-/*! \class FileWvIn
-    \brief STK audio file input class.
-
-    This class inherits from WvIn.  It provides a "tick-level"
-    interface to the FileRead class.  It also provides variable-rate
-    playback functionality.  Audio file support is provided by the
-    FileRead class.  Linear interpolation is used for fractional read
-    rates.
-
-    FileWvIn supports multi-channel data.  It is important to
-    distinguish the tick() method that computes a single frame (and
-    returns only the specified sample of a multi-channel frame) from
-    the overloaded one that takes an StkFrames object for
-    multi-channel and/or multi-frame data.
-
-    FileWvIn will either load the entire content of an audio file into
-    local memory or incrementally read file data from disk in chunks.
-    This behavior is controlled by the optional constructor arguments
-    \e chunkThreshold and \e chunkSize.  File sizes greater than \e
-    chunkThreshold (in sample frames) will be read incrementally in
-    chunks of \e chunkSize each (also in sample frames).
-
-    When the file end is reached, subsequent calls to the tick()
-    functions return zeros and isFinished() returns \e true.
-
-    See the FileRead class for a description of the supported audio
-    file formats.
-
-    by Perry R. Cook and Gary P. Scavone, 1995--2014.
-*/
-/***************************************************/
-
-#include "FileWvIn.h"
-#include <cmath>
-
-namespace stk {
-
-FileWvIn :: FileWvIn( unsigned long chunkThreshold, unsigned long chunkSize )
-  : finished_(true), interpolate_(false), time_(0.0), rate_(0.0),
-    chunkThreshold_(chunkThreshold), chunkSize_(chunkSize)
-{
-  Stk::addSampleRateAlert( this );
-}
-
-FileWvIn :: FileWvIn( std::string fileName, bool raw, bool doNormalize,
-                      unsigned long chunkThreshold, unsigned long chunkSize )
-  : finished_(true), interpolate_(false), time_(0.0), rate_(0.0),
-    chunkThreshold_(chunkThreshold), chunkSize_(chunkSize)
-{
-  openFile( fileName, raw, doNormalize );
-  Stk::addSampleRateAlert( this );
-}
-
-FileWvIn :: ~FileWvIn()
-{
-  this->closeFile();
-  Stk::removeSampleRateAlert( this );
-}
-
-void FileWvIn :: sampleRateChanged( StkFloat newRate, StkFloat oldRate )
-{
-  if ( !ignoreSampleRateChange_ )
-    this->setRate( oldRate * rate_ / newRate );
-}
-
-void FileWvIn :: closeFile( void )
-{
-  if ( file_.isOpen() ) file_.close();
-  finished_ = true;
-  lastFrame_.resize( 0, 0 );
-}
-
-void FileWvIn :: openFile( std::string fileName, bool raw, bool doNormalize )
-{
-  // Call close() in case another file is already open.
-  this->closeFile();
-
-  // Attempt to open the file ... an error might be thrown here.
-  file_.open( fileName, raw );
-
-  // Determine whether chunking or not.
-  if ( file_.fileSize() > chunkThreshold_ ) {
-    chunking_ = true;
-    chunkPointer_ = 0;
-    data_.resize( chunkSize_, file_.channels() );
-    if ( doNormalize ) normalizing_ = true;
-    else normalizing_ = false;
-  }
-  else {
-    chunking_ = false;
-    data_.resize( (size_t) file_.fileSize(), file_.channels() );
-  }
-
-  // Load all or part of the data.
-  file_.read( data_, 0, doNormalize );
-
-  // Resize our lastFrame container.
-  lastFrame_.resize( 1, file_.channels() );
-
-  // Set default rate based on file sampling rate.
-  this->setRate( data_.dataRate() / Stk::sampleRate() );
-
-  if ( doNormalize & !chunking_ ) this->normalize();
-
-  this->reset();
-}
-
-void FileWvIn :: reset(void)
-{
-  time_ = (StkFloat) 0.0;
-  for ( unsigned int i=0; i<lastFrame_.size(); i++ ) lastFrame_[i] = 0.0;
-  finished_ = false;
-}
-
-void FileWvIn :: normalize(void)
-{
-  this->normalize( 1.0 );
-}
-
-// Normalize all channels equally by the greatest magnitude in all of the data.
-void FileWvIn :: normalize( StkFloat peak )
-{
-  // When chunking, the "normalization" scaling is performed by FileRead.
-  if ( chunking_ ) return;
-
-  size_t i;
-  StkFloat max = 0.0;
-
-  for ( i=0; i<data_.size(); i++ ) {
-    if ( fabs( data_[i] ) > max )
-      max = (StkFloat) fabs((double) data_[i]);
-  }
-
-  if ( max > 0.0 ) {
-    max = 1.0 / max;
-    max *= peak;
-    for ( i=0; i<data_.size(); i++ )
-      data_[i] *= max;
-  }
-}
-
-void FileWvIn :: setRate( StkFloat rate )
-{
-  rate_ = rate;
-
-  // If negative rate and at beginning of sound, move pointer to end
-  // of sound.
-  if ( (rate_ < 0) && (time_ == 0.0) ) time_ = file_.fileSize() - 1.0;
-
-  if ( fmod( rate_, 1.0 ) != 0.0 ) interpolate_ = true;
-  else interpolate_ = false;
-}
-
-void FileWvIn :: addTime( StkFloat time )   
-{
-  // Add an absolute time in samples 
-  time_ += time;
-
-  if ( time_ < 0.0 ) time_ = 0.0;
-  if ( time_ > file_.fileSize() - 1.0 ) {
-    time_ = file_.fileSize() - 1.0;
-    for ( unsigned int i=0; i<lastFrame_.size(); i++ ) lastFrame_[i] = 0.0;
-    finished_ = true;
-  }
-}
-
-StkFloat FileWvIn :: tick( unsigned int channel )
-{
-#if defined(_STK_DEBUG_)
-  if ( channel >= data_.channels() ) {
-    oStream_ << "FileWvIn::tick(): channel argument and soundfile data are incompatible!";
-    handleError( StkError::FUNCTION_ARGUMENT );
-  }
-#endif
-
-  if ( finished_ ) return 0.0;
-
-  if ( time_ < 0.0 || time_ > (StkFloat) ( file_.fileSize() - 1.0 ) ) {
-    for ( unsigned int i=0; i<lastFrame_.size(); i++ ) lastFrame_[i] = 0.0;
-    finished_ = true;
-    return 0.0;
-  }
-
-  StkFloat tyme = time_;
-  if ( chunking_ ) {
-
-    // Check the time address vs. our current buffer limits.
-    if ( ( time_ < (StkFloat) chunkPointer_ ) ||
-         ( time_ > (StkFloat) ( chunkPointer_ + chunkSize_ - 1 ) ) ) {
-
-      while ( time_ < (StkFloat) chunkPointer_ ) { // negative rate
-        chunkPointer_ -= chunkSize_ - 1; // overlap chunks by one frame
-        if ( chunkPointer_ < 0 ) chunkPointer_ = 0;
-      }
-      while ( time_ > (StkFloat) ( chunkPointer_ + chunkSize_ - 1 ) ) { // positive rate
-        chunkPointer_ += chunkSize_ - 1; // overlap chunks by one frame
-        if ( chunkPointer_ + chunkSize_ > file_.fileSize() ) // at end of file
-          chunkPointer_ = file_.fileSize() - chunkSize_;
-      }
-
-      // Load more data.
-      file_.read( data_, chunkPointer_, normalizing_ );
-    }
-
-    // Adjust index for the current buffer.
-    tyme -= chunkPointer_;
-  }
-
-  if ( interpolate_ ) {
-    for ( unsigned int i=0; i<lastFrame_.size(); i++ )
-      lastFrame_[i] = data_.interpolate( tyme, i );
-  }
-  else {
-    for ( unsigned int i=0; i<lastFrame_.size(); i++ )
-      lastFrame_[i] = data_( (size_t) tyme, i );
-  }
-
-  // Increment time, which can be negative.
-  time_ += rate_;
-
-  return lastFrame_[channel];
-}
-
-StkFrames& FileWvIn :: tick( StkFrames& frames, unsigned int channel)
-{
-  if ( !file_.isOpen() ) {
-#if defined(_STK_DEBUG_)
-    oStream_ << "FileWvIn::tick(): no file data is loaded!";
-    handleError( StkError::DEBUG_PRINT );
-#endif
-    return frames;
-  }
-
-  unsigned int nChannels = lastFrame_.channels();
-#if defined(_STK_DEBUG_)
-  if ( channel > frames.channels() - nChannels ) {
-    oStream_ << "FileWvIn::tick(): channel and StkFrames arguments are incompatible!";
-    handleError( StkError::FUNCTION_ARGUMENT );
-  }
-#endif
-    
-  StkFloat *samples = &frames[channel];
-  unsigned int j, hop = frames.channels() - nChannels;
-  if ( nChannels == 1 ) {
-    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
-      *samples++ = tick();
-  }
-  else {
-    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
-      *samples++ = tick();
-      for ( j=1; j<nChannels; j++ )
-        *samples++ = lastFrame_[j];
-    }
-  }
-  return frames;
-
-}
-
-} // stk namespace

data/src/stk/src/SineWave.cpp

@@ -1,78 +0,0 @@
-/***************************************************/
-/*! \class SineWave
-    \brief STK sinusoid oscillator class.
-
-    This class computes and saves a static sine "table" that can be
-    shared by multiple instances.  It has an interface similar to the
-    WaveLoop class but inherits from the Generator class.  Output
-    values are computed using linear interpolation.
-
-    The "table" length, set in SineWave.h, is 2048 samples by default.
-
-    by Perry R. Cook and Gary P. Scavone, 1995--2014.
-*/
-/***************************************************/
-
-#include "SineWave.h"
-#include <cmath>
-
-namespace stk {
-
-StkFrames SineWave :: table_;
-
-SineWave :: SineWave( void )
-  : time_(0.0), rate_(1.0), phaseOffset_(0.0)
-{
-  if ( table_.empty() ) {
-    table_.resize( TABLE_SIZE + 1, 1 );
-    StkFloat temp = 1.0 / TABLE_SIZE;
-    for ( unsigned long i=0; i<=TABLE_SIZE; i++ )
-      table_[i] = sin( TWO_PI * i * temp );
-  }
-
-  Stk::addSampleRateAlert( this );
-}
-
-SineWave :: ~SineWave()
-{
-  Stk::removeSampleRateAlert( this );
-}
-
-void SineWave :: sampleRateChanged( StkFloat newRate, StkFloat oldRate )
-{
-  if ( !ignoreSampleRateChange_ )
-    this->setRate( oldRate * rate_ / newRate );
-}
-
-void SineWave :: reset( void )
-{
-  time_ = 0.0;
-  lastFrame_[0] = 0;
-}
-
-void SineWave :: setFrequency( StkFloat frequency )
-{
-  // This is a looping frequency.
-  this->setRate( TABLE_SIZE * frequency / Stk::sampleRate() );
-}
-
-void SineWave :: addTime( StkFloat time )
-{
-  // Add an absolute time in samples.
-  time_ += time;
-}
-
-void SineWave :: addPhase( StkFloat phase )
-{
-  // Add a time in cycles (one cycle = TABLE_SIZE).
-  time_ += TABLE_SIZE * phase;
-}
-
-void SineWave :: addPhaseOffset( StkFloat phaseOffset )
-{
-  // Add a phase offset relative to any previous offset value.
-  time_ += ( phaseOffset - phaseOffset_ ) * TABLE_SIZE;
-  phaseOffset_ = phaseOffset;
-}
-
-} // stk namespace

data/src/stk/src/Stk.cpp

@@ -1,395 +0,0 @@
-/***************************************************/
-/*! \class Stk
-    \brief STK base class
-
-    Nearly all STK classes inherit from this class.
-    The global sample rate can be queried and
-    modified via Stk.  In addition, this class
-    provides error handling and byte-swapping
-    functions.
-
-    The Synthesis ToolKit in C++ (STK) is a set of open source audio
-    signal processing and algorithmic synthesis classes written in the
-    C++ programming language. STK was designed to facilitate rapid
-    development of music synthesis and audio processing software, with
-    an emphasis on cross-platform functionality, realtime control,
-    ease of use, and educational example code.  STK currently runs
-    with realtime support (audio and MIDI) on Linux, Macintosh OS X,
-    and Windows computer platforms. Generic, non-realtime support has
-    been tested under NeXTStep, Sun, and other platforms and should
-    work with any standard C++ compiler.
-
-    STK WWW site: http://ccrma.stanford.edu/software/stk/
-
-    The Synthesis ToolKit in C++ (STK)
-    Copyright (c) 1995--2014 Perry R. Cook and Gary P. Scavone
-
-    Permission is hereby granted, free of charge, to any person
-    obtaining a copy of this software and associated documentation files
-    (the "Software"), to deal in the Software without restriction,
-    including without limitation the rights to use, copy, modify, merge,
-    publish, distribute, sublicense, and/or sell copies of the Software,
-    and to permit persons to whom the Software is furnished to do so,
-    subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be
-    included in all copies or substantial portions of the Software.
-
-    Any person wishing to distribute modifications to the Software is
-    asked to send the modifications to the original developer so that
-    they can be incorporated into the canonical version.  This is,
-    however, not a binding provision of this license.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
-    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-/***************************************************/
-
-#include "Stk.h"
-#include <stdlib.h>
-
-namespace stk {
-
-StkFloat Stk :: srate_ = (StkFloat) SRATE;
-std::string Stk :: rawwavepath_ = RAWWAVE_PATH;
-const Stk::StkFormat Stk :: STK_SINT8   = 0x1;
-const Stk::StkFormat Stk :: STK_SINT16  = 0x2;
-const Stk::StkFormat Stk :: STK_SINT24  = 0x4;
-const Stk::StkFormat Stk :: STK_SINT32  = 0x8;
-const Stk::StkFormat Stk :: STK_FLOAT32 = 0x10;
-const Stk::StkFormat Stk :: STK_FLOAT64 = 0x20;
-bool Stk :: showWarnings_ = true;
-bool Stk :: printErrors_ = true;
-std::vector<Stk *> Stk :: alertList_;
-std::ostringstream Stk :: oStream_;
-
-Stk :: Stk( void )
-  : ignoreSampleRateChange_(false)
-{
-}
-
-Stk :: ~Stk( void )
-{
-}
-
-void Stk :: setSampleRate( StkFloat rate )
-{
-  if ( rate > 0.0 && rate != srate_ ) {
-    StkFloat oldRate = srate_;
-    srate_ = rate;
-
-    for ( unsigned int i=0; i<alertList_.size(); i++ )
-      alertList_[i]->sampleRateChanged( srate_, oldRate );
-  }
-}
-
-void Stk :: sampleRateChanged( StkFloat /*newRate*/, StkFloat /*oldRate*/ )
-{
-  // This function should be reimplemented in classes that need to
-  // make internal variable adjustments in response to a global sample
-  // rate change.
-}
-
-void Stk :: addSampleRateAlert( Stk *ptr )
-{
-  for ( unsigned int i=0; i<alertList_.size(); i++ )
-    if ( alertList_[i] == ptr ) return;
-
-  alertList_.push_back( ptr );
-}
-
-void Stk :: removeSampleRateAlert( Stk *ptr )
-{
-  for ( unsigned int i=0; i<alertList_.size(); i++ ) {
-    if ( alertList_[i] == ptr ) {
-      alertList_.erase( alertList_.begin() + i );
-      return;
-    }
-  }
-}
-
-void Stk :: setRawwavePath( std::string path )
-{
-  if ( !path.empty() )
-    rawwavepath_ = path;
-
-  // Make sure the path includes a "/"
-  if ( rawwavepath_[rawwavepath_.length()-1] != '/' )
-    rawwavepath_ += "/";
-}
-
-void Stk :: swap16(unsigned char *ptr)
-{
-  unsigned char val;
-
-  // Swap 1st and 2nd bytes
-  val = *(ptr);
-  *(ptr) = *(ptr+1);
-  *(ptr+1) = val;
-}
-
-void Stk :: swap32(unsigned char *ptr)
-{
-  unsigned char val;
-
-  // Swap 1st and 4th bytes
-  val = *(ptr);
-  *(ptr) = *(ptr+3);
-  *(ptr+3) = val;
-
-  //Swap 2nd and 3rd bytes
-  ptr += 1;
-  val = *(ptr);
-  *(ptr) = *(ptr+1);
-  *(ptr+1) = val;
-}
-
-void Stk :: swap64(unsigned char *ptr)
-{
-  unsigned char val;
-
-  // Swap 1st and 8th bytes
-  val = *(ptr);
-  *(ptr) = *(ptr+7);
-  *(ptr+7) = val;
-
-  // Swap 2nd and 7th bytes
-  ptr += 1;
-  val = *(ptr);
-  *(ptr) = *(ptr+5);
-  *(ptr+5) = val;
-
-  // Swap 3rd and 6th bytes
-  ptr += 1;
-  val = *(ptr);
-  *(ptr) = *(ptr+3);
-  *(ptr+3) = val;
-
-  // Swap 4th and 5th bytes
-  ptr += 1;
-  val = *(ptr);
-  *(ptr) = *(ptr+1);
-  *(ptr+1) = val;
-}
-
-#if (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))
-  #include <unistd.h>
-#elif defined(__OS_WINDOWS__)
-  #include <windows.h>
-#endif
-
-void Stk :: sleep(unsigned long milliseconds)
-{
-#if defined(__OS_WINDOWS__)
-  Sleep((DWORD) milliseconds);
-#elif (defined(__OS_IRIX__) || defined(__OS_LINUX__) || defined(__OS_MACOSX__))
-  usleep( (unsigned long) (milliseconds * 1000.0) );
-#endif
-}
-
-void Stk :: handleError( StkError::Type type ) const
-{
-  handleError( oStream_.str(), type );
-  oStream_.str( std::string() ); // reset the ostringstream buffer
-}
-
-void Stk :: handleError( const char *message, StkError::Type type )
-{
-  std::string msg( message );
-  handleError( msg, type );
-}
-
-void Stk :: handleError( std::string message, StkError::Type type )
-{
-  if ( type == StkError::WARNING || type == StkError::STATUS ) {
-    if ( !showWarnings_ ) return;
-    std::cerr << '\n' << message << '\n' << std::endl;
-  }
-  else if (type == StkError::DEBUG_PRINT) {
-#if defined(_STK_DEBUG_)
-    std::cerr << '\n' << message << '\n' << std::endl;
-#endif
-  }
-  else {
-    if ( printErrors_ ) {
-      // Print error message before throwing.
-      std::cerr << '\n' << message << '\n' << std::endl;
-    }
-    throw StkError(message, type);
-  }
-}
-
-//
-// StkFrames definitions
-//
-
-StkFrames :: StkFrames( unsigned int nFrames, unsigned int nChannels )
-  : data_( 0 ), nFrames_( nFrames ), nChannels_( nChannels )
-{
-  size_ = nFrames_ * nChannels_;
-  bufferSize_ = size_;
-
-  if ( size_ > 0 ) {
-    data_ = (StkFloat *) calloc( size_, sizeof( StkFloat ) );
-#if defined(_STK_DEBUG_)
-    if ( data_ == NULL ) {
-      std::string error = "StkFrames: memory allocation error in constructor!";
-      Stk::handleError( error, StkError::MEMORY_ALLOCATION );
-    }
-#endif
-  }
-
-  dataRate_ = Stk::sampleRate();
-}
-
-StkFrames :: StkFrames( const StkFloat& value, unsigned int nFrames, unsigned int nChannels )
-  : data_( 0 ), nFrames_( nFrames ), nChannels_( nChannels )
-{
-  size_ = nFrames_ * nChannels_;
-  bufferSize_ = size_;
-  if ( size_ > 0 ) {
-    data_ = (StkFloat *) malloc( size_ * sizeof( StkFloat ) );
-#if defined(_STK_DEBUG_)
-    if ( data_ == NULL ) {
-      std::string error = "StkFrames: memory allocation error in constructor!";
-      Stk::handleError( error, StkError::MEMORY_ALLOCATION );
-    }
-#endif
-    for ( long i=0; i<(long)size_; i++ ) data_[i] = value;
-  }
-
-  dataRate_ = Stk::sampleRate();
-}
-
-StkFrames :: ~StkFrames()
-{
-  if ( data_ ) free( data_ );
-}
-
-StkFrames :: StkFrames( const StkFrames& f )
-  : data_(0), size_(0), bufferSize_(0)
-{
-  resize( f.frames(), f.channels() );
-  dataRate_ = Stk::sampleRate();
-  for ( unsigned int i=0; i<size_; i++ ) data_[i] = f[i];
-}
-
-StkFrames& StkFrames :: operator= ( const StkFrames& f )
-{
-  if ( data_ ) free( data_ );
-  data_ = 0;
-  size_ = 0;
-  bufferSize_ = 0;
-  resize( f.frames(), f.channels() );
-  dataRate_ = Stk::sampleRate();
-  for ( unsigned int i=0; i<size_; i++ ) data_[i] = f[i];
-  return *this;
-}
-
-void StkFrames :: resize( size_t nFrames, unsigned int nChannels )
-{
-  nFrames_ = nFrames;
-  nChannels_ = nChannels;
-
-  size_ = nFrames_ * nChannels_;
-  if ( size_ > bufferSize_ ) {
-    if ( data_ ) free( data_ );
-    data_ = (StkFloat *) malloc( size_ * sizeof( StkFloat ) );
-#if defined(_STK_DEBUG_)
-    if ( data_ == NULL ) {
-      std::string error = "StkFrames::resize: memory allocation error!";
-      Stk::handleError( error, StkError::MEMORY_ALLOCATION );
-    }
-#endif
-    bufferSize_ = size_;
-  }
-}
-
-void StkFrames :: resize( size_t nFrames, unsigned int nChannels, StkFloat value )
-{
-  this->resize( nFrames, nChannels );
-
-  for ( size_t i=0; i<size_; i++ ) data_[i] = value;
-}
-    
-StkFrames& StkFrames::getChannel(unsigned int sourceChannel,StkFrames& destinationFrames, unsigned int destinationChannel) const
-{
-#if defined(_STK_DEBUG_)
-  if (sourceChannel > channels() - 1) {
-    std::ostringstream error;
-    error << "StkFrames::getChannel invalid sourceChannel (" << sourceChannel << ")";
-    Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT);
-  }
-  if (destinationChannel > destinationFrames.channels() - 1) {
-    std::ostringstream error;
-    error << "StkFrames::getChannel invalid destinationChannel (" << destinationChannel << ")";
-    Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT );
-  }
-  if (destinationFrames.frames() < frames()) {
-    std::ostringstream error;
-    error << "StkFrames::getChannel destination.frames() < frames()";
-    Stk::handleError( error.str(), StkError::MEMORY_ACCESS);
-  }
-#endif
-  int sourceHop = nChannels_;
-  int destinationHop = destinationFrames.nChannels_;
-  for (int i  = sourceChannel, j= destinationChannel; i < nFrames_ * nChannels_; i+=sourceHop,j+=destinationHop) {
-    destinationFrames[j] = data_[i];
-  }
-  return destinationFrames;
-        
-}
-
-void StkFrames::setChannel(unsigned int destinationChannel, const stk::StkFrames &sourceFrames,unsigned int sourceChannel)
-{
-#if defined(_STK_DEBUG_)
-  if (sourceChannel > sourceFrames.channels() - 1) {
-    std::ostringstream error;
-    error << "StkFrames::setChannel invalid sourceChannel (" << sourceChannel << ")";
-    Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT);
-  }
-  if (destinationChannel > channels() - 1) {
-    std::ostringstream error;
-    error << "StkFrames::setChannel invalid channel (" << destinationChannel << ")";
-    Stk::handleError( error.str(), StkError::FUNCTION_ARGUMENT );
-  }
-  if (sourceFrames.frames() != frames()) {
-    std::ostringstream error;
-    error << "StkFrames::setChannel sourceFrames.frames() != frames()";
-    Stk::handleError( error.str(), StkError::MEMORY_ACCESS);
-  }
-#endif
-  unsigned int sourceHop = sourceFrames.nChannels_;
-  unsigned int destinationHop = nChannels_;
-  for (int i  = destinationChannel,j = sourceChannel ; i < nFrames_ * nChannels_; i+=destinationHop,j+=sourceHop) {
-    data_[i] = sourceFrames[j];
-  }
-}
-
-StkFloat StkFrames :: interpolate( StkFloat frame, unsigned int channel ) const
-{
-#if defined(_STK_DEBUG_)
-  if ( frame < 0.0 || frame > (StkFloat) ( nFrames_ - 1 ) || channel >= nChannels_ ) {
-    std::ostringstream error;
-    error << "StkFrames::interpolate: invalid frame (" << frame << ") or channel (" << channel << ") value!";
-    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
-  }
-#endif
-
-  size_t iIndex = ( size_t ) frame;                    // integer part of index
-  StkFloat output, alpha = frame - (StkFloat) iIndex;  // fractional part of index
-
-  iIndex = iIndex * nChannels_ + channel;
-  output = data_[ iIndex ];
-  if ( alpha > 0.0 )
-    output += ( alpha * ( data_[ iIndex + nChannels_ ] - output ) );
-
-  return output;
-}
-
-} // stk namespace