beeps 0.1.10

data/src/stk/include/BlitSquare.h

@@ -0,0 +1,170 @@
+#ifndef STK_BLITSQUARE_H
+#define STK_BLITSQUARE_H
+
+#include "Generator.h"
+#include <cmath>
+#include <limits>
+
+namespace stk {
+
+/***************************************************/
+/*! \class BlitSquare
+    \brief STK band-limited square wave class.
+
+    This class generates a band-limited square wave signal.  It is
+    derived in part from the approach reported by Stilson and Smith in
+    "Alias-Free Digital Synthesis of Classic Analog Waveforms", 1996.
+    The algorithm implemented in this class uses a SincM function with
+    an even M value to achieve a bipolar bandlimited impulse train.
+    This signal is then integrated to achieve a square waveform.  The
+    integration process has an associated DC offset so a DC blocking
+    filter is applied at the output.
+
+    The user can specify both the fundamental frequency of the
+    waveform and the number of harmonics contained in the resulting
+    signal.
+
+    If nHarmonics is 0, then the signal will contain all harmonics up
+    to half the sample rate.  Note, however, that this setting may
+    produce aliasing in the signal when the frequency is changing (no
+    automatic modification of the number of harmonics is performed by
+    the setFrequency() function).  Also note that the harmonics of a
+    square wave fall at odd integer multiples of the fundamental, so
+    aliasing will happen with a lower fundamental than with the other
+    Blit waveforms.  This class is not guaranteed to be well behaved
+    in the presence of significant aliasing.
+
+    Based on initial code of Robin Davies, 2005.
+    Modified algorithm code by Gary Scavone, 2005 - 2006.
+*/
+/***************************************************/
+
+class BlitSquare: public Generator
+{
+ public:
+  //! Default constructor that initializes BLIT frequency to 220 Hz.
+  BlitSquare( StkFloat frequency = 220.0 );
+
+  //! Class destructor.
+  ~BlitSquare();
+
+  //! Resets the oscillator state and phase to 0.
+  void reset();
+
+  //! Set the phase of the signal.
+  /*!
+    Set the phase of the signal, in the range 0 to 1.
+  */
+  void setPhase( StkFloat phase ) { phase_ = PI * phase; };
+
+  //! Get the current phase of the signal.
+  /*!
+    Get the phase of the signal, in the range [0 to 1.0).
+  */
+  StkFloat getPhase() const { return phase_ / PI; };
+
+  //! Set the impulse train rate in terms of a frequency in Hz.
+  void setFrequency( StkFloat frequency );
+
+  //! Set the number of harmonics generated in the signal.
+  /*!
+    This function sets the number of harmonics contained in the
+    resulting signal.  It is equivalent to (2 * M) + 1 in the BLIT
+    algorithm.  The default value of 0 sets the algorithm for maximum
+    harmonic content (harmonics up to half the sample rate).  This
+    parameter is not checked against the current sample rate and
+    fundamental frequency.  Thus, aliasing can result if one or more
+    harmonics for a given fundamental frequency exceeds fs / 2.  This
+    behavior was chosen over the potentially more problematic solution
+    of automatically modifying the M parameter, which can produce
+    audible clicks in the signal.
+  */
+  void setHarmonics( unsigned int nHarmonics = 0 );
+
+  //! Return the last computed output value.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
+
+  //! Compute and return one output sample.
+  StkFloat tick( void );
+
+  //! Fill a channel of the StkFrames object with computed outputs.
+  /*!
+    The \c channel argument must be less than the number of
+    channels in the StkFrames argument (the first channel is specified
+    by 0).  However, range checking is only performed if _STK_DEBUG_
+    is defined during compilation, in which case an out-of-range value
+    will trigger an StkError exception.
+  */
+  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+
+ protected:
+
+  void updateHarmonics( void );
+
+  unsigned int nHarmonics_;
+  unsigned int m_;
+  StkFloat rate_;
+  StkFloat phase_;
+  StkFloat p_;
+  StkFloat a_;
+  StkFloat lastBlitOutput_;
+  StkFloat dcbState_;
+};
+
+inline StkFloat BlitSquare :: tick( void )
+{
+  StkFloat temp = lastBlitOutput_;
+
+  // A fully  optimized version of this would replace the two sin calls
+  // with a pair of fast sin oscillators, for which stable fast 
+  // two-multiply algorithms are well known. In the spirit of STK,
+  // which favors clarity over performance, the optimization has 
+  // not been made here.
+
+  // Avoid a divide by zero, or use of a denomralized divisor
+  // at the sinc peak, which has a limiting value of 1.0.
+  StkFloat denominator = sin( phase_ );
+  if ( fabs( denominator )  < std::numeric_limits<StkFloat>::epsilon() ) {
+    // Inexact comparison safely distinguishes betwen *close to zero*, and *close to PI*.
+    if ( phase_ < 0.1f || phase_ > TWO_PI - 0.1f )
+      lastBlitOutput_ = a_;
+    else
+      lastBlitOutput_ = -a_;
+  }
+  else {
+    lastBlitOutput_ =  sin( m_ * phase_ );
+    lastBlitOutput_ /= p_ * denominator;
+  }
+
+  lastBlitOutput_ += temp;
+
+  // Now apply DC blocker.
+  lastFrame_[0] = lastBlitOutput_ - dcbState_ + 0.999 * lastFrame_[0];
+  dcbState_ = lastBlitOutput_;
+
+  phase_ += rate_;
+  if ( phase_ >= TWO_PI ) phase_ -= TWO_PI;
+
+	return lastFrame_[0];
+}
+
+inline StkFrames& BlitSquare :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "BlitSquare::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int hop = frames.channels();
+  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+    *samples = BlitSquare::tick();
+
+  return frames;
+}
+
+} // stk namespace
+
+#endif

