Stk.h

#ifndef STK_STK_H
#define STK_STK_H
 
#include "ArdConfig.h"
#include <string>
#include <cstring>
#include <vector>
#include <iostream>
#include <sstream>
#ifdef __ARDUINO__
#include <cstdlib>
#endif
 
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
//#define _STK_DEBUG_
 
// Most data in STK is passed and calculated with the
// following user-definable floating-point type.  You
// can change this to "float" if you prefer or perhaps
// a "long double" in the future.
typedef float StkFloat;
 
 
class StkError
{
public:
  enum Type {
    STATUS,
    WARNING,
    DEBUG_PRINT,
    MEMORY_ALLOCATION,
    MEMORY_ACCESS,
    FUNCTION_ARGUMENT,
    FILE_NOT_FOUND,
    FILE_UNKNOWN_FORMAT,
    FILE_ERROR,
    PROCESS_THREAD,
    PROCESS_SOCKET,
    PROCESS_SOCKET_IPADDR,
    AUDIO_SYSTEM,
    MIDI_SYSTEM,
    UNSPECIFIED
  };
 
protected:
  std::string message_;
  Type type_;
 
public:
  StkError(const std::string& message, Type type = StkError::UNSPECIFIED)
    : message_(message), type_(type) {}
 
  virtual ~StkError(void) {};
 
  virtual void printMessage(void) { 
    #ifdef __ARDUINO__
    std::ostream* out = &std::cout;
    #else
    std::ostream* out = &std::cerr;
    #endif
    *out << '\n' << message_ << "\n\n";
  }
 
  virtual const Type& getType(void) { return type_; }
 
  virtual const std::string& getMessage(void) { return message_; }
 
  virtual const char *getMessageCString(void) { return message_.c_str(); }
};
 
 
class Stk
{
public:
 
  typedef unsigned long StkFormat;
  static const StkFormat STK_SINT8;   
  static const StkFormat STK_SINT16;  
  static const StkFormat STK_SINT24;  
  static const StkFormat STK_SINT32;  
  static const StkFormat STK_FLOAT32; 
  static const StkFormat STK_FLOAT64; 
  static StkFloat sampleRate( void ) { return srate_; }
 
 
  static void setSampleRate( StkFloat rate );
 
 
  void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; };
  
  static void  clear_alertList(){std::vector<Stk *>().swap(alertList_);};
  
  static std::string rawwavePath(void) { return rawwavepath_; }
 
  static void setRawwavePath( std::string path );
 
  static void swap16( unsigned char *ptr );
 
  static void swap32( unsigned char *ptr );
 
  static void swap64( unsigned char *ptr );
 
  static void sleep( unsigned long milliseconds );
 
  static bool inRange( StkFloat value, StkFloat min, StkFloat max ) {
    if ( value < min ) return false;
    else if ( value > max ) return false;
    else return true;
  }
 
  static void handleError( const char *message, StkError::Type type );
 
  static void handleError( std::string message, StkError::Type type );
 
  static void showWarnings( bool status ) { showWarnings_ = status; }
 
  static void printErrors( bool status ) { printErrors_ = status; }
 
private:
  static StkFloat srate_;
  static std::string rawwavepath_;
  static bool showWarnings_;
  static bool printErrors_;
  static std::vector<Stk *> alertList_;
 
protected:
 
  static std::ostringstream oStream_;
  bool ignoreSampleRateChange_;
 
  Stk( void );
 
  virtual ~Stk( void );
 
  virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
  void addSampleRateAlert( Stk *ptr );
 
  void removeSampleRateAlert( Stk *ptr );
 
  void handleError( StkError::Type type ) const;
};
 
 
/***************************************************/
/***************************************************/
 
class StkFrames
{
public:
 
  StkFrames( unsigned int nFrames = 0, unsigned int nChannels = 0 );
 
  StkFrames( const StkFloat& value, unsigned int nFrames, unsigned int nChannels );
 
  ~StkFrames();
 
  // A copy constructor.
  StkFrames( const StkFrames& f );
 
  // Assignment operator that returns a reference to self.
  StkFrames& operator= ( const StkFrames& f );
 
 
  StkFloat& operator[] ( size_t n );
 
 
  StkFloat operator[] ( size_t n ) const;
    
 
  StkFrames operator+(const StkFrames &frames) const;
 
 
  void operator+= ( StkFrames& f );
 
 
  void operator*= ( StkFrames& f );
 
 
  StkFloat& operator() ( size_t frame, unsigned int channel );
 
 
  StkFloat operator() ( size_t frame, unsigned int channel ) const;
 
 
  StkFloat interpolate( StkFloat frame, unsigned int channel = 0 ) const;
 
  size_t size() const { return size_; }; 
 
  bool empty() const;
 
 
  void resize( size_t nFrames, unsigned int nChannels = 1 );
 
 
  void resize( size_t nFrames, unsigned int nChannels, StkFloat value );
 
 
  StkFrames& getChannel(unsigned int channel,StkFrames& destinationFrames, unsigned int destinationChannel) const;
 
 
  void setChannel(unsigned int channel,const StkFrames &sourceFrames,unsigned int sourceChannel);
 
