Arduino STK 4.6.2
Stk.h
1#ifndef STK_STK_H
2#define STK_STK_H
3
4#include "ArdConfig.h"
5#include "ArdStkLogger.h"
6#include <string>
7#include <cstring>
8#include <vector>
9#include <iostream>
10#include <sstream>
11#ifdef __ARDUINO__
12#include <cstdlib>
13#endif
14
15
22namespace stk {
23
24/***************************************************/
74/***************************************************/
75
76//#define _STK_DEBUG_
77
78// Most data in STK is passed and calculated with the
79// following user-definable floating-point type. You
80// can change this to "float" if you prefer or perhaps
81// a "long double" in the future.
82typedef float StkFloat;
83
85
91{
92public:
93 enum Type {
94 STATUS,
95 WARNING,
96 DEBUG_PRINT,
97 MEMORY_ALLOCATION,
98 MEMORY_ACCESS,
99 FUNCTION_ARGUMENT,
100 FILE_NOT_FOUND,
101 FILE_UNKNOWN_FORMAT,
102 FILE_ERROR,
103 PROCESS_THREAD,
104 PROCESS_SOCKET,
105 PROCESS_SOCKET_IPADDR,
106 AUDIO_SYSTEM,
107 MIDI_SYSTEM,
108 UNSPECIFIED
109 };
110
111protected:
112 std::string message_;
113 Type type_;
114
115public:
117 StkError(const std::string& message, Type type = StkError::UNSPECIFIED)
118 : message_(message), type_(type) {}
119
121 virtual ~StkError(void) {};
122
124 virtual void printMessage(void) {
125 #ifdef __ARDUINO__
126 std::ostream* out = &std::cout;
127 #else
128 std::ostream* out = &std::cerr;
129 #endif
130 *out << '\n' << message_ << "\n\n";
131 }
132
134 virtual const Type& getType(void) { return type_; }
135
137 virtual const std::string& getMessage(void) { return message_; }
138
140 virtual const char *getMessageCString(void) { return message_.c_str(); }
141};
142
143
144class Stk
145{
146public:
147 typedef unsigned long StkFormat;
148 static const StkFormat STK_SINT8;
149 static const StkFormat STK_SINT16;
150 static const StkFormat STK_SINT24;
151 static const StkFormat STK_SINT32;
152 static const StkFormat STK_FLOAT32;
153 static const StkFormat STK_FLOAT64;
154
156 static StkFloat sampleRate( void ) { return srate_; }
157
159
176 static void setSampleRate( StkFloat rate );
177
179
184 void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; };
185
187 static void clear_alertList(){std::vector<Stk *>().swap(alertList_);};
188
190 static std::string rawwavePath(void) { return rawwavepath_; }
191
193 static void setRawwavePath( std::string path );
194
196 static void swap16( unsigned char *ptr );
197
199 static void swap32( unsigned char *ptr );
200
202 static void swap64( unsigned char *ptr );
203
205 static void sleep( unsigned long milliseconds );
206
208 static bool inRange( StkFloat value, StkFloat min, StkFloat max ) {
209 if ( value < min ) return false;
210 else if ( value > max ) return false;
211 else return true;
212 }
213
215 static void handleError( const char *message, StkError::Type type );
216
218 static void handleError( std::string message, StkError::Type type );
219
221 static void showWarnings( bool status ) { showWarnings_ = status; }
222
224 static void printErrors( bool status ) { printErrors_ = status; }
225
226private:
227 static StkFloat srate_;
228 static std::string rawwavepath_;
229 static bool showWarnings_;
230 static bool printErrors_;
231 static std::vector<Stk *> alertList_;
232
233protected:
234
235 static std::ostringstream oStream_;
236 bool ignoreSampleRateChange_;
237
239 Stk( void );
240
242 virtual ~Stk( void );
243
245 virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
246
249
252
254 void handleError( StkError::Type type ) const;
255};
256
257
258/***************************************************/
284/***************************************************/
285
287{
288public:
289
291 StkFrames( unsigned int nFrames = 0, unsigned int nChannels = 0 );
292
294 StkFrames( const StkFloat& value, unsigned int nFrames, unsigned int nChannels );
295
298
299 // A copy constructor.
300 StkFrames( const StkFrames& f );
301
302 // Assignment operator that returns a reference to self.
303 StkFrames& operator= ( const StkFrames& f );
304
306
312 StkFloat& operator[] ( size_t n );
313
315
319 StkFloat operator[] ( size_t n ) const;
320
322
327 StkFrames operator+(const StkFrames &frames) const;
328
330
335 void operator+= ( StkFrames& f );
336
338
343 void operator*= ( StkFrames& f );
344
346
353 StkFloat& operator() ( size_t frame, unsigned int channel );
354
356
361 StkFloat operator() ( size_t frame, unsigned int channel ) const;
362
364
370 StkFloat interpolate( StkFloat frame, unsigned int channel = 0 ) const;
371
373 size_t size() const { return size_; };
374
376 bool empty() const;
377
379
386 void resize( size_t nFrames, unsigned int nChannels = 1 );
387
389
396 void resize( size_t nFrames, unsigned int nChannels, StkFloat value );
397
399
404 StkFrames& getChannel(unsigned int channel,StkFrames& destinationFrames, unsigned int destinationChannel) const;
405
407
412 void setChannel(unsigned int channel,const StkFrames &sourceFrames,unsigned int sourceChannel);
413
415 unsigned int channels( void ) const { return nChannels_; };
416
418 unsigned int frames( void ) const { return (unsigned int)nFrames_; };
419
421
425 void setDataRate( StkFloat rate ) { dataRate_ = rate; };
426
428
432 StkFloat dataRate( void ) const { return dataRate_; };
433
434private:
435 StkFloat EMPTY_RESULT = 0.0f; // returned result if data_ is null
436
437 StkFloat *data_;
438 StkFloat dataRate_;
439 size_t nFrames_;
440 unsigned int nChannels_;
441 size_t size_;
442 size_t bufferSize_;
443
444};
445
446inline bool StkFrames :: empty() const
447{
448 if ( size_ > 0 ) return false;
449 else return true;
450}
451
452inline StkFloat& StkFrames :: operator[] ( size_t n )
453{
454#if defined(_STK_DEBUG_)
455 if ( n >= size_ ) {
456 std::ostringstream error;
457 error << "StkFrames::operator[]: invalid index (" << n << ") value!";
458 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
459 }
460#endif
461
462 return data_==nullptr ? EMPTY_RESULT : data_[n];
463}
464
465inline StkFloat StkFrames :: operator[] ( size_t n ) const
466{
467#if defined(_STK_DEBUG_)
468 if ( n >= size_ ) {
469 std::ostringstream error;
470 error << "StkFrames::operator[]: invalid index (" << n << ") value!";
471 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
472 }
473#endif
474
475 return data_==nullptr ? EMPTY_RESULT : data_[n];
476}
477
478inline StkFloat& StkFrames :: operator() ( size_t frame, unsigned int channel )
479{
480#if defined(_STK_DEBUG_)
481 if ( frame >= nFrames_ || channel >= nChannels_ ) {
482 std::ostringstream error;
483 error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!";
484 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
485 }
486#endif
487
488 return data_==nullptr? EMPTY_RESULT : data_[ frame * nChannels_ + channel ];
489}
490
491inline StkFloat StkFrames :: operator() ( size_t frame, unsigned int channel ) const
492{
493#if defined(_STK_DEBUG_)
494 if ( frame >= nFrames_ || channel >= nChannels_ ) {
495 std::ostringstream error;
496 error << "StkFrames::operator(): invalid frame (" << frame << ") or channel (" << channel << ") value!";
497 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
498 }
499#endif
500
501 return data_==nullptr ? EMPTY_RESULT : data_[ frame * nChannels_ + channel ];
502}
503
505{
506#if defined(_STK_DEBUG_)
507 if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) {
508 std::ostringstream error;
509 error << "StkFrames::operator+: frames argument must be of equal dimensions!";
510 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
511 }
512#endif
513 StkFrames sum((unsigned int)nFrames_,nChannels_);
514 StkFloat *sumPtr = &sum[0];
515 const StkFloat *fptr = f.data_;
516 const StkFloat *dPtr = data_;
517 for (unsigned int i = 0; i < size_; i++) {
518 *sumPtr++ = *fptr++ + *dPtr++;
519 }
520 return sum;
521}
522
523inline void StkFrames :: operator+= ( StkFrames& f )
524{
525#if defined(_STK_DEBUG_)
526 if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) {
527 std::ostringstream error;
528 error << "StkFrames::operator+=: frames argument must be of equal dimensions!";
529 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
530 }
531#endif
532
533 StkFloat *fptr = &f[0];
534 StkFloat *dptr = data_;
535 for ( unsigned int i=0; i<size_; i++ )
536 *dptr++ += *fptr++;
537}
538
539inline void StkFrames :: operator*= ( StkFrames& f )
540{
541#if defined(_STK_DEBUG_)
542 if ( f.frames() != nFrames_ || f.channels() != nChannels_ ) {
543 std::ostringstream error;
544 error << "StkFrames::operator*=: frames argument must be of equal dimensions!";
545 Stk::handleError( error.str(), StkError::MEMORY_ACCESS );
546 }
547#endif
548
549 StkFloat *fptr = &f[0];
550 StkFloat *dptr = data_;
551 for ( unsigned int i=0; i<size_; i++ )
552 *dptr++ *= *fptr++;
553}
554
555// Here are a few other useful typedefs.
556typedef unsigned short UINT16;
557typedef unsigned int UINT32;
558typedef signed short SINT16;
559typedef signed int SINT32;
560typedef float FLOAT32;
561typedef double FLOAT64;
562
563// The default sampling rate.
564const StkFloat SRATE = 44100.0;
565
566// The default real-time audio input and output buffer size. If
567// clicks are occuring in the input and/or output sound stream, a
568// larger buffer size may help. Larger buffer sizes, however, produce
569// more latency.
570const unsigned int RT_BUFFER_SIZE = 512;
571
572// The default rawwave path value is set with the preprocessor
573// definition RAWWAVE_PATH. This can be specified as an argument to
574// the configure script, in an integrated development environment, or
575// below. The global STK rawwave path variable can be dynamically set
576// with the Stk::setRawwavePath() function. This value is
577// concatenated to the beginning of all references to rawwave files in
578// the various STK core classes (e.g. Clarinet.cpp). If you wish to
579// move the rawwaves directory to a different location in your file
580// system, you will need to set this path definition appropriately.
581#if !defined(RAWWAVE_PATH)
582# define RAWWAVE_PATH "../../rawwaves/"
583#endif
584
585const StkFloat STK_PI = 3.14159265358979;
586const StkFloat STK_TWO_PI = 2 * STK_PI;
587
588const StkFloat ONE_OVER_128 = 0.0078125;
589
590#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_MM__)
591 #define __OS_WINDOWS__
592 #define __STK_REALTIME__
593#elif defined(__LINUX_OSS__) || defined(__LINUX_ALSA__) || defined(__UNIX_JACK__)
594 #define __OS_LINUX__
595 #define __STK_REALTIME__
596#elif defined(__IRIX_AL__)
597 #define __OS_IRIX__
598#elif defined(__MACOSX_CORE__) || defined(__UNIX_JACK__)
599 #define __OS_MACOSX__
600 #define __STK_REALTIME__
601#endif
602
603} // stk namespace
604
605#endif
virtual void printMessage(void)
Prints thrown error message to stderr.
Definition Stk.h:124
virtual const std::string & getMessage(void)
Returns the thrown error message string.
Definition Stk.h:137
virtual const char * getMessageCString(void)
Returns the thrown error message as a C string.
Definition Stk.h:140
virtual const Type & getType(void)
Returns the thrown error message type.
Definition Stk.h:134
virtual ~StkError(void)
The destructor.
Definition Stk.h:121
StkError(const std::string &message, Type type=StkError::UNSPECIFIED)
The constructor.
Definition Stk.h:117
unsigned int channels(void) const
Return the number of channels represented by the data.
Definition Stk.h:415
void operator*=(StkFrames &f)
Assignment by product operator into self.
Definition Stk.h:539
void operator+=(StkFrames &f)
Assignment by sum operator into self.
Definition Stk.h:523
unsigned int frames(void) const
Return the number of sample frames represented by the data.
Definition Stk.h:418
size_t size() const
Returns the total number of audio samples represented by the object.
Definition Stk.h:373
void resize(size_t nFrames, unsigned int nChannels=1)
Resize self to represent the specified number of channels and frames.
~StkFrames()
The destructor.
StkFloat interpolate(StkFloat frame, unsigned int channel=0) const
Return an interpolated value at the fractional frame index and channel.
StkFrames operator+(const StkFrames &frames) const
Sum operator.
Definition Stk.h:504
void resize(size_t nFrames, unsigned int nChannels, StkFloat value)
Resize self to represent the specified number of channels and frames and perform element initializati...
StkFloat dataRate(void) const
Return the sample rate associated with the StkFrames data.
Definition Stk.h:432
StkFrames & getChannel(unsigned int channel, StkFrames &destinationFrames, unsigned int destinationChannel) const
Retrieves a single channel.
bool empty() const
Returns true if the object size is zero and false otherwise.
Definition Stk.h:446
StkFloat & operator()(size_t frame, unsigned int channel)
Channel / frame subscript operator that returns a reference.
Definition Stk.h:478
StkFloat & operator[](size_t n)
Subscript operator that returns a reference to element n of self.
Definition Stk.h:452
StkFrames(unsigned int nFrames=0, unsigned int nChannels=0)
The default constructor initializes the frame data structure to size zero.
StkFrames(const StkFloat &value, unsigned int nFrames, unsigned int nChannels)
Overloaded constructor that initializes the frame data to the specified size with value.
void setChannel(unsigned int channel, const StkFrames &sourceFrames, unsigned int sourceChannel)
Sets a single channel.
void setDataRate(StkFloat rate)
Set the sample rate associated with the StkFrames data.
Definition Stk.h:425
static const StkFormat STK_FLOAT32
Definition Stk.h:152
static void showWarnings(bool status)
Toggle display of WARNING and STATUS messages.
Definition Stk.h:221
static void clear_alertList()
Static method that frees memory from alertList_.
Definition Stk.h:187
void removeSampleRateAlert(Stk *ptr)
Remove class pointer from list for sample rate change notification.
static void setSampleRate(StkFloat rate)
Static method that sets the STK sample rate.
static void handleError(const char *message, StkError::Type type)
Static function for error reporting and handling using c-strings.
static void setRawwavePath(std::string path)
Static method that sets the STK rawwave path.
static const StkFormat STK_FLOAT64
Definition Stk.h:153
static const StkFormat STK_SINT16
Definition Stk.h:149
void addSampleRateAlert(Stk *ptr)
Add class pointer to list for sample rate change notification.
static std::string rawwavePath(void)
Static method that returns the current rawwave path.
Definition Stk.h:190
static void swap64(unsigned char *ptr)
Static method that byte-swaps a 64-bit data type.
static StkFloat sampleRate(void)
Static method that returns the current STK sample rate.
Definition Stk.h:156
static const StkFormat STK_SINT32
Definition Stk.h:151
virtual void sampleRateChanged(StkFloat newRate, StkFloat oldRate)
This function should be implemented in subclasses that depend on the sample rate.
static bool inRange(StkFloat value, StkFloat min, StkFloat max)
Static method to check whether a value is within a specified range.
Definition Stk.h:208
static void swap32(unsigned char *ptr)
Static method that byte-swaps a 32-bit data type.
Stk(void)
Default constructor.
static void swap16(unsigned char *ptr)
Static method that byte-swaps a 16-bit data type.
void ignoreSampleRateChange(bool ignore=true)
A function to enable/disable the automatic updating of class data when the STK sample rate changes.
Definition Stk.h:184
static void handleError(std::string message, StkError::Type type)
Static function for error reporting and handling using c++ strings.
virtual ~Stk(void)
Class destructor.
static void sleep(unsigned long milliseconds)
Static cross-platform method to sleep for a number of milliseconds.
static const StkFormat STK_SINT8
Definition Stk.h:148
void handleError(StkError::Type type) const
Internal function for error reporting that assumes message in oStream_ variable.
static const StkFormat STK_SINT24
Definition Stk.h:150
static void printErrors(bool status)
Toggle display of error messages before throwing exceptions.
Definition Stk.h:224
The STK namespace.
Definition ADSR.h:8