data/src/stk/include/FileRead.h

@@ -0,0 +1,141 @@
+#ifndef STK_FILEREAD_H
+#define STK_FILEREAD_H
+
+#include "Stk.h"
+
+namespace stk {
+
+/***************************************************/
+/*! \class FileRead
+    \brief STK audio file input class.
+
+    This class provides input support for various
+    audio file formats.  Multi-channel (>2)
+    soundfiles are supported.  The file data is
+    returned via an external StkFrames object
+    passed to the read() function.  This class
+    does not store its own copy of the file data,
+    rather the data is read directly from disk.
+
+    FileRead currently supports uncompressed WAV,
+    AIFF/AIFC, SND (AU), MAT-file (Matlab), and
+    STK RAW file formats.  Signed integer (8-,
+    16-, 24-, and 32-bit) and floating-point (32- and
+    64-bit) data types are supported.  Compressed
+    data types are not supported.
+
+    STK RAW files have no header and are assumed to
+    contain a monophonic stream of 16-bit signed
+    integers in big-endian byte order at a sample
+    rate of 22050 Hz.  MAT-file data should be saved
+    in an array with each data channel filling a
+    matrix row.  The sample rate for MAT-files should
+    be specified in a variable named "fs".  If no
+    such variable is found, the sample rate is
+    assumed to be 44100 Hz.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2014.
+*/
+/***************************************************/
+
+class FileRead : public Stk
+{
+public:
+  //! Default constructor.
+  FileRead( void );
+
+  //! Overloaded constructor that opens a file during instantiation.
+  /*!
+    An StkError will be thrown if the file is not found or its
+    format is unknown or unsupported.  The optional arguments allow a
+    headerless file type to be supported.  If \c typeRaw is false (the
+    default), the subsequent parameters are ignored.
+  */
+  FileRead( std::string fileName, bool typeRaw = false, unsigned int nChannels = 1,
+            StkFormat format = STK_SINT16, StkFloat rate = 22050.0 );
+
+  //! Class destructor.
+  ~FileRead( void );
+
+  //! Open the specified file and determine its formatting.
+  /*!
+    An StkError will be thrown if the file is not found or its
+    format is unknown or unsupported.  The optional arguments allow a
+    headerless file type to be supported.  If \c typeRaw is false (the
+    default), the subsequent parameters are ignored.
+  */
+  void open( std::string fileName, bool typeRaw = false, unsigned int nChannels = 1,
+             StkFormat format = STK_SINT16, StkFloat rate = 22050.0 );
+
+  //! If a file is open, close it.
+  void close( void );
+
+  //! Returns \e true if a file is currently open.
+  bool isOpen( void );
+
+  //! Return the file size in sample frames.
+  unsigned long fileSize( void ) const { return fileSize_; };
+
+  //! Return the number of audio channels in the file.
+  unsigned int channels( void ) const { return channels_; };
+
+  //! Return the data format of the file.
+  StkFormat format( void ) const { return dataType_; };
+
+  //! Return the file sample rate in Hz.
+  /*!
+    WAV, SND, and AIF formatted files specify a sample rate in
+    their headers.  By definition, STK RAW files have a sample rate of
+    22050 Hz.  MAT-files are assumed to have a rate of 44100 Hz.
+  */
+  StkFloat fileRate( void ) const { return fileRate_; };
+
+  //! Read sample frames from the file into an StkFrames object.
+  /*!
+    The number of sample frames to read will be determined from the
+    number of frames of the StkFrames argument.  If this size is
+    larger than the available data in the file (given the file size
+    and starting frame index), the extra frames will be unaffected
+    (the StkFrames object will not be resized).  Optional parameters
+    are provided to specify the starting sample frame within the file
+    (default = 0) and whether to normalize the data with respect to
+    fixed-point limits (default = true).  An StkError will be thrown
+    if a file error occurs or if the number of channels in the
+    StkFrames argument is not equal to that in the file.
+   */
+  void read( StkFrames& buffer, unsigned long startFrame = 0, bool doNormalize = true );
+
+protected:
+
+  // Get STK RAW file information.
+  bool getRawInfo( const char *fileName, unsigned int nChannels,
+                   StkFormat format, StkFloat rate );
+
+  // Get WAV file header information.
+  bool getWavInfo( const char *fileName );
+
+  // Get SND (AU) file header information.
+  bool getSndInfo( const char *fileName );
+
+  // Get AIFF file header information.
+  bool getAifInfo( const char *fileName );
+
+  // Get MAT-file header information.
+  bool getMatInfo( const char *fileName );
+
+  // Helper function for MAT-file parsing.
+  bool findNextMatArray( SINT32 *chunkSize, SINT32 *rows, SINT32 *columns, SINT32 *nametype );
+
+  FILE *fd_;
+  bool byteswap_;
+  bool wavFile_;
+  unsigned long fileSize_;
+  unsigned long dataOffset_;
+  unsigned int channels_;
+  StkFormat dataType_;
+  StkFloat fileRate_;
+};
+
+} // stk namespace
+
+#endif