  unsigned int channels( void ) const { return nChannels_; };
 
  unsigned int frames( void ) const { return (unsigned int)nFrames_; };
 
 
  void setDataRate( StkFloat rate ) { dataRate_ = rate; };
 
 
  StkFloat dataRate( void ) const { return dataRate_; };
 
private:
 
  StkFloat *data_;
  StkFloat dataRate_;
  size_t nFrames_;
  unsigned int nChannels_;
  size_t size_;
  size_t bufferSize_;
 
};
 
inline bool StkFrames :: empty() const
{
  if ( size_ > 0 ) return false;
  else return true;
}
 
inline StkFloat& StkFrames :: operator[] ( size_t n )
{
#if defined(_STK_DEBUG_)
  if ( n >= size_ ) {
    std::ostringstream error;
    error << "StkFrames::operator[]: invalid index (" << n << ") value!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
 
  return data_[n];
}
 
inline StkFloat StkFrames :: operator[] ( size_t n ) const
{
#if defined(_STK_DEBUG_)
  if ( n >= size_ ) {
    std::ostringstream error;
    error << "StkFrames::operator[]: invalid index (" << n << ") value!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
 
  return data_[n];
}
 
inline StkFloat& StkFrames :: operator() ( size_t frame, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( frame >= nFrames_ || channel >= nChannels_ ) {
    std::ostringstream error;
    error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
 
  return data_[ frame * nChannels_ + channel ];
}
 
inline StkFloat StkFrames :: operator() ( size_t frame, unsigned int channel ) const
{
#if defined(_STK_DEBUG_)
  if ( frame >= nFrames_ || channel >= nChannels_ ) {
    std::ostringstream error;
    error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
 
  return data_[ frame * nChannels_ + channel ];
}
    
inline StkFrames StkFrames::operator+(const StkFrames &f) const
{
#if defined(_STK_DEBUG_)
  if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) {
    std::ostringstream error;
    error << "StkFrames::operator+: frames argument must be of equal dimensions!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
  StkFrames sum((unsigned int)nFrames_,nChannels_);
  StkFloat *sumPtr = &sum[0];
  const StkFloat *fptr = f.data_;
  const StkFloat *dPtr = data_;
  for (unsigned int i = 0; i < size_; i++) {
    *sumPtr++ = *fptr++ + *dPtr++;
  }
  return sum;
}
 
inline void StkFrames :: operator+= ( StkFrames& f )
{
#if defined(_STK_DEBUG_)
  if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) {
    std::ostringstream error;
    error << "StkFrames::operator+=: frames argument must be of equal dimensions!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
 
  StkFloat *fptr = &f[0];
  StkFloat *dptr = data_;
  for ( unsigned int i=0; i<size_; i++ )
    *dptr++ += *fptr++;
}
 
inline void StkFrames :: operator*= ( StkFrames& f )
{
#if defined(_STK_DEBUG_)
  if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) {
    std::ostringstream error;
    error << "StkFrames::operator*=: frames argument must be of equal dimensions!";
    Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
  }
#endif
 
  StkFloat *fptr = &f[0];
  StkFloat *dptr = data_;
  for ( unsigned int i=0; i<size_; i++ )
    *dptr++ *= *fptr++;
}
 
// Here are a few other useful typedefs.
typedef unsigned short UINT16;
typedef unsigned int UINT32;
typedef signed short SINT16;
typedef signed int SINT32;
typedef float FLOAT32;
typedef double FLOAT64;
 
// The default sampling rate.
const StkFloat SRATE = 44100.0;
 
// The default real-time audio input and output buffer size.  If
// clicks are occuring in the input and/or output sound stream, a
// larger buffer size may help.  Larger buffer sizes, however, produce
// more latency.
const unsigned int RT_BUFFER_SIZE = 512;
 
// The default rawwave path value is set with the preprocessor
// definition RAWWAVE_PATH.  This can be specified as an argument to
// the configure script, in an integrated development environment, or
// below.  The global STK rawwave path variable can be dynamically set
// with the Stk::setRawwavePath() function.  This value is
// concatenated to the beginning of all references to rawwave files in
// the various STK core classes (e.g. Clarinet.cpp).  If you wish to
// move the rawwaves directory to a different location in your file
// system, you will need to set this path definition appropriately.
#if !defined(RAWWAVE_PATH)
  #define RAWWAVE_PATH "../../rawwaves/"
#endif
 
const StkFloat STK_PI           = 3.14159265358979;
const StkFloat STK_TWO_PI       = 2 * STK_PI;
 
const StkFloat ONE_OVER_128 = 0.0078125;
 
#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_MM__)
  #define __OS_WINDOWS__
  #define __STK_REALTIME__
#elif defined(__LINUX_OSS__) || defined(__LINUX_ALSA__) || defined(__UNIX_JACK__)
  #define __OS_LINUX__
  #define __STK_REALTIME__
#elif defined(__IRIX_AL__)
  #define __OS_IRIX__
#elif defined(__MACOSX_CORE__) || defined(__UNIX_JACK__)
  #define __OS_MACOSX__
  #define __STK_REALTIME__
#endif
 
} // stk namespace
 
#endif