beeps 0.1.10

data/src/stk/src/FileWvIn.cpp

@@ -0,0 +1,260 @@
+/***************************************************/
+/*! \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

@@ -0,0 +1,78 @@
+/***************************************************/
+/*! \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

@@ -0,0 +1,395 @@
+/***************************************************/
+/*! \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