Stk.h

#ifndef STK_STK_H
#define STK_STK_H

#include <string>
#include <cstring>
#include <iostream>
#include <sstream>
#include <vector>
//#include <cstdlib>

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 double 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) { std::cerr << '\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 PI           = 3.14159265358979;
const StkFloat TWO_PI       = 2 * 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