data/src/stk/include/FileWvIn.h

@@ -0,0 +1,195 @@
+#ifndef STK_FILEWVIN_H
+#define STK_FILEWVIN_H
+
+#include "WvIn.h"
+#include "FileRead.h"
+
+namespace stk {
+
+/***************************************************/
+/*! \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.
+*/
+/***************************************************/
+
+class FileWvIn : public WvIn
+{
+public:
+  //! Default constructor.
+  FileWvIn( unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024 );
+
+  //! Overloaded constructor for file input.
+  /*!
+    An StkError will be thrown if the file is not found, its format is
+    unknown, or a read error occurs.
+  */
+  FileWvIn( std::string fileName, bool raw = false, bool doNormalize = true,
+            unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024 );
+
+  //! Class destructor.
+  ~FileWvIn( void );
+
+  //! Open the specified file and load its data.
+  /*!
+    Data from a previously opened file will be overwritten by this
+    function.  An StkError will be thrown if the file is not found,
+    its format is unknown, or a read error occurs.  If the file data
+    is to be loaded incrementally from disk and normalization is
+    specified, a scaling will be applied with respect to fixed-point
+    limits.  If the data format is floating-point, no scaling is
+    performed.
+  */
+  virtual void openFile( std::string fileName, bool raw = false, bool doNormalize = true );
+
+  //! Close a file if one is open.
+  virtual void closeFile( void );
+
+  //! Clear outputs and reset time (file) pointer to zero.
+  virtual void reset( void );
+
+  //! Normalize data to a maximum of +-1.0.
+  /*!
+    This function has no effect when data is incrementally loaded
+    from disk.
+  */
+  virtual void normalize( void );
+
+  //! Normalize data to a maximum of \e +-peak.
+  /*!
+    This function has no effect when data is incrementally loaded
+    from disk.
+  */
+  virtual void normalize( StkFloat peak );
+
+  //! Return the file size in sample frames.
+  virtual unsigned long getSize( void ) const { return file_.fileSize(); };
+
+  //! Return the input file sample rate in Hz (not the data read rate).
+  /*!
+    WAV, SND, and AIF formatted files specify a sample rate in
+    their headers.  STK RAW files have a sample rate of 22050 Hz
+    by definition.  MAT-files are assumed to have a rate of 44100 Hz.
+  */
+  virtual StkFloat getFileRate( void ) const { return data_.dataRate(); };
+
+  //! Query whether a file is open.
+  bool isOpen( void ) { return file_.isOpen(); };
+
+  //! Query whether reading is complete.
+  bool isFinished( void ) const { return finished_; };
+
+  //! Set the data read rate in samples.  The rate can be negative.
+  /*!
+    If the rate value is negative, the data is read in reverse order.
+  */
+  virtual void setRate( StkFloat rate );
+
+  //! Increment the read pointer by \e time samples.
+  /*!
+    Note that this function will not modify the interpolation flag status.
+   */
+  virtual void addTime( StkFloat time );
+
+  //! Turn linear interpolation on/off.
+  /*!
+    Interpolation is automatically off when the read rate is
+    an integer value.  If interpolation is turned off for a
+    fractional rate, the time index is truncated to an integer
+    value.
+  */
+  void setInterpolate( bool doInterpolate ) { interpolate_ = doInterpolate; };
+
+  //! Return the specified channel value of the last computed frame.
+  /*!
+    If no file is loaded, the returned value is 0.0.  The \c
+    channel argument must be less than the number of output channels,
+    which can be determined with the channelsOut() function (the first
+    channel is specified by 0).  However, range checking is only
+    performed if _STK_DEBUG_ is defined during compilation, in which
+    case an out-of-range value will trigger an StkError exception. \sa
+    lastFrame()
+  */
+  StkFloat lastOut( unsigned int channel = 0 );
+
+  //! Compute a sample frame and return the specified \c channel value.
+  /*!
+    For multi-channel files, use the lastFrame() function to get
+    all values from the computed frame.  If no file data is loaded,
+    the returned value is 0.0.  The \c channel argument must be less
+    than the number of channels in the file data (the first channel is
+    specified by 0).  However, range checking is only performed if
+    _STK_DEBUG_ is defined during compilation, in which case an
+    out-of-range value will trigger an StkError exception.
+  */
+  virtual StkFloat tick( unsigned int channel = 0 );
+
+  //! Fill the StkFrames object with computed sample frames, starting at the specified channel and return the same reference.
+  /*!
+    The \c channel argument plus the number of input channels must
+    be less than the number of channels in the StkFrames argument (the
+    first channel is specified by 0).  However, range checking is only
+    performed if _STK_DEBUG_ is defined during compilation, in which
+    case an out-of-range value will trigger an StkError exception.
+  */
+  virtual StkFrames& tick( StkFrames& frames,unsigned int channel = 0 );
+
+protected:
+
+  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
+
+  FileRead file_;
+  bool finished_;
+  bool interpolate_;
+  bool normalizing_;
+  bool chunking_;
+  StkFloat time_;
+  StkFloat rate_;
+  unsigned long chunkThreshold_;
+  unsigned long chunkSize_;
+  long chunkPointer_;
+
+};
+
+inline StkFloat FileWvIn :: lastOut( unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= data_.channels() ) {
+    oStream_ << "FileWvIn::lastOut(): channel argument and soundfile data are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  if ( finished_ ) return 0.0;
+  return lastFrame_[channel];
+}
+
+} // stk namespace
+
+#endif