Home Information Classes Download Usage Mail List Requirements Links FAQ Tutorial
00001 #ifndef STK_STK_H 00002 #define STK_STK_H 00003 00004 #include <string> 00005 #include <iostream> 00006 #include <sstream> 00007 #include <vector> 00008 #include <cstdlib> 00009 00016 namespace stk { 00017 00018 /***************************************************/ 00068 /***************************************************/ 00069 00070 //#define _STK_DEBUG_ 00071 00072 // Most data in STK is passed and calculated with the 00073 // following user-definable floating-point type. You 00074 // can change this to "float" if you prefer or perhaps 00075 // a "long double" in the future. 00076 typedef double StkFloat; 00077 00079 00084 class StkError 00085 { 00086 public: 00087 enum Type { 00088 STATUS, 00089 WARNING, 00090 DEBUG_WARNING, 00091 MEMORY_ALLOCATION, 00092 MEMORY_ACCESS, 00093 FUNCTION_ARGUMENT, 00094 FILE_NOT_FOUND, 00095 FILE_UNKNOWN_FORMAT, 00096 FILE_ERROR, 00097 PROCESS_THREAD, 00098 PROCESS_SOCKET, 00099 PROCESS_SOCKET_IPADDR, 00100 AUDIO_SYSTEM, 00101 MIDI_SYSTEM, 00102 UNSPECIFIED 00103 }; 00104 00105 protected: 00106 std::string message_; 00107 Type type_; 00108 00109 public: 00111 StkError(const std::string& message, Type type = StkError::UNSPECIFIED) 00112 : message_(message), type_(type) {} 00113 00115 virtual ~StkError(void) {}; 00116 00118 virtual void printMessage(void) { std::cerr << '\n' << message_ << "\n\n"; } 00119 00121 virtual const Type& getType(void) { return type_; } 00122 00124 virtual const std::string& getMessage(void) { return message_; } 00125 00127 virtual const char *getMessageCString(void) { return message_.c_str(); } 00128 }; 00129 00130 00131 class Stk 00132 { 00133 public: 00134 00135 typedef unsigned long StkFormat; 00136 static const StkFormat STK_SINT8; 00137 static const StkFormat STK_SINT16; 00138 static const StkFormat STK_SINT24; 00139 static const StkFormat STK_SINT32; 00140 static const StkFormat STK_FLOAT32; 00141 static const StkFormat STK_FLOAT64; 00143 00144 static StkFloat sampleRate( void ) { return srate_; } 00145 00147 00164 static void setSampleRate( StkFloat rate ); 00165 00167 00172 void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; }; 00173 00175 static std::string rawwavePath(void) { return rawwavepath_; } 00176 00178 static void setRawwavePath( std::string path ); 00179 00181 static void swap16( unsigned char *ptr ); 00182 00184 static void swap32( unsigned char *ptr ); 00185 00187 static void swap64( unsigned char *ptr ); 00188 00190 static void sleep( unsigned long milliseconds ); 00191 00193 static void handleError( const char *message, StkError::Type type ); 00194 00196 static void handleError( std::string message, StkError::Type type ); 00197 00199 static void showWarnings( bool status ) { showWarnings_ = status; } 00200 00202 static void printErrors( bool status ) { printErrors_ = status; } 00203 00204 private: 00205 static StkFloat srate_; 00206 static std::string rawwavepath_; 00207 static bool showWarnings_; 00208 static bool printErrors_; 00209 static std::vector<Stk *> alertList_; 00210 00211 protected: 00212 00213 std::ostringstream errorString_; 00214 bool ignoreSampleRateChange_; 00215 00217 Stk( void ); 00218 00220 virtual ~Stk( void ); 00221 00223 virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate ); 00224 00226 void addSampleRateAlert( Stk *ptr ); 00227 00229 void removeSampleRateAlert( Stk *ptr ); 00230 00232 void handleError( StkError::Type type ); 00233 }; 00234 00235 00236 /***************************************************/ 00259 /***************************************************/ 00260 00261 class StkFrames 00262 { 00263 public: 00264 00266 StkFrames( unsigned int nFrames = 0, unsigned int nChannels = 0 ); 00267 00269 StkFrames( const StkFloat& value, unsigned int nFrames, unsigned int nChannels ); 00270 00272 ~StkFrames(); 00273 00274 // A copy constructor. 00275 StkFrames( const StkFrames& f ); 00276 00277 // Assignment operator that returns a reference to self. 00278 StkFrames& operator= ( const StkFrames& f ); 00279 00281 00287 StkFloat& operator[] ( size_t n ); 00288 00290 00294 StkFloat operator[] ( size_t n ) const; 00295 00297 00302 void operator+= ( StkFrames& f ); 00303 00305 00310 void operator*= ( StkFrames& f ); 00311 00313 00320 StkFloat& operator() ( size_t frame, unsigned int channel ); 00321 00323 00328 StkFloat operator() ( size_t frame, unsigned int channel ) const; 00329 00331 00337 StkFloat interpolate( StkFloat frame, unsigned int channel = 0 ) const; 00338 00340 size_t size() const { return size_; }; 00341 00343 bool empty() const; 00344 00346 00353 void resize( size_t nFrames, unsigned int nChannels = 1 ); 00354 00356 00363 void resize( size_t nFrames, unsigned int nChannels, StkFloat value ); 00364 00366 unsigned int channels( void ) const { return nChannels_; }; 00367 00369 unsigned int frames( void ) const { return nFrames_; }; 00370 00372 00376 void setDataRate( StkFloat rate ) { dataRate_ = rate; }; 00377 00379 00383 StkFloat dataRate( void ) const { return dataRate_; }; 00384 00385 private: 00386 00387 StkFloat *data_; 00388 StkFloat dataRate_; 00389 size_t nFrames_; 00390 unsigned int nChannels_; 00391 size_t size_; 00392 size_t bufferSize_; 00393 00394 }; 00395 00396 inline bool StkFrames :: empty() const 00397 { 00398 if ( size_ > 0 ) return false; 00399 else return true; 00400 } 00401 00402 inline StkFloat& StkFrames :: operator[] ( size_t n ) 00403 { 00404 #if defined(_STK_DEBUG_) 00405 if ( n >= size_ ) { 00406 std::ostringstream error; 00407 error << "StkFrames::operator[]: invalid index (" << n << ") value!"; 00408 Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); 00409 } 00410 #endif 00411 00412 return data_[n]; 00413 } 00414 00415 inline StkFloat StkFrames :: operator[] ( size_t n ) const 00416 { 00417 #if defined(_STK_DEBUG_) 00418 if ( n >= size_ ) { 00419 std::ostringstream error; 00420 error << "StkFrames::operator[]: invalid index (" << n << ") value!"; 00421 Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); 00422 } 00423 #endif 00424 00425 return data_[n]; 00426 } 00427 00428 inline StkFloat& StkFrames :: operator() ( size_t frame, unsigned int channel ) 00429 { 00430 #if defined(_STK_DEBUG_) 00431 if ( frame >= nFrames_ || channel >= nChannels_ ) { 00432 std::ostringstream error; 00433 error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!"; 00434 Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); 00435 } 00436 #endif 00437 00438 return data_[ frame * nChannels_ + channel ]; 00439 } 00440 00441 inline StkFloat StkFrames :: operator() ( size_t frame, unsigned int channel ) const 00442 { 00443 #if defined(_STK_DEBUG_) 00444 if ( frame >= nFrames_ || channel >= nChannels_ ) { 00445 std::ostringstream error; 00446 error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!"; 00447 Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); 00448 } 00449 #endif 00450 00451 return data_[ frame * nChannels_ + channel ]; 00452 } 00453 00454 inline void StkFrames :: operator+= ( StkFrames& f ) 00455 { 00456 #if defined(_STK_DEBUG_) 00457 if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) { 00458 std::ostringstream error; 00459 error << "StkFrames::operator+=: frames argument must be of equal dimensions!"; 00460 Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); 00461 } 00462 #endif 00463 00464 StkFloat *fptr = &f[0]; 00465 StkFloat *dptr = data_; 00466 for ( unsigned int i=0; i<size_; i++ ) 00467 *dptr++ += *fptr++; 00468 } 00469 00470 inline void StkFrames :: operator*= ( StkFrames& f ) 00471 { 00472 #if defined(_STK_DEBUG_) 00473 if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) { 00474 std::ostringstream error; 00475 error << "StkFrames::operator*=: frames argument must be of equal dimensions!"; 00476 Stk::handleError( error.str(), StkError::MEMORY_ACCESS ); 00477 } 00478 #endif 00479 00480 StkFloat *fptr = &f[0]; 00481 StkFloat *dptr = data_; 00482 for ( unsigned int i=0; i<size_; i++ ) 00483 *dptr++ *= *fptr++; 00484 } 00485 00486 // Here are a few other useful typedefs. 00487 typedef unsigned short UINT16; 00488 typedef unsigned int UINT32; 00489 typedef signed short SINT16; 00490 typedef signed int SINT32; 00491 typedef float FLOAT32; 00492 typedef double FLOAT64; 00493 00494 // The default sampling rate. 00495 const StkFloat SRATE = 44100.0; 00496 00497 // The default real-time audio input and output buffer size. If 00498 // clicks are occuring in the input and/or output sound stream, a 00499 // larger buffer size may help. Larger buffer sizes, however, produce 00500 // more latency. 00501 const unsigned int RT_BUFFER_SIZE = 512; 00502 00503 // The default rawwave path value is set with the preprocessor 00504 // definition RAWWAVE_PATH. This can be specified as an argument to 00505 // the configure script, in an integrated development environment, or 00506 // below. The global STK rawwave path variable can be dynamically set 00507 // with the Stk::setRawwavePath() function. This value is 00508 // concatenated to the beginning of all references to rawwave files in 00509 // the various STK core classes (ex. Clarinet.cpp). If you wish to 00510 // move the rawwaves directory to a different location in your file 00511 // system, you will need to set this path definition appropriately. 00512 #if !defined(RAWWAVE_PATH) 00513 #define RAWWAVE_PATH "../../rawwaves/" 00514 #endif 00515 00516 const StkFloat PI = 3.14159265358979; 00517 const StkFloat TWO_PI = 2 * PI; 00518 const StkFloat ONE_OVER_128 = 0.0078125; 00519 00520 #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_MM__) 00521 #define __OS_WINDOWS__ 00522 #define __STK_REALTIME__ 00523 #elif defined(__LINUX_OSS__) || defined(__LINUX_ALSA__) || defined(__UNIX_JACK__) 00524 #define __OS_LINUX__ 00525 #define __STK_REALTIME__ 00526 #elif defined(__IRIX_AL__) 00527 #define __OS_IRIX__ 00528 #elif defined(__MACOSX_CORE__) || defined(__UNIX_JACK__) 00529 #define __OS_MACOSX__ 00530 #define __STK_REALTIME__ 00531 #endif 00532 00533 } // stk namespace 00534 00535 #endif
The Synthesis ToolKit in C++ (STK) |
©1995-2010 Perry R. Cook and Gary P. Scavone. All Rights Reserved. |