Update README-iOS.md

fix markdown syntax

.gitignore

@@ -0,0 +1,188 @@
+#####
+# OS X temporary files that should never be committed
+#
+# c.f. http://www.westwind.com/reference/os-x/invisibles.html
+
+.DS_Store
+
+# c.f. http://www.westwind.com/reference/os-x/invisibles.html
+
+.Trashes
+
+# c.f. http://www.westwind.com/reference/os-x/invisibles.html
+
+*.swp
+
+# *.lock - this is used and abused by many editors for many different things.
+#    For the main ones I use (e.g. Eclipse), it should be excluded 
+#    from source-control, but YMMV
+
+*.lock
+
+#
+# profile - REMOVED temporarily (on double-checking, this seems incorrect; I can't find it in OS X docs?)
+#profile
+
+
+####
+# Xcode temporary files that should never be committed
+# 
+# NB: NIB/XIB files still exist even on Storyboard projects, so we want this...
+
+*~.nib
+
+
+####
+# Xcode build files -
+#
+# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "DerivedData"
+
+DerivedData/
+
+# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "build"
+
+build/
+
+
+#####
+# Xcode private settings (window sizes, bookmarks, breakpoints, custom executables, smart groups)
+#
+# This is complicated:
+#
+# SOMETIMES you need to put this file in version control.
+# Apple designed it poorly - if you use "custom executables", they are
+#  saved in this file.
+# 99% of projects do NOT use those, so they do NOT want to version control this file.
+#  ..but if you're in the 1%, comment out the line "*.pbxuser"
+
+# .pbxuser: http://lists.apple.com/archives/xcode-users/2004/Jan/msg00193.html
+
+*.pbxuser
+
+# .mode1v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
+
+*.mode1v3
+
+# .mode2v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
+
+*.mode2v3
+
+# .perspectivev3: http://stackoverflow.com/questions/5223297/xcode-projects-what-is-a-perspectivev3-file
+
+*.perspectivev3
+
+#    NB: also, whitelist the default ones, some projects need to use these
+!default.pbxuser
+!default.mode1v3
+!default.mode2v3
+!default.perspectivev3
+
+
+####
+# Xcode 4 - semi-personal settings
+#
+#
+# OPTION 1: ---------------------------------
+#     throw away ALL personal settings (including custom schemes!
+#     - unless they are "shared")
+#
+# NB: this is exclusive with OPTION 2 below
+xcuserdata
+
+# OPTION 2: ---------------------------------
+#     get rid of ALL personal settings, but KEEP SOME OF THEM
+#     - NB: you must manually uncomment the bits you want to keep
+#
+# NB: this *requires* git v1.8.2 or above; you may need to upgrade to latest OS X,
+#    or manually install git over the top of the OS X version
+# NB: this is exclusive with OPTION 1 above
+#
+#xcuserdata/**/*
+
+#     (requires option 2 above): Personal Schemes
+#
+#!xcuserdata/**/xcschemes/*
+
+####
+# XCode 4 workspaces - more detailed
+#
+# Workspaces are important! They are a core feature of Xcode - don't exclude them :)
+#
+# Workspace layout is quite spammy. For reference:
+#
+# /(root)/
+#   /(project-name).xcodeproj/
+#     project.pbxproj
+#     /project.xcworkspace/
+#       contents.xcworkspacedata
+#       /xcuserdata/
+#         /(your name)/xcuserdatad/
+#           UserInterfaceState.xcuserstate
+#     /xcsshareddata/
+#       /xcschemes/
+#         (shared scheme name).xcscheme
+#     /xcuserdata/
+#       /(your name)/xcuserdatad/
+#         (private scheme).xcscheme
+#         xcschememanagement.plist
+#
+#
+
+####
+# Xcode 4 - Deprecated classes
+#
+# Allegedly, if you manually "deprecate" your classes, they get moved here.
+#
+# We're using source-control, so this is a "feature" that we do not want!
+
+*.moved-aside
+
+####
+# Files generated by automake
+
+Makefile
+autom4te.cache
+config.log
+config.status
+configure
+projects/demo/Makefile
+projects/demo/stk-demo
+projects/demo/Release
+projects/demo/Debug
+projects/effects/Makefile
+projects/effects/effects
+projects/effects/Release
+projects/effects/Debug
+projects/eguitar/Makefile
+projects/eguitar/eguitar
+projects/eguitar/Release
+projects/eguitar/Debug
+projects/examples/Makefile
+projects/examples/audioprobe
+projects/examples/bethree
+projects/examples/controlbee
+projects/examples/crtsine
+projects/examples/duplex
+projects/examples/foursine
+projects/examples/grains
+projects/examples/inetIn
+projects/examples/inetOut
+projects/examples/libMakefile
+projects/examples/midiprobe
+projects/examples/play
+projects/examples/playsmf
+projects/examples/record
+projects/examples/rtsine
+projects/examples/sine
+projects/examples/sineosc
+projects/examples/threebees
+projects/examples/Release
+projects/examples/Debug
+projects/ragamatic/Makefile
+projects/ragamatic/ragamat
+projects/ragamatic/Release
+projects/ragamatic/Debug
+src/libstk.a
+src/Release
+src/Debug
+src/Makefile

INSTALL

@@ -1,41 +0,0 @@
-The Synthesis ToolKit in C++ (STK)
-
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
-
-The Synthesis ToolKit in C++ can be used in a variety of ways, depending on your particular needs.  Some people just choose the classes they need for a particular project and copy those to their project directory.  Others like to compile and link to a library of object files.  STK was not designed with one particular style of use in mind.
-
-To configure and compile (on Unix systems):
-
-1. Unpack the STK distribution (tar -xzf stk-4.x.x.tar.gz).
-2. From within the directory containing this file, run configure:
-
-   ./configure
-
-3. From within each project directory, type "make".
-4. To compile a library of objects, type "make" from within the src directory.
-
-Several options can be passed to configure, including:
-
-  --disable-realtime = only compile generic non-realtime classes
-  --enable-debug = enable various debug output
-  --with-alsa = choose native ALSA API support (default, linux only)
-  --with-jack = choose native JACK server API support (linux only)
-  --with-oss = choose native OSS API support (linux only)
-
-It is now possible to specify more than one Linux audio API.  Note however that the ALSA library is required in order to compile the RtMidi class, even if the "--with-oss" option is provided (only the OSS audio API will be used, not the OSS MIDI API).  Typing "./configure --help" will display all the available options.  In addition, it is possible to specify the RAWWAVES and INCLUDE paths to configure as (ex. to set to /home/gary/rawwaves and /home/gary/include):
-
-  ./configure RAWWAVE_PATH='$(HOME)/rawwaves/'
-  ./configure INCLUDE_PATH='$(HOME)/include/'
-
-The ending "/" is required for the RAWWAVES path.  The default behavior will set a relative path that works for the project files included with the distribution (assuming they are not moved).  You can also change the RAWWAVE_PATH dynamically via the static Stk::setRawwavePath() function.
-
-If you wish to use a different compiler than that selected by configure, specify that compiler in the command line (ex. to use CC):
-
-  ./configure CXX=CC
-
-In addition, a linux RPM is available from the Planet CCRMA WWW site (http://ccrma.stanford.edu/planetccrma/software/).
-
-
-For Windows Users:
-
-An STK distribution is available which contains precompiled executables.  In addition, Visual C++ project files are included for each of the example STK projects.

INSTALL.md

@@ -0,0 +1,58 @@
+% The Synthesis ToolKit in C++ (STK)
+% Perry R. Cook and Gary P. Scavone
+% 1995--2016
+
+# The Synthesis ToolKit in C++ (STK)
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
+
+The Synthesis ToolKit in C++ can be used in a variety of ways, depending on your particular needs.  Some people simply choose the classes they need for a particular project and copy those to their project directory.  Others like to compile and link to a library of object files.  STK was not designed with one particular style of use in mind.
+
+## Unix systems and MinGW
+
+1. If you downloaded the software from the git repository, first run autoconf,
+
+        autoconf
+
+otherwise, if you downloaded the software from the STK source distribution, unpack the tar file,
+
+        tar -xzf stk-4.x.x.tar.gz
+
+2. From within the directory containing this file, run configure:
+
+        ./configure
+
+3. From within each project directory, type `make`.
+
+4. To compile a library of objects, type `make` from within the `src` directory.
+
+Several options can be passed to configure, including:
+
+    --disable-realtime = only compile generic non-realtime classes
+    --enable-debug = enable various debug output
+    --with-alsa = choose native ALSA API support (default, linux only)
+    --with-oss = choose native OSS API support (linux only)
+    --with-jack = choose native JACK server API support (linux and macintosh OS-X)
+    --with-core = choose OS-X Core Audio API (macintosh OS-X only)
+    --with-asio = choose ASIO API support (windows only)
+    --with-ds = choose DirectSound API support (windows only)
+    --with-wasapi = choose Windows Audio Session API support (windows only)
+
+It is now possible to specify more than one audio and MIDI API where supported.  Note, however, that the ALSA library is required in order to compile the RtMidi class in Linux if the `--with-oss` option is provided (only the OSS audio API will be used, not the OSS MIDI API).  Typing `./configure --help` will display all the available options.  In addition, it is possible to specify the RAWWAVES and INCLUDE paths to configure as (ex. to set to /home/me/rawwaves and /home/me/include):
+
+    ./configure RAWWAVE_PATH='$(HOME)/rawwaves/'
+    ./configure INCLUDE_PATH='$(HOME)/include/'
+
+The ending "/" is required for the RAWWAVES path.  The default behavior will set a relative path that works for the project files included with the distribution (assuming they are not moved).  You can also change the RAWWAVE_PATH dynamically via the static Stk::setRawwavePath() function.
+
+If you wish to use a different compiler than that selected by configure, specify that compiler in the command line (ex. to use CC):
+
+    ./configure CXX=CC
+
+
+## Windows
+
+MinGW support is provided in the configure script.  In addition, Visual C++ 6.0 project files are included for each of the example STK projects, though these may not work with more recent versions of Visual Studio.
+
+##iOS
+
+You can integrate the STK in iOS projects either by using its iOS static library or Cocoapods. See the [iOS README file](iOS/README-iOS.md) for instructions. 

LICENSE

@@ -0,0 +1,27 @@
+The Synthesis ToolKit in C++ (STK)
+
+Copyright (c) 1995--2016 Perry R. Cook and Gary P. Scavone
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+Any person wishing to distribute modifications to the Software is
+asked to send the modifications to the original developer so that they
+can be incorporated into the canonical version.  This is, however, not
+a binding provision of this license.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile.in

@@ -0,0 +1,41 @@
+### Do not edit -- Generated by 'configure --with-whatever' from Makefile.in
+
+RM = /bin/rm
+
+REALTIME = @realtime@
+
+all :
+	cd src && $(MAKE)
+	cd projects/demo && $(MAKE) libdemo
+ifeq ($(REALTIME),yes)
+	cd projects/effects && $(MAKE) libeffects
+	cd projects/ragamatic && $(MAKE) libragamat
+	cd projects/eguitar && $(MAKE) libeguitar
+endif
+	cd projects/examples && $(MAKE) -f libMakefile
+
+clean : 
+	$(RM) -f *~
+	cd src && $(MAKE) clean
+	cd projects/demo && $(MAKE) clean
+ifeq ($(REALTIME),yes)
+	cd projects/effects && $(MAKE) clean
+	cd projects/ragamatic && $(MAKE) clean
+	cd projects/eguitar && $(MAKE) clean
+endif
+	cd projects/examples && $(MAKE) clean
+
+distclean: clean
+	$(RM) -rf config.log config.status autom4te.cache Makefile
+	cd src && $(MAKE) distclean
+	cd projects/demo && $(MAKE) distclean
+ifeq ($(REALTIME),yes)
+	cd projects/effects && $(MAKE) distclean
+	cd projects/ragamatic && $(MAKE) distclean
+	cd projects/eguitar && $(MAKE) distclean
+endif
+	cd projects/examples && $(MAKE) distclean
+
+install:
+	$(MAKE) -C src install
+

README

@@ -1,96 +0,0 @@
-The Synthesis ToolKit in C++ (STK)
-
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
-
-This distribution of the Synthesis ToolKit in C++ (STK) contains the following:
-
-include:  STK class header files
-src:      STK class source files
-rawwaves: STK audio files (1-channel, 16-bit, big-endian)
-doc:      STK documentation
-projects: example STK projects and programs
-
-Please read the Legal and Ethical notes near the bottom of this document.
-
-For compiling and installing STK, see the INSTALL file in this directory.
-
-
-OVERVIEW:
-
-The Synthesis ToolKit in C++ (STK) is a set of open source audio signal processing and algorithmic synthesis classes written in the C++ programming language.  STK was designed to facilitate rapid development of music synthesis and audio processing software, with an emphasis on cross-platform functionality, realtime control, ease of use, and educational example code.  The Synthesis ToolKit is extremely portable (it's mostly platform-independent C and C++ code), and it's completely user-extensible (all source included, no unusual libraries, and no hidden drivers).  We like to think that this increases the chances that our programs will still work in another 5-10 years.  In fact, the ToolKit has been working continuously for nearly 10 years now.  STK currently runs with "realtime" support (audio and MIDI) on SGI (Irix), Linux, Macintosh OS X, and Windows computer platforms.  Generic, non-realtime support has been tested under NeXTStep, Sun, and other platforms and should work with any standard C++ compiler.
-
-The Synthesis ToolKit is free for non-commercial use.  The only parts of the Synthesis ToolKit that are platform-dependent concern real-time audio and MIDI input and output, and that is taken care of with a few special classes.  The interface for MIDI input and the simple Tcl/Tk graphical user interfaces (GUIs) provided is the same, so it's easy to experiment in real time using either the GUIs or MIDI.  The Synthesis ToolKit can generate simultaneous SND (AU), WAV, AIFF, and MAT-file output soundfile formats (as well as realtime sound output), so you can view your results using one of a large variety of sound/signal analysis tools already available (e.g. Snd, Cool Edit, Matlab). 
-
-The Synthesis Toolkit is not one particular program.  Rather, it is a set of C++ classes that you can use to create your own programs.  A few example applications are provided to demonstrate some of the ways to use the classes.  If you have specific needs, you will probably have to either modify the example programs or write a new program altogether. Further, the example programs don't have a fancy GUI wrapper. If you feel the need to have a "drag and drop" graphical patching GUI, you probably don't want to use the ToolKit. Spending hundreds of hours making platform-dependent graphics code would go against one of the fundamental design goals of the ToolKit - platform independence. 
-
-For those instances where a simple GUI with sliders and buttons is helpful, we use Tcl/Tk (http://dev.scriptics.com) which is freely distributed for all the supported ToolKit platforms. A number of Tcl/Tk GUI scripts are distributed with the ToolKit release.  For control, the Synthesis Toolkit uses raw MIDI (on supported platforms), and SKINI (Synthesis ToolKit Instrument Network Interface, a MIDI-like text message synthesis control format).
-
-
-SYSTEM REQUIREMENTS:
-
-See the individual README's (eg. README-linux) in the /doc directory for platform specific information and system requirements.  In general, you will use the configure script to create Makefiles on unix platforms or the VC++ workspace files to compile the example programs.  To use the Tcl/Tk GUIs, you will need Tcl/Tk version 8.0 or higher.
-
-
-WHAT'S NEW (AND NOT SO NEW):
-
-Despite being available in one form or another since 1996, we still consider STK to be alpha software.  We attempt to maintain backward compatability but changes are sometimes made in an effort to improve the overall design or performance of the software.  Please read the Release Notes to see what has changed since the last release.
-
-A new StkFrames class has been created to facilitate the handling and passing of multichannel, vectorized audio data.  All STK classes have been updated to include tick() functions that accept StkFrames arguments.
-
-The control message handling scheme has been simplified greatly through the use of the Messager class.  It is now possible to have access to simultaneous piped, socketed, and/or MIDI input control messages.  In most cases, this should eliminate the use of the Md2Skini program.
-
-Realtime audio input capabilities were added to STK with release 3.0, though the behavior of such is very hardware dependent.  Under Linux, Macintosh OS-X, and Irix, audio input and output are possible with very low latency.  Using the Windoze DirectSound API, minimum dependable output sound latency seems to be around 20 milliseconds or so, while input sound latency is on the order of a hundred milliseconds or more!
-
-As mentioned above, it is possible to record the audio ouput of an STK program to .snd, .wav, .raw, .aif, and .mat (Matlab MAT-file) output file types.  Though somewhat obsolete, the program Md2Skini can be used to write SKINI scorefiles from realtime MIDI input.  Finally, STK should compile with non-realtime functionality on any platform with a generic C++ compiler.
-
-For those who wish to make a library from the core STK classes, the configure script generates a Makefile in the src directory that will accomplish that (Linux, SGI, and Macintosh OS X only).
-
-
-DISCLAIMER:
-
-You probably already guessed this, but just to be sure, we don't guarantee anything works.  :-)  It's free ... what do you expect?  If you find a bug, please let us know and we'll try to correct it.  You can also make suggestions, but again, no guarantees.  Send email to the mail list.
-
-
-LEGAL AND ETHICAL:
-
-This software was designed and created to be made publicly available for free, primarily for academic purposes, so if you use it, pass it on with this documentation, and for free.  
-
-If you make a million dollars with it, give us some.  If you make compositions with it, put us in the program notes.
-
-Some of the concepts are covered by various patents, some known to us and likely others which are unknown.  Many of the ones known to us are administered by the Stanford Office of Technology and Licensing.  
-
-The good news is that large hunks of the techniques used here are public domain.  To avoid subtle legal issues, we'll not state what's freely useable here, but we'll try to note within the various classes where certain things are likely to be protected by patents.
-
-
-FURTHER READING:
-
-For complete documentation on this ToolKit, the classes, etc., see the doc directory of the distribution or surf to http://ccrma.stanford.edu/software/stk/.  Also check the platform specific README's for specific system requirements.
-
-
-PERRY'S NOTES FROM THE ORIGINAL DISTRIBUTION:
-
-This whole world was created with no particular hardware in mind.  These examples are intended to be tutorial in nature, as a platform for the continuation of my research, and as a possible starting point for a software synthesis system.  The basic motivation was to create the necessary unit generators to do the synthesis, processing, and control that I want to do and teach about.  Little thought for optimization was given and therefore improvements, especially speed enhancements, should be possible with these classes.  It was written with some basic concepts in mind about how to let compilers optimize.
-
-Your question at this point might be, "But Perry, with CMix, CMusic, CSound, CShells, CMonkeys, etc. already cluttering the landscape, why a new set of stupid C functions for music synthesis and processing?"  The answers lie below.
-
-1) I needed to port many of the things I've done into something which is generic enough to port further to different machines.
-
-2) I really plan to document this stuff, so that you don't have to be me to figure out what's going on. (I'll probably be sorry I said this in a couple of years, when even I can't figure out what I was thinking.)
-
-3) The classic difficulties most people have in trying to implement physical models are:
-
-   A) They have trouble understanding the papers, and/or in turning the theory into practice.
-
-   B) The Physical Model instruments are a pain to get to oscillate, and coming up with stable and meaningful parameter values is required to get the models to work at all.
-
-   This set of C++ unit generators and instruments might help to diminish the scores of emails I get asking what to do with those block diagrams I put in my papers.
-
-4) I wanted to try some new stuff with modal synthesis, and implement some classic FM patches as well.
-
-5) I wanted to reimplement, and newly implement more of the intelligent and physical performer models I've talked about in some of my papers. But I wanted to do it in a portable way, and in such a way that I can hook up modules quickly.  I also wanted to make these instruments connectable to such player objects, so folks like Brad Garton who really think a lot about the players can connect them to my instruments, a lot about which I think.
-
-6) More rationalizations to follow . . .
-
-
-
-

README.md

@@ -0,0 +1,194 @@
+# The Synthesis ToolKit in C++ (STK)
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
+
+This distribution of the Synthesis ToolKit in C++ (STK) contains the following:
+
+* [`include`](include/):  STK class header files
+* [`src`](src/): STK class source files
+* [`rawwaves`](rawwaves): STK audio files (1-channel, 16-bit, big-endian)
+* [`doc`](doc): STK documentation
+* [`projects`](projects): example STK projects and programs
+
+Please read the [Legal and Ethical notes](#legal-and-ethical) near the bottom of this document and the [License](LICENSE).
+
+For compiling and installing STK, see the [INSTALL.md](INSTALL.md) file in this directory.
+
+##Contents
+
+* [Overview](#overview)
+* [System Requirements](#system-requirements)
+* [What's New (and not so new)](#whats-new-and-not-so-new)
+* [Disclaimer](#disclaimer)
+* [Legal and Ethical](#legal-and-ethical)
+* [Further Reading](#further-reading)
+* [Perry's Notes From the Original Distribution](#perrys-notes-from-the-original-distribution)
+
+# OVERVIEW
+
+The Synthesis ToolKit in C++ (STK) is a set of open source audio
+signal processing and algorithmic synthesis classes written in the C++
+programming language.  STK was designed to facilitate rapid
+development of music synthesis and audio processing software, with an
+emphasis on cross-platform functionality, realtime control, ease of
+use, and educational example code.  The Synthesis ToolKit is extremely
+portable (most classes are platform-independent C++ code), and it's
+completely user-extensible (all source included, no unusual libraries,
+and no hidden drivers).  We like to think that this increases the
+chances that our programs will still work in another 5-10 years.  STK
+currently runs with "realtime" support (audio and MIDI) on Linux,
+Macintosh OS X, and Windows computer platforms.  Generic, non-realtime
+support has been tested under NeXTStep, Sun, and other platforms and
+should work with any standard C++ compiler.
+
+The only classes of the Synthesis ToolKit that are platform-dependent
+concern sockets, threads, mutexes, and real-time audio and MIDI input
+and output.  The interface for MIDI input and the simple Tcl/Tk
+graphical user interfaces (GUIs) provided is the same, so it's easy to
+experiment in real time using either the GUIs or MIDI.  The Synthesis
+ToolKit can generate simultaneous SND (AU), WAV, AIFF, and MAT-file
+output soundfile formats (as well as realtime sound output), so you
+can view your results using one of a large variety of sound/signal
+analysis tools already available (e.g. Snd, Cool Edit, Matlab).
+
+The Synthesis Toolkit is not one particular program.  Rather, it is a
+set of C++ classes that you can use to create your own programs.  A
+few example applications are provided to demonstrate some of the ways
+to use the classes.  If you have specific needs, you will probably
+have to either modify the example programs or write a new program
+altogether. Further, the example programs don't have a fancy GUI
+wrapper. If you feel the need to have a "drag and drop" graphical
+patching GUI, you probably don't want to use the ToolKit. Spending
+hundreds of hours making platform-dependent graphics code would go
+against one of the fundamental design goals of the ToolKit - platform
+independence.
+
+For those instances where a simple GUI with sliders and buttons is
+helpful, we use Tcl/Tk (http://dev.scriptics.com) which is freely
+distributed for all the supported ToolKit platforms. A number of
+Tcl/Tk GUI scripts are distributed with the ToolKit release.  For
+control, the Synthesis Toolkit uses raw MIDI (on supported platforms),
+and SKINI (Synthesis ToolKit Instrument Network Interface, a MIDI-like
+text message synthesis control format).
+
+
+# SYSTEM REQUIREMENTS
+
+See the individual README's (eg. README-linux) in the /doc directory
+for platform specific information and system requirements.  In
+general, you will use the configure script to create Makefiles on unix
+platforms (and MinGW) or the VC++ workspace files to compile the
+example programs.  To use the Tcl/Tk GUIs, you will need Tcl/Tk
+version 8.0 or higher.
+
+
+# WHAT'S NEW (AND NOT SO NEW)
+
+Despite being available in one form or another since 1996, we still
+consider STK to be alpha software.  We attempt to maintain backward
+compatability but changes are sometimes made in an effort to improve
+the overall design or performance of the software.  Please read the
+"Release Notes" in the /doc directory to see what has changed since
+the last release.
+
+A new StkFrames class has been created to facilitate the handling and
+passing of multichannel, vectorized audio data.  All STK classes have
+been updated to include tick() functions that accept StkFrames
+arguments.
+
+The control message handling scheme has been simplified greatly
+through the use of the Messager class.  It is now possible to have
+access to simultaneous piped, socketed, and/or MIDI input control
+messages.  In most cases, this should eliminate the use of the
+Md2Skini program.
+
+Realtime audio input capabilities were added to STK with release 3.0,
+though the behavior of such is very hardware dependent.  Under Linux
+and Macintosh OS-X, audio input and output are possible with very low
+latency.  Using the Windoze DirectSound API, minimum dependable output
+sound latency seems to be around 20 milliseconds or so, while input
+sound latency is generally higher.  Performance with the ASIO audio
+API on Windoze provides much better performance.
+
+As mentioned above, it is possible to record the audio ouput of an STK
+program to .snd, .wav, .raw, .aif, and .mat (Matlab MAT-file) output
+file types.  Though somewhat obsolete, the program Md2Skini can be
+used to write SKINI scorefiles from realtime MIDI input.  Finally, STK
+should compile with non-realtime functionality on any platform with a
+generic C++ compiler.
+
+For those who wish to make a library from the core STK classes, the
+configure script generates a Makefile in the src directory that will
+accomplish that.
+
+
+# DISCLAIMER
+
+You probably already guessed this, but just to be sure, we don't
+guarantee anything works.  :-) It's free ... what do you expect?  If
+you find a bug, please let us know and we'll try to correct it.  You
+can also make suggestions, but again, no guarantees.  Send email to
+the mail list.
+
+
+# LEGAL AND ETHICAL
+
+This software was designed and created to be made publicly available
+for free, primarily for academic purposes, so if you use it, pass it
+on with this documentation, and for free.
+
+If you make a million dollars with it, it would be nice if you would
+share. If you make compositions with it, put us in the program notes.
+
+Some of the concepts are covered by various patents, some known to us
+and likely others which are unknown.  Many of the ones known to us are
+administered by the Stanford Office of Technology and Licensing.
+
+The good news is that large hunks of the techniques used here are
+public domain.  To avoid subtle legal issues, we'll not state what's
+freely useable here, but we'll try to note within the various classes
+where certain things are likely to be protected by patents.
+
+
+# FURTHER READING
+
+For complete documentation on this ToolKit, the classes, etc., see the
+doc directory of the distribution or surf to
+http://ccrma.stanford.edu/software/stk/.  Also check the platform
+specific README's for specific system requirements.
+
+
+# PERRY'S NOTES FROM THE ORIGINAL DISTRIBUTION
+
+This whole world was created with no particular hardware in mind.
+These examples are intended to be tutorial in nature, as a platform
+for the continuation of my research, and as a possible starting point
+for a software synthesis system.  The basic motivation was to create
+the necessary unit generators to do the synthesis, processing, and
+control that I want to do and teach about.  Little thought for
+optimization was given and therefore improvements, especially speed
+enhancements, should be possible with these classes.  It was written
+with some basic concepts in mind about how to let compilers optimize.
+
+Your question at this point might be, "But Perry, with CMix, CMusic,
+CSound, CShells, CMonkeys, etc. already cluttering the landscape, why
+a new set of stupid C functions for music synthesis and processing?"
+The answers lie below.
+
+1) I needed to port many of the things I've done into something which is generic enough to port further to different machines.
+
+2) I really plan to document this stuff, so that you don't have to be me to figure out what's going on. (I'll probably be sorry I said this in a couple of years, when even I can't figure out what I was thinking.)
+
+3) The classic difficulties most people have in trying to implement physical models are:
+
+    A) They have trouble understanding the papers, and/or in turning the theory into practice.
+
+    B) The Physical Model instruments are a pain to get to oscillate, and coming up with stable and meaningful parameter values is required to get the models to work at all.
+
+This set of C++ unit generators and instruments might help to diminish the scores of emails I get asking what to do with those block diagrams I put in my papers.
+
+4) I wanted to try some new stuff with modal synthesis, and implement some classic FM patches as well.
+
+5) I wanted to reimplement, and newly implement more of the intelligent and physical performer models I've talked about in some of my papers. But I wanted to do it in a portable way, and in such a way that I can hook up modules quickly.  I also wanted to make these instruments connectable to such player objects, so folks like Brad Garton who really think a lot about the players can connect them to my instruments, a lot about which I think.
+
+6) More rationalizations to follow . . .
+

configure.ac

@@ -1,12 +1,19 @@
 # Process this file with autoconf to produce a configure script.
-AC_INIT(STK, 4.2.1, gary@music.mcgill.ca, stk)
+AC_INIT(STK, 4.5.1, gary@music.mcgill.ca, stk)
+AC_CONFIG_AUX_DIR(config)
 AC_CONFIG_SRCDIR(src/Stk.cpp)
-AC_CONFIG_FILES(src/Makefile projects/demo/Makefile projects/effects/Makefile projects/ragamatic/Makefile projects/examples/Makefile projects/examples/libMakefile)
+AC_CONFIG_FILES(Makefile src/Makefile projects/demo/Makefile projects/effects/Makefile projects/ragamatic/Makefile projects/examples/Makefile projects/examples/libMakefile projects/eguitar/Makefile)
+
+# Fill GXX with something before test.
+AC_SUBST( GXX, ["no"] )
 
 # Checks for programs.
-AC_PROG_CC
 AC_PROG_CXX(g++ CC c++ cxx)
-AC_PROG_CXX
+AC_PROG_RANLIB
+AC_PATH_PROG(AR, ar, no)
+if [[ $AR = "no" ]] ; then
+    AC_MSG_ERROR("Could not find ar - needed to create a library");
+fi
 
 # Checks for header files.
 AC_HEADER_STDC
@@ -33,82 +40,175 @@ AC_MSG_RESULT($INCLUDE_PATH)
 
 # Check for realtime support disable
 AC_MSG_CHECKING(whether to compile realtime support)
-AC_ARG_ENABLE(realtime, [  --disable-realtime = only compile generic non-realtime classes], [AC_SUBST( realtime, [no] ) AC_SUBST( sound_api, [] )], [AC_SUBST( realtime, [yes] ) ] )
+AC_ARG_ENABLE(realtime,
+         [  --disable-realtime = only compile generic non-realtime classes],
+         realtime=$enableval)
+if test "$realtime" = "no"; then
+   AC_SUBST( sound_api, [] )
+else
+   AC_SUBST( realtime, [yes] )
+fi
 AC_MSG_RESULT($realtime)
 
+AC_MSG_CHECKING(whether to build the static library)
+AC_ARG_ENABLE(static,
+         [  --disable-static = do not compile static library ],
+	 build_static=$enableval,
+	 build_static=yes)
+AC_SUBST(build_static)
+AC_MSG_RESULT($build_static)
+
+AC_MSG_CHECKING(whether to build the shared library)
+AC_ARG_ENABLE(shared,
+         [  --enable-shared = compile the shared library ],
+	 build_shared=$enableval,
+	 build_shared=no)
+AC_SUBST(build_shared)
+AC_MSG_RESULT($build_shared)
+
+if test x$build_static = xno -a x$build_shared = xno ; then
+        AC_MSG_ERROR([ both static and shared libraries are disabled], 1)
+fi
+
 # Check for math library
 AC_CHECK_LIB(m, cos, , AC_MSG_ERROR(math library is needed!))
 
-if test $realtime = yes; then
-  AC_CHECK_LIB(pthread, pthread_create, , AC_MSG_ERROR(realtime support requires the pthread library!))
-  AC_CHECK_FUNCS(gettimeofday select socket)
-fi
-
 # Check for debug
 AC_MSG_CHECKING(whether to compile debug version)
 AC_ARG_ENABLE(debug,
-  [  --enable-debug = enable various debug output],
-  [AC_SUBST( debug, ["-D_STK_DEBUG_ -D__RTAUDIO_DEBUG__"] ) AC_SUBST( cflags, ["-g -O2"] ) AC_SUBST( object_path, [Debug] ) AC_MSG_RESULT(yes)],
-  [AC_SUBST( debug, [] ) AC_SUBST( cflags, [-O3] ) AC_SUBST( object_path, [Release] ) AC_MSG_RESULT(no)])
+        [  --enable-debug = enable various debug output],
+        debug=$enableval)
+if test "$debug" = "yes"; then
+   AC_SUBST( cppflag, ["-D_STK_DEBUG_ -D__RTAUDIO_DEBUG__ -D__RTMIDI_DEBUG__"] )
+   AC_SUBST( cxxflag, ["-g"] )
+   AC_SUBST( object_path, [Debug] )
+else
+  AC_SUBST( debug, [no] )
+  AC_SUBST( cppflag, [] )
+  AC_SUBST( cxxflag, [-O3] )
+  AC_SUBST( object_path, [Release] )
+fi
+AC_MSG_RESULT($debug)
+
+# Checks for functions
+if test $realtime = yes; then
+  AC_CHECK_FUNCS(select socket)
+  AC_CHECK_FUNC(gettimeofday, [cppflag="$cppflag -DHAVE_GETTIMEOFDAY"], )
+fi
+
+# For -I and -D flags
+CPPFLAGS="$CPPFLAGS $cppflag"
+
+# For debugging and optimization ... overwrite default because it has both -g and -O2
+CXXFLAGS="$cxxflag"
 
 # Check compiler and use -Wall if gnu.
-if test $GXX = "yes" ; then
-  AC_SUBST( warn, ["-Wall -g -D__GXX__"] )
+if [test $GXX = "yes" ;] then
+  AC_SUBST( cxxflag, [-Wall] )
 fi
 
+CXXFLAGS="$CXXFLAGS $cxxflag"
+
+AC_CANONICAL_HOST
+
+basesharedname="libstk-\$(RELEASE)"
+
+AC_SUBST( sharedlib, ["libstk.so"] )
+AC_SUBST( sharedname, [${basesharedname}.so] )
+AC_SUBST( libflags, ["-shared -Wl,-soname,${basesharedname}.so -o $sharedname"] )
+case $host in
+  *-apple*)
+  AC_SUBST( sharedlib, ["libstk.dylib"] )
+  AC_SUBST( sharedname, ["${basesharedname}.dylib"] )
+  AC_SUBST( libflags, ["-dynamiclib -o ${basesharedname}.dylib"] )
+esac
+
 if test $realtime = yes; then
   # Checks for package options and external software
-  AC_CANONICAL_HOST
   AC_MSG_CHECKING(for audio API)
   case $host in
     *-*-linux*)
-    AC_SUBST( sound_api, [_NO_API_] )
+    AC_ARG_WITH(jack, [  --with-jack = choose JACK server support (mac and linux only)], [
+    api="$api -D__UNIX_JACK__"
+    AC_MSG_RESULT(using JACK)
+    AC_CHECK_LIB(jack, jack_client_open, , AC_MSG_ERROR(JACK support requires the jack library!))
+    AC_CHECK_LIB(asound, snd_pcm_open, , AC_MSG_ERROR(Jack support also requires the asound library!))], )
 
-    # Look for ALSA library because we need it for RtMidi
-    AC_CHECK_LIB(asound, snd_pcm_open, , AC_MSG_ERROR(STK in Linux requires the ALSA asound library for RtMidi!))
-    audio_apis="-D__LINUX_ALSASEQ__" 
-
-    # Look for Jack flag
-    AC_ARG_WITH(jack, [  --with-jack = choose JACK server support (linux only)], [AC_SUBST( sound_api, [-D__LINUX_JACK__] ) AC_MSG_RESULT(using JACK)] , )
-    if [test $sound_api = -D__LINUX_JACK__;] then
-      TEMP_LIBS=$LIBS
-      AC_CHECK_LIB(jack, jack_client_new, , AC_MSG_ERROR(JACK support requires the jack library!))
-      LIBS="`pkg-config --cflags --libs jack` $TEMP_LIBS -lasound"
-      audio_apis="-D__LINUX_JACK__ $audio_apis"
-    fi
-
-    # Look for Alsa flag
-    AC_ARG_WITH(alsa, [  --with-alsa = choose native ALSA API support (linux only)], [AC_SUBST( sound_api, [-D__LINUX_ALSA__] ) AC_MSG_RESULT(using ALSA)], )
-    if test $sound_api = -D__LINUX_ALSA__; then
-      audio_apis="-D__LINUX_ALSA__ $audio_apis"
-    fi
+    # Look for ALSA flag
+    AC_ARG_WITH(alsa, [  --with-alsa = choose native ALSA API support (linux only)], [
+    api="$api -D__LINUX_ALSA__"
+    AC_MSG_RESULT(using ALSA)
+    AC_CHECK_LIB(asound, snd_pcm_open, , AC_MSG_ERROR(ALSA support requires the asound library!))], )
 
     # Look for OSS flag
-    AC_ARG_WITH(oss, [  --with-oss = choose OSS API support (linux only)], [AC_SUBST( sound_api, [-D__LINUX_OSS__] ) AC_MSG_RESULT(using OSS)], )
-    if test $sound_api = -D__LINUX_OSS__; then
-      audio_apis="-D__LINUX_OSS__ $audio_apis"
-    fi
+    AC_ARG_WITH(oss, [  --with-oss = choose OSS API support (linux only)], [
+    api="$api -D__LINUX_OSS__ -D__LINUX_ALSA__"
+    AC_MSG_RESULT(using OSS)
+    AC_CHECK_LIB(asound, snd_pcm_open, , AC_MSG_ERROR(OSS support requires ALSA for RtMidi!))], )
 
     # If no audio api flags specified, use ALSA
-    if [test $sound_api = _NO_API_;] then
+    if [test "$api" == "";] then
       AC_MSG_RESULT(using ALSA)
-      audio_apis="-D__LINUX_ALSA__ $audio_apis"
+      AC_SUBST( api, [-D__LINUX_ALSA__] )
+      AC_CHECK_LIB(asound, snd_pcm_open, , AC_MSG_ERROR(ALSA support requires the asound library!))
     fi
-    ;;
 
-    *-sgi*)
-    AC_SUBST( audio_apis, ["-D__IRIX_AL__ -D__IRIX_MD__ -LANG:std -w"] )
-    AC_MSG_RESULT(using IRIX AL)
-    AC_CHECK_LIB(audio, alOpenPort, , AC_MSG_ERROR(IRIX audio support requires the audio library!) )
-    AC_CHECK_LIB(md, mdOpenInPort, , AC_MSG_ERROR(IRIX MIDI support requires the md library!) )
+    AC_CHECK_LIB(pthread, pthread_create, , AC_MSG_ERROR(RtAudio requires the pthread library!))
     ;;
 
     *-apple*)
-    # Check for CoreAudio and CoreMIDI framework
-    AC_CHECK_HEADERS(CoreAudio/CoreAudio.h CoreMIDI/CoreMIDI.h CoreServices/CoreServices.h,
-      [AC_SUBST( audio_apis, [-D__MACOSX_CORE__] )],
-      [AC_MSG_ERROR(CoreAudio and/or CoreMIDI header files not found!)] )
-    AC_SUBST( frameworks, ["-framework CoreAudio -framework CoreMIDI -framework CoreFoundation"] )
+    AC_ARG_WITH(jack, [  --with-jack = choose JACK server support (unix only)], [
+    api="$api -D__UNIX_JACK__"
+    AC_MSG_RESULT(using JACK)
+    AC_CHECK_LIB(jack, jack_client_new, , AC_MSG_ERROR(JACK support requires the jack library!))], )
+
+    # Look for Core flag
+    AC_ARG_WITH(core, [  --with-core = choose CoreAudio API support (mac only)], [
+    api="$api -D__MACOSX_CORE__"
+    AC_MSG_RESULT(using CoreAudio)
+    AC_CHECK_HEADER(CoreAudio/CoreAudio.h, [], [AC_MSG_ERROR(CoreAudio header files not found!)] )
+    LIBS="$LIBS -framework CoreAudio -framework CoreFoundation -framework CoreMIDI" ], )
+
+    # If no audio api flags specified, use CoreAudio
+    if [test "$api" == ""; ] then
+      AC_SUBST( api, [-D__MACOSX_CORE__] )
+      AC_MSG_RESULT(using CoreAudio)
+      AC_CHECK_HEADER(CoreAudio/CoreAudio.h,
+      [],
+      [AC_MSG_ERROR(CoreAudio header files not found!)] )
+      AC_SUBST( LIBS, ["-framework CoreAudio -framework CoreFoundation -framework CoreMIDI"] )
+    fi
+
+    AC_CHECK_LIB(pthread, pthread_create, , AC_MSG_ERROR(RtAudio requires the pthread library!))
+    ;;
+
+    *-mingw32*)
+    AC_ARG_WITH(asio, [  --with-asio = choose ASIO API support (windoze only)], [
+    api="$api -D__WINDOWS_ASIO__"
+    AC_MSG_RESULT(using ASIO)
+    AC_SUBST( objects, ["asio.o asiodrivers.o asiolist.o iasiothiscallresolver.o"] ) ], )
+
+    # Look for DirectSound flag
+    AC_ARG_WITH(ds, [  --with-ds = choose DirectSound API support (windoze only)], [
+    api="$api -D__WINDOWS_DS__"
+    AC_MSG_RESULT(using DirectSound)
+    LIBS="-ldsound $LIBS" ], )
+
+    # Look for WASAPI flag
+    AC_ARG_WITH(wasapi, [  --with-wasapi = choose Windows Audio Session API support (windoze only)], [
+    api="$api -D__WINDOWS_WASAPI__"
+    AC_MSG_RESULT(using WASAPI)
+    LIBS="-luuid -lksuser $LIBS" ], )
+
+    # If no audio api flags specified, use DirectSound
+    if [test "$api" == "";] then
+      AC_SUBST( api, [-D__WINDOWS_DS__] )
+      AC_MSG_RESULT(using DirectSound)
+      LIBS="-ldsound -lwinmm $LIBS"
+    fi
+
+    api="$api -D__WINDOWS_MM__"
+    LIBS="-lole32 -lwinmm -lwsock32 $LIBS"
     ;;
 
     *)
@@ -116,10 +216,8 @@ if test $realtime = yes; then
     AC_MSG_ERROR(Unknown system type for realtime support ... try --disable-realtime argument!)
     ;;
   esac
+
+CPPFLAGS="$CPPFLAGS $api"
 fi
 
-# Checks for library functions.
-AC_PROG_GCC_TRADITIONAL
-AC_CHECK_FUNCS(strstr)
-
 AC_OUTPUT

doc/README-Linux.txt

@@ -1,21 +1,13 @@
 The Synthesis ToolKit in C++ (STK)
 
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
 
 Please read the file README and INSTALL for more general STK information.
 
-Realtime audio support for Linux currently includes the Advanced Linux Sound Architecture (ALSA), the JACK low-latency audio server, and/or Open Sound System (OSS) APIs.  One or more APIs are selected during compilation using the __LINUX_ALSA__, __LINUX_JACK__, and/or __LINUX_OSS__ definitions.  Because the ALSA library is now integrated into the standard Linux kernel, it is the default audio/MIDI API with STK versions 4.2 and higher.  The __LINUX_ALSASEQ__ definition is required to compile RtMidi with ALSA sequencer support.  Native OSS MIDI support no longer exists in RtMidi.  If the __LINUX_OSS__ preprocessor definition is specified, only OSS audio support will be compiled and RtMidi will still be compiled using the ALSA API.  For this reason, STK now requires the asound library for realtime support.  Realtime programs must also link with the <TT>pthread</TT> library.  The OSS audio API can be selected by passing the "--with-oss" option to configure.
+Realtime audio support for Linux currently includes the Advanced Linux Sound Architecture (ALSA), the JACK low-latency audio server, and/or Open Sound System (OSS version 4.0 and higher only) APIs.  That said, the OSS API support has not been tested in several years and is not considered a high priority.  One or more APIs are selected during compilation using the __LINUX_ALSA__, __UNIX_JACK__, and/or __LINUX_OSS__ definitions.  Because the ALSA library is now integrated into the standard Linux kernel, it is the default audio/MIDI API with STK versions 4.2 and higher.
 
-The free version of OSS generally works as well (and in some cases better than the commercial OSS version ... such as with my Maestro 2e chipset).  In general, the ALSA drivers also seem to perform well.  You can read more about ALSA at http://www.alsa-project.org/.  ALSA is open source and holds great promise for audio under Linux.  
+Realtime MIDI support Linux currently includes the Jack and ALSA sequencer support.  Native OSS MIDI support no longer exists in RtMidi.  If the __LINUX_OSS__ preprocessor definition is specified, only OSS audio support will be compiled and RtMidi will still be compiled using the ALSA API.  For this reason, STK now requires the asound library for realtime support (unless only using the Jack API).  Realtime programs must also link with the pthread library.
 
-STK should compile without much trouble under Linux.  Since all Linux distributions typically include the GNU makefile utilities, you should be able to use the default Makefile.  Typing "make" will initiate the compilation process.
-
-MIDIATOR SERIAL PORT MIDI SUPPORT:
-
-MIDIator support has been removed from RtMidi with STK versions 4.2 and higher.  If you really need it, you can contact us to get an old distribution.
-
-NOTE REGARDING PTHREADS:
-
-There haven't been any problems with threads since the old days of RedHat Linux 5.0.  STK uses the MIT pthreads API.
+STK should compile without much trouble under Linux.  Since all Linux distributions typically include the GNU makefile utilities, you should be able to use the default Makefiles.  Typing "make" in a project directory will initiate the compilation process (after initially running the configure script in the top-level directory).
 
 

doc/README-MacOSX.txt

@@ -1,21 +1,16 @@
 The Synthesis ToolKit in C++ (STK)
 
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
 
 Please read the file README and INSTALL for more general STK information.
 
-Realtime support for Macintosh OS X uses the CoreAudio HAL API and is specified during compilation using the __MACOSX_CORE__ preprocessor definition.
-
-It is necessary to install the OS X developer kit in order to compile STK.  STK was successfully tested on OS X versions 10.4.
-
-The internal Macintosh audio hardware typically supports a sample rate of 44100 Hz only.  The default STK sample rate is now 44100 Hz and all current example programs use this rate.  However, it is possible to manually override this value in some programs from the command-line.  The default sample rate is set in Stk.h.  In addition, the RT_BUFFER_SIZE, specified in Stk.h, could be increased (to a higher power of two) for more robust performance.
-
-There is a potential conflict between the STK Delay class and a Delay() function declared in OSUtils.h (which is included via <CoreServices/CoreServices.h>).  In general, this conflict can be avoided via the use of a namespace (an explicit Delay::Delay declaration), though this made the Windows Visual C++ compiler barf.  If you use STK classes within a project that includes the OSUtils.h file, you will likely need to make changes in STK classes that use the Delay class.
+The default realtime support for Macintosh OS X uses the CoreAudio HAL API and is specified during compilation using the __MACOSX_CORE__ preprocessor definition.  There is also support for the JACK audio server using the __UNIX_JACK__ preprocessor definition.
 
+It is necessary to install the OS X developer kit (or the command line tools) in order to compile STK.  STK was successfully tested on the latest version of OS X.
 
 Tcl/Tk on OS X:
 
-The tcl/tk interpreter does not ship by default with OS X, but must be downloaded from the internet.  The latest Tcl/Tk Aqua distribution (http://www.apple.com/downloads/macosx/unix_open_source/tcltk.html) has been successfully tested on 10.2 and 10.3 systems.  The default installation will place a link to the wish interpretor at /usr/bin/wish.
+I think that tcl/tk interpreter is now included in the XCode package, since I haven't had to download it for several years now.
 
 It appears that socket support in Tcl/Tk on OS X uses the Nagle algorithm, which produces poor response between changes made in the tcl/tk script and the resulting audio updates.  Note that this is only a problem when using a socket connection from a Tcl/Tk script.
 

doc/README-NeXT.txt

@@ -1,7 +0,0 @@
-The Synthesis ToolKit in C++ (STK)
-
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
-
-Please read the file README and INSTALL for more general STK information.
-
-STK has always worked under NeXTStep without realtime audio or MIDI support.  In general, STK should compile in this way using any generic C++ compiler.  C++ exception handling was added to STK with release 3.2.  We managed to get a version of gcc compiled for NeXTStep that can deal with C++ exceptions.

doc/README-SGI.txt

@@ -1,15 +1,7 @@
 The Synthesis ToolKit in C++ (STK)
 
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
 
 Please read the file README and INSTALL for more general STK information.
 
-The project Makefiles are created by configure.  If you have trouble running "make", try invoking "gmake" (for GNU make).  If that doesn't work, try to download the GNU Makefile utilities from the Internet.
-
-Another issue that has crept up with this release is proper compiler support for C++ error handling.  If you experience problems, you probably don't have a recent version of the C++ compiler.  Otherwise, STK should compile and run on SGI platforms without any problems.  Release 4.0 of STK is confirmed to compile (with various warnings) using CC version 7.30.
-
-The __IRIX_AL__ and __IRIX_MD__ preprocessor definitions are required for realtime audio and MIDI support.
-
-NOTE REGARDING PTHREADS:
-
-Since release 3.1, STK has used the pthread API under Irix.  It appears that pthread functionality is standard on SGI, so this change shouldn't cause any problems.  If I'm wrong, let me know!
+Since STK version 4.3, realtime support for IRIX has been discontinued due to an inability to test it.  If you need realtime support on an SGI, go back to version 4.2.1.  Release 4.0 of STK is confirmed to compile (with various warnings) using CC version 7.30.

doc/README-Win.txt

@@ -1,23 +1,22 @@
 The Synthesis ToolKit in C++ (STK)
 
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
 
 Please read the file README for more general STK information.
 
-DirectX and WindowsNT Issues:
------------------------------
+The configure script supports MinGW.  As well, STK is distributed with Visual C++ .NET project and workspace files (though these may no longer work with current versions of Visual Studio).  It no longer compiles with Visual C++ 6.0.
 
-STK is currently distributed with Visual C++ 6.0 project and workspace files.  It has been tested using both Visual C++ 6.0 and Visual C++ .NET.
+With Windows XP/7, piping works as under unix.  Simply fire up the script files (ex. StkDemo.bat) by either double-clicking on them or from within a shell.
 
-IMPORTANT VC++ NOTE: When compiling "release" versions of STK programs, link to the release multithreaded library.  When compiling "debug" versions, link to the debug multithreaded library.  Compiler errors will result otherwise.  Also, the Microsoft folk are up to their old habits of trying to change standards.  The .NET compiler will complain about cerr for some reason.
+IMPORTANT VC++ NOTE: When compiling "release" versions of STK programs, link to the release multithreaded library.  When compiling "debug" versions, link to the debug multithreaded library.  Compiler errors will result otherwise.
 
-Both the DirectSound and Steinberg ASIO audio APIs are supported for realtime audio input/output.  The Visual C++ project files included with this distribution are configured to use the DirectSound API.  In order to use the ASIO API, it is necessary to change the preprocessor definition from __WINDOWS_DS__ to __WINDOWS_ASIO__, as well as include all the files in the /src/asio/ directory (i.e. asio.h, asio.cpp, ...).  If you have a good quality soundcard and a native ASIO driver (not emulated), you are likely to get much better input/output response using that.
+The DirectSound, WASAPI and Steinberg ASIO audio APIs are supported for realtime audio input/output.  The Visual C++ project files included with this distribution are configured to use all supported APIs.  In order to use the ASIO API, it is necessary to use the preprocessor definition __WINDOWS_ASIO__, as well as include most of the files in the /src/include/ directory (i.e. asio.h, asio.cpp, ...).  If you have a good quality soundcard and a native ASIO driver (not emulated), you are likely to get much better input/output response using that.
 
-When using the DirectSound API for audio input, latency is typically pretty horrendous (should we be surprised?).  Also, there is a slight chance you don't have DirectSoundCapture support on your computer.  If not, you should download the DirectX 6.0 (or higher) runtime libraries from Microsoft's WWW site (http://www.microsoft.com/directx/download.asp) in order to run the pre-compiled STK executables for Windoze.  The last time I checked, there was no DirectSoundCapture support for WindowsNT ... you'll have to switch to Windows 2000 or XP or use an ASIO driver.  I stopped supporting the WinMM audio output code with release 3.2.
+When using the DirectSound API for audio input, latency can be high.  If you experience realtime audio "stuttering", you should experiment with different "buffer size" and "number of buffers" values.
 
 Realtime MIDI input/output is supported by RtMidi using the winmm.lib API and requires the __WINDOWS_MM__ preprocessor definition.
 
-Visual C++ 6.0 workspaces have been created for the various STK projects.  Everything has already been configured for you.  The intermediate .obj files will be written to either the "Release" or "Debug" directories, but the executable files will be written to the main project directories (where they need to be for proper execution).  If you should somehow lose or hose the VC++ workspace file for a project, then you will have to do a LOT of configuring to recreate it ... it's probably easier just to download the distribution again from our WWW sites.  Anyway, for your benefit and mine, here is a list of things that need to be added to the various "Project Settings":
+Visual C++ workspaces have been created for the various STK projects.  Everything has already been configured for you.  The intermediate .obj files will be written to either the "Release" or "Debug" directories, but the executable files will be written to the main project directories (where they need to be for proper execution).  If you should somehow lose or hose the VC++ workspace file for a project, then you will have to do a LOT of configuring to recreate it ... it's probably easier just to download the distribution again from our WWW sites.  Anyway, for your benefit and mine, here is a list of things that need to be added to the various "Project Settings" (this was for VC 6.0 ... things have changed with the newer versions of the VC compiler):
 
 1. Under General: Set "Output files:" to <blank> (this will put the executable in the main project directory.
 
@@ -33,42 +32,4 @@ Visual C++ 6.0 workspaces have been created for the various STK projects.  Every
 
 Remember that items 1-5 above need to be done for each project and for each configuration.  There might be an easy way to make global changes, but I couldn't figure it out.
 
-To use the Tcl/Tk GUIs, you will have to install Tcl/Tk.  I got version 8.0 and it works very well (and installed easily).  The distribution is available on the WWW and is free.
-
-In order for socketing to work, it is necessary to have the TCP protocol installed on your computer.  This can be done from the "Network" control panel.
-
-Finally, to use it all -
-
-
-WINDOWS XP/2000:
-
-There is a big advantage in using Windows XP/2000 over 95/98 with STK in that piping works, just as under unix.  Also, the scheduler in 2000/XP seems to be much better, so socketed messages don't get clumped together like they do in Windows 95/98.  Simply fire up a script file (ex. StkDemo.bat) by either double-clicking on it or typing it within a shell.
-
-
-WINDOWS 95/98:
-
-PLAY SKINI SCOREFILES IN REALTIME:
-
-	demo Clarinet -or -if scores/streetsf.ski
-
-USE TCL/TK GUIs FOR REALTIME CONTROL:
-
-1. Open a DOS console window and start syntmono (eg. demo Clarinet -or -is).
-
-2. Double click on a Tcl/Tk file in the tcl/ subdirectory of the demo directory (eg. Demo.tcl) from the Windows Explorer to start the GUI.  Select the "communications" menu item and "Socket" and make the connection.
-
-3. Start moving the sliders to control the instrument.
-
-
-USE REALTIME MIDI INPUT FOR CONTROL:
-
-1. Open a DOS console window and start syntmono with MIDI input (eg. demo Clarinet -or -im).
-
-   This assumes you already have MIDI setup correctly for your computer.
-
-
-WINDOWS NT ONLY:
-
-Realtime piping seems to work under WindowsNT in much the same way as on Unix platforms.  Thus, it is possible to pipe realtime control data to syntmono under WindowsNT as well.  Note, however, that the DirectSoundCapture API does not exist for WindowsNT, so it is necessary to use an ASIO audio driver and the STK ASIO support.
-
-
+To use the Tcl/Tk GUIs, you will have to install Tcl/Tk.

doc/ReleaseNotes.txt

@@ -1,13 +1,98 @@
 The Synthesis ToolKit in C++ (STK)
 
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
+
+v4.5.1 (22 February 2016)
+- fix for FileWvIn / FileLoop classes to avoid keeping files open if not necessary
+- miscellaneous bug fixes, documented on GitHub site (github.com/thestk/stk)
+- update to play.cpp example to play mono files as stereo
+- bug fix in DelayL::setDelay() function
+- miscellanous build bug fixes
+
+v4.5.0: (26 April 2014)
+- updated versions of RtAudio and RtMidi, with associated renaming of RtError class to either RtAudioError or RtMidiError and addition of WASAPI support in Windows
+- added support in FileRead for little-endian AIFC file format
+- new iOS project files (thanks to Ariel Elkin)
+- bug fix in FreeVerb that could cause crackling for stereo input
+- various bug fixes and updates to minimize compiler warnings
+- ADSR fix for decay/release time calculations
+- various updates to build system
+
+v4.4.4: (24 August 2012)
+- new FreeVerb class (thanks to Greg Burlet)
+- new Guitar class
+- new electric guitar project
+- cleaned / revised Shakers class
+- updated versions of RtAudio and RtMidi
+- bug fix in LentPitShift
+- bug fix in Echo constructor
+- bug fix in FileWvIn (file size when chunking)
+- bug fix in StkFrames copy constructor
+
+v4.4.3: (30 August 2011)
+- changed SINT24 to be lower 3 bytes of 32-bit word
+- bug fixes to vectorized tick functions in Effects classes
+- updated versions of RtAudio and RtMidi
+- fix to ADSR bugs
+- updates to the internal argument checking and reporting scheme
+- updates to Bowed class (thanks to Esteban Maestre!)
+- fixes for 24-bit support in FileRead and FileWrite
+- added WAVE_FORMAT_EXTENSIBLE support in FileWrite
+- added sample rate variable reading and writing for MAT-files in FileRead and FileWrite
+
+v4.4.2: (4 February 2011)
+- added various header file includes for newer compilers
+- new LentPitShift class (thanks to Francois Germain)
+- added "addTo" function to Delay class
+- updates to RtAudio and RtMidi
+- bug fixes in Voicer class (thanks Richard Dobson!)
+- bug fixes in Granulate class
+- added Makefile.in to compile library and all projects, as well as clean and distclean all
+
+v4.4.1: (3 June 2010)
+- added multi-channel/frame tick() virtual function to WvIn and WvOut abstract base classes (required update to RtWvOut class)
+- updated configure script to select g++ compiler by default
+- in demo.cpp: removed voicer grouping for messages, fixing polyphony when messages are on the same MIDI/SKINI channel
+- updates to RtAudio and RtMidi
+
+v4.4: (30 April 2010)
+- all classes embedded in the "stk" namespace (except RtAudio, RtMidi, and RtError)
+- class WaveLoop renamed FileLoop
+- significant efficiency improvements via code restructuring and inlining
+- some class source (.cpp) files deleted as part of inlining (Generator, Filter, Function, WvIn, WvOut, Effect, Instrmnt, BowTable, ReedTable, JetTable, Vector3D)
+- updates to RtAudio and RtMidi
+- previous "tickFrame()" functions renamed "tick" for more consistent API
+- more consistent and scalable approach to multichannel data and computations
+- multichannel support added to Granulate class
+- Filter class made abstract.  New Iir and Fir classes made for non-order-specific filtering.
+- new TapDelay class
+- SubNoise class deleted (same as sub-sampled "ticking" of Noise class)
+
+
+v4.3.1: (7 December 2007)
+- further headerless file support in FileRead
+- bug fix in RtWvOut.cpp
+- added configure support for MinGW
+- updates to RtAudio and RtMidi for MinGW
+- changes to channel assignment in demo.cpp
+
+
+v4.3.0: (13 August 2007)
+- an official MIT-like license
+- new functionality to automatically update class data when the STK sample rate changes (partly implemented)
+- updates for new RtAudio version 4.0
+- removed RtDuplex class, users should use RtAudio directly with a callback function
+- bug fix in interpolate() function in Stk.h for non-interleaved data
+- fixes / improvements to the Granulate class
+- fix in Whistle when doing animation
+- fixes in BlitSquare for frequency, harmonics, and dc offset
+- updates to Makefiles for non-realtime compile
+- fix in demo.cpp for voice channel assignment
+- updated versions of RtMidi and RtAudio
+- updated ASIO files for MinGW compiler
+- new FAQ in documentation
+- MAT-file bug fix in FileRead class
 
-Future To Do:
-- OSC server/client classes
-- move various error checks, especially in tick() functions, into __DEBUG__ blocks?
-- add WAVEFORMATEXTENSIBLE support to RtAudio
-- add WAVEFORMATEXTENSIBLE support to WvIn/WvOut?
-- better documentation
 
 v4.2.1: (14 October 2005)
 - greatly expanded StkFrames functionality (including interpolation and indexing by channel/frame)

doc/SKINI.txt

@@ -85,7 +85,7 @@ upon/from which to build and depart.
     the channel number is scanned as a long int.  Channels could be socket
     numbers, machine IDs, serial numbers, or even unique tags for each
     event in a synthesis.  Other fields might be used, as specified in the
-    SKINI.tbl file.  This is described in more detail later.
+    SKINItbl.h file.  This is described in more detail later.
 
     Fields in a SKINI line are delimited by spaces, commas, or
     tabs.  The SKINI parser only operates on a line at a time,
@@ -109,9 +109,9 @@ upon/from which to build and depart.
 
     All fields other than type, time, and channel are optional, and the
     types and useage of the additional fields is defined in the file
-    SKINI.tbl.
+    SKINItbl.h.
 
-    The other important file used by SKINI is SKINI.msg, which is a
+    The other important file used by SKINI is SKINImsg.h, which is a
     set of #defines to make C code more readable, and to allow reasonably
     quick re-mapping of control numbers, etc..  All of these defined
     symbols are assigned integer values.  For JAVA, the #defines could
@@ -127,13 +127,13 @@ upon/from which to build and depart.
     receiving SKINI messages a line at a time, usually in real time,
     but not restricted to real time.
 
-    SKINI.msg should be included by anything wanting to use the
+    SKINImsg.h should be included by anything wanting to use the
     Skini.cpp object.  This is not mandatory, but use of the __SK_blah_
     symbols which are defined in the .msg file will help to ensure
     clarity and consistency when messages are added and changed.
 
-    SKINI.tbl is used only by the SKINI parser object (Skini.cpp).
-    In the file SKINI.tbl, an array of structures is declared and
+    SKINItbl.h is used only by the SKINI parser object (Skini.cpp).
+    In the file SKINItbl.h, an array of structures is declared and
     assigned values which instruct the parser as to what the message
     types are, and what the fields mean for those message types.
     This table is compiled and linked into applications using SKINI, but
@@ -195,7 +195,7 @@ upon/from which to build and depart.
         A -1 channel can be used as don't care, omni, or other functions
         depending on your needs and taste.
 
-    g)  All remaining fields are specified in the SKINI.tbl file.
+    g)  All remaining fields are specified in the SKINItbl.h file.
         In general, there are maximum two more fields, which are either
         SK_INT (long), SK_DBL (double float), or SK_STR (string).  The
         latter is the mechanism by which more arguments can be specified
@@ -237,9 +237,9 @@ upon/from which to build and depart.
         NoteOff         0.000000 2 71 82
         NoteOff         0.000000 2 79 82
 
-7)  The SKINI.tbl File, How Messages are Parsed:
+7)  The SKINItbl.h File, How Messages are Parsed:
 
-    The SKINI.tbl file contains an array of structures which
+    The SKINItbl.h file contains an array of structures which
     are accessed by the parser object Skini.cpp.  The struct is:
 
         struct SKINISpec { char messageString[32];
@@ -276,7 +276,7 @@ upon/from which to build and depart.
                            something else stored in the SK_STR field, or
                            as a new type of multi-line message.
 
-    Here's a couple of lines from the SKINI.tbl file
+    Here's a couple of lines from the SKINItbl.h file
 
  {"NoteOff"          ,        __SK_NoteOff_,               SK_DBL,  SK_DBL},
  {"NoteOn"           ,         __SK_NoteOn_,               SK_DBL,  SK_DBL},
@@ -290,7 +290,7 @@ upon/from which to build and depart.
     The first three are basic MIDI messages.  The first two would cause the
     parser, after recognizing a match of the string "NoteOff" or "NoteOn",
     to set the message type to 128 or 144 (__SK_NoteOff_ and __SK_NoteOn_
-    are #defined in the file SKINI.msg to be the MIDI byte value, without
+    are #defined in the file SKINImsg.h to be the MIDI byte value, without
     channel, of the actual MIDI messages for NoteOn and NoteOff).  The parser
     would then set the time or delta time (this is always done and is
     therefore not described in the SKINI Message Struct).  The next two

doc/doxygen/compile.txt

@@ -1,6 +1,6 @@
 /*! \page compile Compiling
 
-The Synthesis ToolKit can be used in a variety of ways, depending on your particular needs.  Some people choose the classes they need for a particular project and copy those to their working directory.  Others create <TT>Makefiles</TT> which compile project-specific class objects from common <TT>src</TT> and <TT>include</TT> directories.  And still others like to compile and link to a common library of object files.  STK was not designed with one particular style of use in mind.
+The Synthesis ToolKit can be used in a variety of ways, depending on your particular needs.  Some people choose the classes they need for a particular project and copy those to their working directory.  Others create <TT>Makefiles</TT> that compile project-specific class objects from common <TT>src</TT> and <TT>include</TT> directories.  And still others like to compile and link to a common library of object files.  STK was not designed with one particular style of use in mind.
 
 
 \section rtvsnonrt "Realtime" vs. "Non-Realtime"
@@ -9,11 +9,11 @@ Most of the Synthesis ToolKit classes are platform independent.  That
 means that they should compile on any reasonably current C++ compiler.
 The functionality needed for realtime audio and MIDI input/output, as
 well as realtime control message acquistion, is inherently platform
-and operating-system (OS) <I>dependent</I>.  STK classes which require
+and operating-system (OS) <I>dependent</I>.  STK classes that require
 specific platform/OS support include RtAudio, RtWvOut, RtWvIn,
 RtDuplex, RtMidi, InetWvIn, InetWvOut, Socket, UdpSocket, TcpServer,
 TcpClient, Thread, and Mutex.  These classes currently can only be
-compiled on Linux, Irix, Macintosh OS X, and Windows systems.
+compiled on Linux, Macintosh OS X, and Windows systems.
 
 Without the "realtime" classes, it is still possible to read SKINI
 scorefiles for control input and to read and write to/from a variety
@@ -37,20 +37,20 @@ STK compiles with realtime support on the following flavors of the Unix operatin
 <TR>
   <TD>Linux</TD>
   <TD>ALSA</TD>
-  <TD>__LINUX_ALSA__, __LINUX_ALSASEQ__, __LITTLE_ENDIAN__</TD>
+  <TD>__LINUX_ALSA__, __LITTLE_ENDIAN__</TD>
   <TD><TT>asound, pthread</TT></TD>
 </TR>
 <TR>
   <TD>Linux</TD>
-  <TD>Jack (audio only, use ALSA for MIDI support)</TD>
-  <TD>__LINUX_JACK__, __LINUX_ALSASEQ__, __LITTLE_ENDIAN__</TD>
+  <TD>OSS (version 4.0 only, use ALSA for MIDI support)</TD>
+  <TD>__LINUX_OSS__, __LINUX_ALSA__, __LITTLE_ENDIAN__</TD>
   <TD><TT>asound, pthread</TT></TD>
 </TR>
 <TR>
-  <TD>Linux</TD>
-  <TD>OSS (audio only, use ALSA for MIDI support)</TD>
-  <TD>__LINUX_OSS__, __LINUX_ALSASEQ__, __LITTLE_ENDIAN__</TD>
-  <TD><TT>asound, pthread</TT></TD>
+  <TD>Linux and Macintosh OS-X</TD>
+  <TD>Jack</TD>
+  <TD>__UNIX_JACK__, __LITTLE_ENDIAN__</TD>
+  <TD><TT>asound, pthread, jack</TT></TD>
 </TR>
 <TR>
   <TD>Macintosh OS X</TD>
@@ -58,12 +58,6 @@ STK compiles with realtime support on the following flavors of the Unix operatin
   <TD>__MACOSX_CORE__</TD>
   <TD><TT>pthread, CoreAudio, CoreMIDI, CoreFoundation</TT></TD>
 </TR>
-<TR>
-  <TD>Irix</TD>
-  <TD>AL</TD>
-  <TD>__IRIX_AL__, __IRIX_MD__</TD>
-  <TD><TT>audio, pthread</TT></TD>
-</TR>
 </TABLE>
 </CENTER>
 
@@ -75,17 +69,15 @@ a particular program into a project directory.  Taking the
 would be necessary to set up a directory that includes the files
 <TT>sineosc.cpp</TT>, the rawwave file <TT>sinewave.raw</TT> in a
 subdirectory called <TT>rawwaves</TT>, and the header and source files
-for the classes Stk, FileRead, FileWrite, WvIn, FileWvIn, WaveLoop,
-WvOut, and FileWvOut.  The program could then be compiled on a
-little-endian system, such as a PC running Linux, using the GNU g++
-compiler as follows:
-\code
-g++ -Wall -D__LITTLE_ENDIAN__ -o sineosc Stk.cpp FileRead.cpp FileWrite.cpp WvIn.cpp FileWvIn.cpp WaveLoop.cpp WvOut.cpp FileWvOut.cpp sineosc.cpp
-\endcode
+for the classes Stk, FileRead, FileWrite, FileWvIn, FileLoop, and
+FileWvOut.  The program could then be compiled on a little-endian
+system, such as a PC running Linux, using the GNU g++ compiler as
+follows:
+\code g++ -Wall -D__LITTLE_ENDIAN__ -o sineosc Stk.cpp FileRead.cpp FileWrite.cpp FileWvIn.cpp FileLoop.cpp FileWvOut.cpp sineosc.cpp \endcode
 
 Note that the <TT>sineosc.cpp</TT> example does not make use of realtime audio or MIDI input/output classes.  For programs using any of the STK realtime classes mentioned above, it is necessary to specify an audio/MIDI API preprocessor definition and link with the appropriate libraries or frameworks.
 
-When working with a number of different projects that make use of ToolKit classes, the above approach can become cumbersome (especially when trying to synchronize with new STK releases).  Most of the STK projects (e.g., demo, effects, ...) contain <TT>Makefiles</TT> (built by the configure script) which compile project-specific class objects from the distribution <TT>src</TT> and <TT>include</TT> directories.  This approach makes it relatively easy when upgrading to a new STK release (by making path substitutions in the <TT>Makefile</TT> or by moving the projects to a similar relative path within the new STK source tree).  A <TT>Makefile</TT> is provided in the <TT>projects/examples</TT> directory for compiling all the tutorial programs, as well as other example programs.  To compile the <TT>sineosc.cpp</TT> program, for example, one need only type <TT>make sineosc</TT> from within the <TT>projects/examples</TT> directory.
+When working with a number of different projects that make use of ToolKit classes, the above approach can become cumbersome (especially when trying to synchronize with new STK releases).  Most of the STK projects (e.g., demo, effects, ...) contain <TT>Makefiles</TT> (built by the configure script) that compile project-specific class objects from the distribution <TT>src</TT> and <TT>include</TT> directories.  This approach makes it relatively easy when upgrading to a new STK release (by making path substitutions in the <TT>Makefile</TT> or by moving the projects to a similar relative path within the new STK source tree).  A <TT>Makefile</TT> is provided in the <TT>projects/examples</TT> directory for compiling all the tutorial programs, as well as other example programs.  To compile the <TT>sineosc.cpp</TT> program, for example, one need only type <TT>make sineosc</TT> from within the <TT>projects/examples</TT> directory.
 
 
 \subsection library Library Use:
@@ -101,7 +93,7 @@ g++ -Wall -D__LITTLE_ENDIAN__ -I/usr/include/stk -o sineosc sineosc.cpp -lstk
 With the header files in a standard search path, it is possible to modify the <TT>\#include</TT> statements in the <TT>sineosc.cpp</TT> program as follows:
 
 \code
-#include "stk/WaveLoop.h"
+#include "stk/FileLoop.h"
 #include "stk/FileWvOut.h"
 \endcode
 
@@ -114,16 +106,16 @@ g++ -Wall -D__LITTLE_ENDIAN__ -o sineosc sineosc.cpp -lstk
 
 \section compileWin Windows:
 
-STK has been tested on Windows platforms using the Visual C++ compiler
+STK has been tested on Windows platforms using the Visual .NET compiler
 only.  It is assumed here that you're familiar with Visual C++ and its
-particular idiosyncrasies.
+particular idiosyncrasies.  STK won't compile in Visual C++ 6.0 any more.
 
-The approach when using Visual C++ is to build a project which
+The approach when using Visual C++ is to build a project that
 includes the necessary ToolKit files from the distribution
 <TT>src</TT> and <TT>include</TT> directories.  For the example
 program from the previous tutorial chapter, create a VC++ console
 application project, add the Stk, FileRead, FileWrite, WvIn, FileWvIn,
-WaveLoop, WvOut, and FileWvOut class files, as well as
+FileLoop, WvOut, and FileWvOut class files, as well as
 <TT>sineosc.cpp</TT>, and make sure the <TT>sinewave.raw</TT> file is
 in the subdirectory <TT>rawwaves</TT>.
 

doc/doxygen/control.txt

@@ -19,9 +19,20 @@ NoteOff         1.000000  2  69.0  64.0
 
 MIDI messages are easily represented within the SKINI protocol.
 
-The class Messager can be used to acquire and parse MIDI messages from a MIDI device and SKINI messages from STDIN and socket connections.  Incoming messages are acquired asynchronously and saved to an internal message queue of Skini::Message types (MIDI messages are converted to the Skini:Message format).  The user then uses the Messager:popMessage() function to retrieve incoming control messages.  This function does not block, instead returning a message type of zero when no more messages are in the queue.  Many of the example programs included with the ToolKit distribution use a Messager instance to accept control input from the accompanying tcl/tk graphical user interfaces, from external MIDI devices, or from SKINI scorefiles.
+The class stk::Messager can be used to acquire and parse MIDI messages
+from a MIDI device and SKINI messages from STDIN and socket
+connections.  Incoming messages are acquired asynchronously and saved
+to an internal message queue of stk::Skini::Message types (MIDI
+messages are converted to the stk::Skini:Message format).  The user
+then uses the stk::Messager:popMessage() function to retrieve incoming
+control messages.  This function does not block, instead returning a
+message type of zero when no more messages are in the queue.  Many of
+the example programs included with the ToolKit distribution use a
+stk::Messager instance to accept control input from the accompanying tcl/tk
+graphical user interfaces, from external MIDI devices, or from SKINI
+scorefiles.
 
-In the following example, we'll modify the <TT>bethree.cpp</TT> program from the previous tutorial chapter and incorporate a Messager class to allow control via SKINI messages read from a SKINI file.
+In the following example, we'll modify the <TT>bethree.cpp</TT> program from the previous tutorial chapter and incorporate a stk::Messager class to allow control via SKINI messages read from a SKINI file.
 
 \include controlbee.cpp
 
@@ -37,7 +48,7 @@ controlbee scores/bookert.ski
 
 Only a few basic SKINI message type case statements are included in this example.  It is easy to extend the program to support a much more elaborate set of instrument control parameters.
 
-This example could also be easily extended to accept "realtime" control input messages via pipe, socket or MIDI connections.  The Messager class provides Messager::startStdInput(), Messager::startSocketInput(), and Messager::startMidiInput() functions for this purpose.
+This example could also be easily extended to accept "realtime" control input messages via pipe, socket or MIDI connections.  The stk::Messager class provides stk::Messager::startStdInput(), stk::Messager::startSocketInput(), and stk::Messager::startMidiInput() functions for this purpose.
 
 [<A HREF="tutorial.html">Main tutorial page</A>] &nbsp; [<A HREF="multichannel.html">Next tutorial</A>]
 */

doc/doxygen/crealtime.txt

@@ -1,26 +1,74 @@
 /*! \page crealtime Realtime Audio (callback)
 
-The previous section described the use of the RtWvOut class for realtime audio output. The RtWvOut::tick() function periodically pauses program execution in order to send a buffer of audio data to the computer's audio hardware (referred to as blocking functionality).  These pauses will effectively limit a program's computations to the correct number of samples per second, which is defined by the sample rate of the hardware.
+An alternative scheme for audio input/output is to define a specific
+function in which audio computations are performed and to let the
+audio system call this function when more input/output data can be
+accepted by the hardware (referred to as a callback scheme).  In this
+section, we show how the previous <TT>rtsine.cpp</TT> program can be
+modified to work in a callback scenario.  There is no "single-sample"
+interface for this functionality.  The callback function will be
+invoked automatically by the audio system controller (RtAudio) when
+new data is needed and it is necessary to compute a full audio buffer
+of samples at that time (see \ref callback for further information).
 
-An alternative scheme for audio input/output is to define a specific function in which audio computations are performed and to let the audio system call this function when more input/output data can be accepted by the hardware (referred to as a callback scheme).  In this section, we show how the previous <TT>rtsine.cpp</TT> program can be modified to work in a callback scenario.  There is no "single-sample" interface for this functionality.  The callback function will be invoked automatically by the audio system controller (RtAudio) when new data is needed and it is necessary to compute a full audio buffer of samples at that time (see \ref callback for further information).
+The previous section described the use of the stk::RtWvOut class for
+realtime audio output. The stk::RtWvOut::tick() function writes data to a
+large ring-buffer, from which data is periodically written to the
+computer's audio hardware via an underlying callback routine.
 
 \include crtsine.cpp
 
-The sinusoidal oscillator is created as before.  The instantiation of RtAudio requires quite a few more parameters, including output/input device and channel specifiers, the data format, and the desired buffer length (in frames).  In this example, we request a single output channel using the default output device, zero channels of input, the RtAudio data format which corresponds to an <tt>StkFloat</tt>, and the RT_BUFFER_SIZE defined in Stk.h.  The last argument is an API-dependent buffering parameter (see RtAudio for further information).
+The sinusoidal oscillator is created as before.  The instantiation of
+RtAudio requires quite a few more parameters, including output/input
+device and channel specifiers, the data format, and the desired buffer
+length (in frames).  In this example, we request a single output
+channel using the default output device, zero channels of input, the
+RtAudio data format which corresponds to an <tt>StkFloat</tt>, and the
+RT_BUFFER_SIZE defined in Stk.h.  The \c bufferFrames argument is an
+API-dependent buffering parameter (see RtAudio for further
+information).
 
-After the digital-to-analog converter (dac) and oscillator are successfully created, it is necessary to provide the audio system controller with a pointer to our callback function.  The RtAudio::setStreamCallback() function takes a pointer to the callback function and an optional pointer to data that will be made available in the callback.  In this example, we need to pass only the pointer to the oscillator.  In more complex programs, it is typically necessary to put all shared data in a <tt>struct</tt> (see the next tutorial program for an example) or make use of global variables.
+We also provide the audio system controller with a pointer to our
+callback function and an optional pointer to data that will be made
+available in the callback.  In this example, we need to pass only the
+pointer to the oscillator.  In more complex programs, it is typically
+necessary to put all shared data in a <tt>struct</tt> (see the next
+tutorial program for an example) or make use of global variables.
 
-Our callback routine is the \c tick() function.  %Function arguments include a pointer to the audio data buffer, the buffer size (in frames), and the data pointer passed to the RtAudio::setStreamCallback() function (if it exists).  It is necessary to cast these pointers to their corresponding data types before use.  Our tick() routine simply "ticks" the oscillator for \c bufferSize counts and writes the result into the audio data buffer before returning.
+Our callback routine is the \c tick() function.  Function arguments
+include pointers to the audio input and output data buffers, the
+buffer size (in frames), a stream time argument, a status argument to
+test for over/underruns, and the data pointer passed in the
+openStream() function (if it exists).  It is necessary to cast these
+pointers to their corresponding data types before use.  Our tick()
+routine simply "ticks" the oscillator for \c nBufferFrames counts and
+writes the result into the audio data buffer before returning.
 
-The \c main() function blocks at the std::cin.get() call until the user hits the "enter" key, after which the audio controller is shut down and program execution ends.
+The \c main() function blocks at the std::cin.get() call until the
+user hits the "enter" key, after which the audio controller is shut
+down and program execution ends.
 
 \section callback Blocking vs. Callbacks
 
-Prior to version 4.2.0, all STK example projects and programs used blocking audio input/output functionality (typically with the RtWvIn, RtWvOut, or RtDuplex classes).  In many instances, a blocking scheme results in a clearer and more straight-forward program structure.  Within a graphical user interface (GUI) programming context, however, callback routines are often more natural.
+Prior to version 4.2.0, all STK example projects and programs used
+blocking audio input/output functionality (typically with the RtWvIn,
+RtWvOut, or RtDuplex classes).  In many instances, a blocking scheme
+results in a clearer and more straight-forward program structure.
+Within a graphical user interface (GUI) programming context, however,
+callback routines are often more natural.
 
-The RtAudio class provides both blocking and callback routines for all supported audio APIs.  It should be noted that it is easy to embed blocking calls within a thread to create "callback-like" functionality.  In fact, this is what RtAudio does for those audio APIs which are naturally based on blocking routines (Linux ALSA and OSS, SGI Irix, and Windows DirectSound).  It is much more difficult to make an inherently callback-based system work like a blocking scheme.  RtAudio attempts to do this with the Linux JACK, Macintosh OS-X CoreAudio, and Windows ASIO APIs, but the result is not fully robust (audio over/underruns are more likely to occur).
-
-In order to allow all STK programs to function with equal proficiency on all supported computer platforms, a decision was made to modify the example projects to use audio callback routines.  The result is a more complicated code structure, which is unfortunate given that we generally strive to make STK code as clear as possible for educational purposes.  This was especially an issue with the demo program because it is designed to function in both realtime and non-realtime contexts.  The use of global variables has been avoided by defining data structures to hold all variables which must be accessible to the callback routine and other functions.  Alternative schemes for making control updates could be designed depending on particular program needs and constraints.
+In order to allow all STK programs to function with equal proficiency
+on all supported computer platforms, a decision was made to modify the
+example projects to use audio callback routines.  The result is a more
+complicated code structure, which is unfortunate given that we
+generally strive to make STK code as clear as possible for educational
+purposes.  This was especially an issue with the demo program because
+it is designed to function in both realtime and non-realtime contexts.
+The use of global variables has been avoided by defining data
+structures to hold all variables that must be accessible to the
+callback routine and other functions.  Alternative schemes for making
+control updates could be designed depending on particular program
+needs and constraints.
 
 [<A HREF="tutorial.html">Main tutorial page</A>] &nbsp; [<A HREF="instruments.html">Next tutorial</A>]
 */

doc/doxygen/download.txt

@@ -1,221 +1,266 @@
 /*! \page download Download, Release Notes, and Bug Fixes
 
-\section down Download Version 4.2.1 (14 October 2005):
-
-<UL>
-<LI><A HREF="http://ccrma.stanford.edu/software/stk/release/stk-4.2.1.tar.gz">Source distribution</A></LI>
-<LI><A HREF="http://ccrma.stanford.edu/software/stk/release/stk-4.2.1.binaries.tar.gz">Source with precompiled Windows binaries</A></LI>
-<LI><A HREF="http://ccrma.stanford.edu/planetccrma/software/">Linux RPMs from Planet CCRMA</A></LI>
-</UL>
+\section down Download Version 4.5.1 (22 February 2016):
 
+- <A HREF="http://ccrma.stanford.edu/software/stk/release/stk-4.5.1.tar.gz">Source distribution</A>
 
 \section notes Release Notes:
+\subsection v4dot5dot1 Version 4.5.1
+- fix for FileWvIn / FileLoop classes to avoid keeping files open if not necessary
+- miscellaneous bug fixes, documented on GitHub site (github.com/thestk/stk)
+- update to play.cpp example to play mono files as stereo
+- bug fix in DelayL::setDelay() function
+- miscellanous build bug fixes
+
+\subsection v4dot5dot0 Version 4.5.0
+- Updated versions of RtAudio and RtMidi, with associated renaming of RtError class to either RtAudioError or RtMidiError
+- New iOS project files (thanks to Ariel Elkin)
+- Bug fix in FreeVerb that could cause crackling for stereo input
+- Various bug fixes and updates to minimize compiler warnings
+- ADSR fix for decay/release time calculations
+- Various updates to build system
+
+\subsection v4dot4dot4 Version 4.4.4
+- New FreeVerb class (thanks to Greg Burlet)
+- New Guitar class
+- New electric guitar project
+- Updated versions of RtAudio and RtMidi
+- Cleaned / revised Shakers class
+- Bug fix in LentPitShift
+- Bug fix in Echo constructor
+- Bug fix in FileWvIn (file size when chunking)
+- Bug fix in StkFrames copy constructor
+
+\subsection v4dot4dot3 Version 4.4.3
+- Changed SINT24 to be lower 3 bytes of 32-bit word.
+- Bug fixes to vectorized tick functions in Effects classes.
+- Updated versions of RtAudio and RtMidi.
+- Bug fixes in ADSR and Envelope classes.
+- Updates to the internal argument checking and reporting scheme.
+- Updates to Bowed class (thanks to Esteban Maestre!).
+- Fixes for 24-bit support in FileRead and FileWrite.
+- Added WAVE_FORMAT_EXTENSIBLE support in FileWrite.
+- Added sample rate variable reading and writing for MAT-files in FileRead and FileWrite.
+
+\subsection v4dot4dot2 Version 4.4.2
+- Added various header file includes for newer compilers.
+- Updates to RtAudio and RtMidi.
+- New LentPitShift class (thanks to Francois Germain).
+- Bug fixes in Voicer class (thanks Richard Dobson!).
+- Added Makefile.in to compile library and all projects, as well as clean and distclean.
+
+\subsection v4dot4dot1 Version 4.4.1
+- Added multi-channel/frame tick() virtual function to WvIn and WvOut abstract base classes (required update to RtWvOut class).
+- Updated configure script to select g++ compiler by default.
+- In demo.cpp: removed voicer grouping for messages, fixing polyphony when messages are on the same MIDI/SKINI channel.
+- Updates to RtAudio and RtMidi.
+
+\subsection v4dot4dot0 Version 4.4.0
+- All classes embedded in the "stk" namespace (except RtAudio, RtMidi, and RtError).
+- Class WaveLoop renamed FileLoop.
+- Significant efficiency improvements via code restructuring and inlining.
+- Some class source (.cpp) files deleted as part of inlining (Generator, Filter, Function, WvIn, WvOut, Effect, Instrmnt, BowTable, ReedTable, JetTable, Vector3D).
+- Updates to RtAudio and RtMidi.
+- Previous "tickFrame()" functions renamed "tick" for more consistent API.
+- More consistent and scalable approach to multichannel data and computations.
+- Multichannel support added to Granulate class.
+- Filter class made abstract.  New Iir and Fir classes made for non-order-specific filtering.
+- New TapDelay class.
+- SubNoise class deleted (same as sub-sampled "ticking" of Noise class).
+
+\subsection v4dot3dot1 Version 4.3.1
+- Further headerless file support in FileRead.
+- Bug fix in RtWvOut.cpp.
+- Added configure support for MinGW.
+- Updates to RtAudio and RtMidi for MinGW.
+- Changes to channel assignment in demo.cpp.
+
+\subsection v4dot3dot0 Version 4.3.0
+- An official MIT-like license.
+- New functionality to automatically update class data when the STK sample rate changes (partly implemented).
+- Updates for new RtAudio version 4.0.
+- Removed RtDuplex class, users should use RtAudio directly with a callback function.
+- Bug fix in interpolate() function in Stk.h for non-interleaved data.
+- Fixes / improvements to the Granulate class.
+- Fix in Whistle when doing animation.
+- Fixes in BlitSquare for frequency, harmonics, and dc offset.
+- Updates to Makefiles for non-realtime compile.
+- Fix in demo.cpp for voice channel assignment.
+- Updated versions of RtMidi and RtAudio.
+- Updated ASIO files for MinGW compiler.
+- New FAQ in documentation.
+- MAT-file bug fix in FileRead class.
 
 \subsection v4dot2dot1 Version 4.2.1
-
-<ul>
-<li>Greatly expanded StkFrames functionality (including interpolation and indexing by channel/frame).</li>
-<li>New Blit, BlitSaw, and BlitSquare bandlimited waveform classes (thanks to Robin Davies!).</li>
-<li>New Granulate granular synthesis class.</li>
-<li>Removed Table class ... all functionality (including interpolation) now in StkFrames and FileRead classes.</li>
-<li>Revised Socket class (now abstract) and added TcpServer, TcpClient, and UdpSocket subclasses.</li>
-<li>Added Stk::showWarnings() and Stk::printErrors() functions to dis/enable warning and error printouts.</li>
-<li>Extracted file I/O functionality to FileRead and FileWrite classes.</li>
-<li>Revised WvIn / WvOut class structure (WvIn / WvOut now abstract and file I/O functionality in new FileWvIn / FileWvOut subclasses).</li>
-<li>New SineWave class which calculates its own static table of variable length (no rawwave dependency).</li>
-<li>New sinewave.raw file of length 1024 samples (used to be 256).</li>
-<li>TcpWvIn and TcpWvOut renamed InetWvIn and InetWvOut, with added support for UDP sockets.</li>
-<li>Fixed bug in WvOut tickFrame( const  StkFrames &frames ) function.</li>
-<li>Fixed bug in demo.cpp when writing output soundfiles without realtime output.</li>
-<li>Added "binary" open flag to MidiFileIn class for Windows.</li>
-<li>Fixed oversized MAT-file header in WvOut.cpp</li>
-<li>Fixed case statement bug in MidiFileIn.cpp for sysex.</li>
-<li>Added missing getDelay() function to DelayA.cpp.</li>
-<li>Fixed modDepth omission in Chorus.cpp.</li>
-<li>Fixed DC blocker initialization bug in Flute.cpp.</li>
-<li>Changed Filter class behavior so no default clearing of state when changing coefficients.</li>
-<li>Fixes to RtAudio, especially for Windows DirectSound and ASIO (thanks to Robin Davies).</li>
-</ul>
+- Greatly expanded StkFrames functionality (including interpolation and indexing by channel/frame).
+- New Blit, BlitSaw, and BlitSquare bandlimited waveform classes (thanks to Robin Davies!).
+- New Granulate granular synthesis class.
+- Removed Table class ... all functionality (including interpolation) now in StkFrames and FileRead classes.
+- Revised Socket class (now abstract) and added TcpServer, TcpClient, and UdpSocket subclasses.
+- Added Stk::showWarnings() and Stk::printErrors() functions to dis/enable warning and error printouts.
+- Extracted file I/O functionality to FileRead and FileWrite classes.
+- Revised WvIn / WvOut class structure (WvIn / WvOut now abstract and file I/O functionality in new FileWvIn / FileWvOut subclasses).
+- New SineWave class which calculates its own static table of variable length (no rawwave dependency).
+- New sinewave.raw file of length 1024 samples (used to be 256).
+- TcpWvIn and TcpWvOut renamed InetWvIn and InetWvOut, with added support for UDP sockets.
+- Fixed bug in WvOut tickFrame( const  StkFrames &frames ) function.
+- Fixed bug in demo.cpp when writing output soundfiles without realtime output.
+- Added "binary" open flag to MidiFileIn class for Windows.
+- Fixed oversized MAT-file header in WvOut.cpp
+- Fixed case statement bug in MidiFileIn.cpp for sysex.
+- Added missing getDelay() function to DelayA.cpp.
+- Fixed modDepth omission in Chorus.cpp.
+- Fixed DC blocker initialization bug in Flute.cpp.
+- Changed Filter class behavior so no default clearing of state when changing coefficients.
+- Fixes to RtAudio, especially for Windows DirectSound and ASIO (thanks to Robin Davies).
 
 \subsection v4dot2dot0 Version 4.2.0
-
-<ul>
-<li>Simultaneous multiple audio APIs supported at compile time.</li>
-<li>Various changes to better conform to standard C++ programming practices.</li>
-<li>Fixed hidden overloaded virtual functions.</li>
-<li>New Asymp exponential envelope class.</li>
-<li><tt>MY_FLOAT</tt> type converted to <tt>StkFloat</tt> and changed throughout (use \c treesed utility to search/replace in old files).</li>
-<li>Most example programs rewritten to use an audio callback paradigm (which works better in OS-X).</li>
-<li>New StkFrames class for vectorized multichannel data and associated new tick() functions making use of StkFrames.</li>
-<li>New RtMidi class with MIDI output capabilities (API changes).</li>
-<li>New MidiFileIn class for reading MIDI files.</li>
-<li>Revised Filter classes to use std::vectors for coefficients (API changes).</li>
-<li>Revised Messager class (API changes).</li>
-<li>New abstract parent Effect class for various effects.</li>
-<li>New abstract parent Generator class for various signal sources.</li>
-<li>New abstract parent Function class for tables and various non-linear functions.</li>
-<li>Skini class completely rewritten (simplified) using the C++ STL (API changes).</li>
-<li>WvOut classes now clip to -1.0 to +1.0 and report out of range.</li>
-<li>New Mutex class.</li>
-<li>Turned Nagle algorithm off by default in Socket class.</li>
-<li>Error reporting standardized in all classes.</li>
-</ul>
+- Simultaneous multiple audio APIs supported at compile time.
+- Various changes to better conform to standard C++ programming practices.
+- Fixed hidden overloaded virtual functions.
+- New Asymp exponential envelope class.
+- <tt>MY_FLOAT</tt> type converted to <tt>StkFloat</tt> and changed throughout (use \c treesed utility to search/replace in old files).
+- Most example programs rewritten to use an audio callback paradigm (which works better in OS-X).
+- New StkFrames class for vectorized multichannel data and associated new tick() functions making use of StkFrames.
+- New RtMidi class with MIDI output capabilities (API changes).
+- New MidiFileIn class for reading MIDI files.
+- Revised Filter classes to use std::vectors for coefficients (API changes).
+- Revised Messager class (API changes).
+- New abstract parent Effect class for various effects.
+- New abstract parent Generator class for various signal sources.
+- New abstract parent Function class for tables and various non-linear functions.
+- Skini class completely rewritten (simplified) using the C++ STL (API changes).
+- WvOut classes now clip to -1.0 to +1.0 and report out of range.
+- New Mutex class.
+- Turned Nagle algorithm off by default in Socket class.
+- Error reporting standardized in all classes.
 
 \subsection v4dot1dot3 Version 4.1.3
-
-<ul>
-<li>Bug fix in RtAudio for Windows DirectSound output only support</li>
-</ul>
+- Bug fix in RtAudio for Windows DirectSound output only support
 
 \subsection v4dot1dot2 Version 4.1.2
-
-<UL>
-<li>Added Linux JACK support to RtAudio.</li>
-<li>Added optional doNormalize argument to WvIn to allow specification of data normalization or not.</li>
-<li>Added volume control to demo program and various tcl scripts.</li>
-<li>Added support for dynamic rawwavePath() setting.</li>
-<li>WaveLoop bug fix.</li>
-<li>Fixed bug in ADSR::setReleaseTime() method.</li>
-<li>Fixed missing initialization of apInput in non-default constructor of DelayA class.</li>
-<li>Added time seeding of random number generator to Noise constructor.</li>
-<li>Update to the contentsAt() method of Delay class.</li>
-<li>WAV file fixes (8-bit) in WvIn and WvOut classes.</li>
-<li>Configure script changes.</li>
-<li>Updated \<iostream\> include statements and appended "std::" as necessary throughout for compatibility with gcc 3.</li>
-</UL>
+- Added Linux JACK support to RtAudio.
+- Added optional doNormalize argument to WvIn to allow specification of data normalization or not.
+- Added volume control to demo program and various tcl scripts.
+- Added support for dynamic rawwavePath() setting.
+- WaveLoop bug fix.
+- Fixed bug in ADSR::setReleaseTime() method.
+- Fixed missing initialization of apInput in non-default constructor of DelayA class.
+- Added time seeding of random number generator to Noise constructor.
+- Update to the contentsAt() method of Delay class.
+- WAV file fixes (8-bit) in WvIn and WvOut classes.
+- Configure script changes.
+- Updated \<iostream\> include statements and appended "std::" as necessary throughout for compatibility with gcc 3.
 
 \subsection v4dot1dot1 Version 4.1.1
-<ul>
-<li>Bug fix in RtAudio for Macintosh OS X and Windows ASIO duplex operation.</li>
-<li>Windows ASIO fix in Stk.h.</li>
-<li>Documentation updates.</li>
-<li>Expanded tutorial.</li>
-<li>Fixed RtDuplex omission in src Makefile.</li>
-</ul>
+- Bug fix in RtAudio for Macintosh OS X and Windows ASIO duplex operation.
+- Windows ASIO fix in Stk.h.
+- Documentation updates.
+- Expanded tutorial.
+- Fixed RtDuplex omission in src Makefile.
 
 \subsection v4dot1 Version 4.1
-
-<UL>
-<LI>Macintosh OS X support added.</LI>
-<LI>New Whistle class.</LI>
-<LI>Added Voicer, SingWave, and VoicForm classes.</LI>
-<LI>Improvements/fixes to the banded waveguide instruments.</LI>
-<LI>Demo program now uses Voicer, allowing polyphony.</LI>
-<LI>Demo tcl/tk scripts changed to use SKINI PitchChange instead of PitchBend.</LI>
-<LI>Demo program response to PitchBend modified to octave up/down.</LI>
-<LI>Several RtAudio fixes and improvements (OS X and Windows ASIO support added).</LI>
-<LI>Added nextOut() method to Delay classes.</LI>
-<LI>Documentation fixes for Reverb classes.</LI>
-<LI>RAWWAVE_PATH changed to include the "rawwave" directory.</LI>
-<LI>"configure" support added for unix systems.</LI>
-<LI>Multivoice flag (-n NUMBER) added as command line option to demo program.</LI>
-<LI>Sample rate flag added as command line option to example programs.</LI>
-<LI>Socket port number added as command line option to example programs.</LI>
-</UL>
+- Macintosh OS X support added.
+- New Whistle class.
+- Added Voicer, SingWave, and VoicForm classes.
+- Improvements/fixes to the banded waveguide instruments.
+- Demo program now uses Voicer, allowing polyphony.
+- Demo tcl/tk scripts changed to use SKINI PitchChange instead of PitchBend.
+- Demo program response to PitchBend modified to octave up/down.
+- Several RtAudio fixes and improvements (OS X and Windows ASIO support added).
+- Added nextOut() method to Delay classes.
+- Documentation fixes for Reverb classes.
+- RAWWAVE_PATH changed to include the "rawwave" directory.
+- "configure" support added for unix systems.
+- Multivoice flag (-n NUMBER) added as command line option to demo program.
+- Sample rate flag added as command line option to example programs.
+- Socket port number added as command line option to example programs.
 
 \subsection v4 Version 4.0
-
-<UL>
-<LI>New documentation and tutorial.</LI>
-<LI>Several new instruments, including Saxofony, BlowBotl, and StifKarp.</LI>
-<LI>New Stk base class, replacing Object class.</LI>
-<LI>New Filter class structure and methods.</LI>
-<LI>Extensive modifications to WvIn and WvOut class structures and methods.</LI>
-<LI>Looping functionality moved to WaveLoop (subclass of WvIn).</LI>
-<LI>Automatic file type detection in WvIn ... hosed WavWvIn, AifWvIn, RawWavIn, SndWavIn, and MatWvIn subclasses.</LI>
-<LI>New file type specifier argument in WvOut ... hosed WavWvOut, AifWvOut, RawWavOut, SndWavOut, and MatWvOut subclasses.</LI>
-<LI>Some simplifications of Messager class (was Controller).</LI>
-<LI>New independent RtAudio class.</LI>
-<LI>Extensive revisions in code and a significant number of API changes.</LI>
-</UL>
+- New documentation and tutorial.
+- Several new instruments, including Saxofony, BlowBotl, and StifKarp.
+- New Stk base class, replacing Object class.
+- New Filter class structure and methods.
+- Extensive modifications to WvIn and WvOut class structures and methods.
+- Looping functionality moved to WaveLoop (subclass of WvIn).
+- Automatic file type detection in WvIn ... hosed WavWvIn, AifWvIn, RawWavIn, SndWavIn, and MatWvIn subclasses.
+- New file type specifier argument in WvOut ... hosed WavWvOut, AifWvOut, RawWavOut, SndWavOut, and MatWvOut subclasses.
+- Some simplifications of Messager class (was Controller).
+- New independent RtAudio class.
+- Extensive revisions in code and a significant number of API changes.
 
 \subsection v3dot2 Version 3.2
-
-<UL>
-<LI>New input control handling class (Controller)</LI>
-<LI>Added AIFF file input/output support.</LI>
-<LI>New C++ error handling capabilities.</LI>
-<LI>New input/output internet streaming support (StrmWvIn/StrmWvOut).</LI>
-<LI>Added native ALSA support for linux.</LI>
-<LI>Added optional "device" argument to all "Rt" classes (audio and MIDI) and printout of devices when argument is invalid.</LI>
-<LI>WvIn classes rewritten to support very big files (incremental load from disk).</LI>
-<LI>Changed WvIn/WvOut classes to work with sample frame buffers.</LI>
-<LI>Fixed looping and negative rate calculations in WvIn classes.</LI>
-<LI>Fixed interpolation bug in RtWvIn.</LI>
-<LI>Windoze RtAudio code rewritten (thank Dave!).</LI>
-<LI>Simplified byte-swapping functions (in-place swapping).</LI>
-<LI>"Stereo-ized" RagaMatic.</LI>
-<LI>Miscellaneous renamings.</LI>
-<LI>Probably a bunch more fixes that I've long since forgotten about.</LI>
-</UL>
+- New input control handling class (Controller)
+- Added AIFF file input/output support.
+- New C++ error handling capabilities.
+- New input/output internet streaming support (StrmWvIn/StrmWvOut).
+- Added native ALSA support for linux.
+- Added optional "device" argument to all "Rt" classes (audio and MIDI) and printout of devices when argument is invalid.
+- WvIn classes rewritten to support very big files (incremental load from disk).
+- Changed WvIn/WvOut classes to work with sample frame buffers.
+- Fixed looping and negative rate calculations in WvIn classes.
+- Fixed interpolation bug in RtWvIn.
+- Windoze RtAudio code rewritten (thank Dave!).
+- Simplified byte-swapping functions (in-place swapping).
+- "Stereo-ized" RagaMatic.
+- Miscellaneous renamings.
+- Probably a bunch more fixes that I've long since forgotten about.
 
 \subsection v3dot1 Version 3.1
-
-<UL>
-<LI>New RagaMatic project ... very cool!!!</LI>
-<LI>Less clipping in the Shakers class.</LI>
-<LI>Added "microphone position" to Mandolin in STKdemo.</LI>
-<LI>Fixed MIDI system message exclusion under Irix.</LI>
-<LI>Added a few bitmaps for the Shaker instruments.</LI>
-<LI>Made destructors virtual for Reverb.h, WvIn.h and Simple.h.</LI>
-<LI>Fixed bug setting delay length in DLineA when value too big.</LI>
-<LI>Fixed bug in WinMM realtime code (RTSoundIO).</LI>
-<LI>Added tick() method to BowTabl, JetTabl, and ReedTabl (same as lookup).</LI>
-<LI>Switched to pthread API on SGI platforms.</LI>
-<LI>Added some defines to Object.h for random number generation, FPU overflow checking, etc....</LI>
-<LI>A few minor changes, some bug fixes ... can't remember all of them.</LI>
-</UL>
+- New RagaMatic project ... very cool!!!
+- Less clipping in the Shakers class.
+- Added "microphone position" to Mandolin in STKdemo.
+- Fixed MIDI system message exclusion under Irix.
+- Added a few bitmaps for the Shaker instruments.
+- Made destructors virtual for Reverb.h, WvIn.h and Simple.h.
+- Fixed bug setting delay length in DLineA when value too big.
+- Fixed bug in WinMM realtime code (RTSoundIO).
+- Added tick() method to BowTabl, JetTabl, and ReedTabl (same as lookup).
+- Switched to pthread API on SGI platforms.
+- Added some defines to Object.h for random number generation, FPU overflow checking, etc....
+- A few minor changes, some bug fixes ... can't remember all of them.
 
 \subsection v3 Version 3.0
-
-<UL>
-<LI>New #define flags for OS and realtime dependencies (this will probably cause problems for old personal STK code, but it was necessary to make future ports easier).</LI>
-<LI>Expanded and cleaned the Shakers class.</LI>
-<LI>New BowedBar algorithm/class.</LI>
-<LI>Fixed Linux MIDI input bug.</LI>
-<LI>Fixed MIDI status masking problem in Windows.</LI>
-<LI>OS type defines now in Makefile.</LI>
-<LI>New RAWWAVE_PATH define in Object.h.</LI>
-<LI>Syntmono project pulled out to separate directory and cleaned up.</LI>
-<LI>Socketing capabilities under Unix, as well as Windoze.</LI>
-<LI>Multiple simultaneous socket client connections to STK servers now possible.</LI>
-<LI>MD2SKINI now can merge MIDI and piped messages under Irix and Linux (for TCL->MD2SKINI->syntmono control).</LI>
-<LI>Defined INT16 and INT32 types and fixed various WvIn and WvOut classes.</LI>
-<LI>Updated MatWvIn and MatWvOut for new MAT-file documentation from Matlab.</LI>
-<LI>New demo Tcl/Tk GUI (TclDemo.tcl).</LI>
-<LI>Minor fixes to FM behavior.</LI>
-<LI>Added record/duplex capabilities to RTSoundIO (Linux, SGI, and Windoze).</LI>
-<LI>Fixed bugs in WavWvOut and MatWvOut header specifications.</LI>
-<LI>Added RawWvOut class.</LI>
-<LI>New WvIn class with RawWvIn, SndWvIn, WavWvIn, MatWvIn, and RTWvIn subclasses.</LI>
-<LI>Removed RawWave, RawShot, RawInterp, and RawLoop classes (supplanted by RawWvIn).</LI>
-<LI>Multi-channel data support in WvIn and WvOut classes using MY_MULTI data type (pointer to StkFloat) and the methods mtick() and mlastOutput().</LI>
-<LI>Now writing to primary buffer under Windoze when allowed by hardware.</LI>
-<LI>Cleaned up Object.h a bit.</LI>
-<LI>Pulled various utility and thread functions out of syntmono.cpp (to aid readability of the code).</LI>
-</UL>
+- New #define flags for OS and realtime dependencies (this will probably cause problems for old personal STK code, but it was necessary to make future ports easier).
+- Expanded and cleaned the Shakers class.
+- New BowedBar algorithm/class.
+- Fixed Linux MIDI input bug.
+- Fixed MIDI status masking problem in Windows.
+- OS type defines now in Makefile.
+- New RAWWAVE_PATH define in Object.h.
+- Syntmono project pulled out to separate directory and cleaned up.
+- Socketing capabilities under Unix, as well as Windoze.
+- Multiple simultaneous socket client connections to STK servers now possible.
+- MD2SKINI now can merge MIDI and piped messages under Irix and Linux (for TCL->MD2SKINI->syntmono control).
+- Defined INT16 and INT32 types and fixed various WvIn and WvOut classes.
+- Updated MatWvIn and MatWvOut for new MAT-file documentation from Matlab.
+- New demo Tcl/Tk GUI (TclDemo.tcl).
+- Minor fixes to FM behavior.
+- Added record/duplex capabilities to RTSoundIO (Linux, SGI, and Windoze).
+- Fixed bugs in WavWvOut and MatWvOut header specifications.
+- Added RawWvOut class.
+- New WvIn class with RawWvIn, SndWvIn, WavWvIn, MatWvIn, and RTWvIn subclasses.
+- Removed RawWave, RawShot, RawInterp, and RawLoop classes (supplanted by RawWvIn).
+- Multi-channel data support in WvIn and WvOut classes using MY_MULTI data type (pointer to StkFloat) and the methods mtick() and mlastOutput().
+- Now writing to primary buffer under Windoze when allowed by hardware.
+- Cleaned up Object.h a bit.
+- Pulled various utility and thread functions out of syntmono.cpp (to aid readability of the code).
 
 \subsection v2dot02 Version 2.02
-
-<UL>
-<LI>Created RawWave abstract class, with subclasses of RawLoop (looping rawwave oscillator), RawShot (non-looping, non-interpolating rawwave player ... used to be RawWvIn), and RawInterp (looping or non-looping, interpolating rawwave player ... used to be RawWave).</LI>
-<LI>Modified DrumSynt to correctly handle sample rates different than 22050 Hz.</LI>
-<LI>Modified syntmono parsing vs. tick routine so that some ticking occurs between each message.  When multiple messages are waiting to be processed, the time between message updates is inversely proportional to the number of messages in the buffer.</LI>
-<LI>Fixed DirectSound playback bug in WinXX distribution.  Sound was being played at 8-bit, 22 kHz in all cases.  Playback is now 16-bit and dependent on SRATE.</LI>
-<LI>Fixed bug in MD2SKINI which prevented some NoteOff statements from being output.</LI>
-<LI>This distribution includes an example STK project, mus151, which demonstrates a means for keeping a user's personal projects separate from the main distribution.  This is highly recommended, in order to simplify upgrades to future STK releases.</LI>
-</UL>
+- Created RawWave abstract class, with subclasses of RawLoop (looping rawwave oscillator), RawShot (non-looping, non-interpolating rawwave player ... used to be RawWvIn), and RawInterp (looping or non-looping, interpolating rawwave player ... used to be RawWave).
+- Modified DrumSynt to correctly handle sample rates different than 22050 Hz.
+- Modified syntmono parsing vs. tick routine so that some ticking occurs between each message.  When multiple messages are waiting to be processed, the time between message updates is inversely proportional to the number of messages in the buffer.
+- Fixed DirectSound playback bug in WinXX distribution.  Sound was being played at 8-bit, 22 kHz in all cases.  Playback is now 16-bit and dependent on SRATE.
+- Fixed bug in MD2SKINI which prevented some NoteOff statements from being output.
+- This distribution includes an example STK project, mus151, which demonstrates a means for keeping a user's personal projects separate from the main distribution.  This is highly recommended, in order to simplify upgrades to future STK releases.
 
 \subsection v2 Version 2
-
-<UL>
-<LI>Unification of the capabilities of STK across the various platforms.  All of the previous SGI functionality has been ported to Linux and Windows, including realtime sound output and MIDI input.</LI>
-<LI>MIDI input (with optional time-stamping) supported on SGI, Linux (OSS device drivers only), and Windows operating systems.  Time stamping under IRIX and Windows is quantized to milliseconds and under Linux to hundredths of a second.</LI>
-<LI>Various Sound Output Options - .wav, .snd, and .mat (Matlab MAT-file) soundfile outputs are supported on all operating systems.  I hacked out the MAT-file structure, so you don't have to include any platform-specific libraries.  Realtime sound output is provided as well, except under NeXTStep.</LI>
-<LI>Multiple Reverberator Implementations - Reverb subclasses of JCRev and NRev (popular reverberator implementations from CCRMA) have been written.  Perry's original reverb implementation still exists as PRCRev.  All reverberators now take a T60 initializer argument.</LI>
-<LI>MD2SKINI - A program which parses a MIDI input stream and spits out SKINI code.  The output of MD2SKINI is typically piped into an STK instrument executable (eg. <tt>MD2SKINI | syntmono Clarinet -r -i</tt>).  In addition, you can supply a filename argument to MD2SKINI and have it simultaneously record a SKINI score file for future reuse.</LI>
-<LI>Modifications to <I>Object.h</I> for OS_TYPE compilation dependencies.  <I>Makefile</I> automatically determines OS_TYPE when invoked (if you have the GNU makefile utilities installed on your system).</LI>
-<LI>A single distribution for all platforms.  The Unix and Windows versions have been merged into a single set of classes.  Makefiles and Visual C++ workspace/project files are provided for compiling.</LI>
-</UL>
+- Unification of the capabilities of STK across the various platforms.  All of the previous SGI functionality has been ported to Linux and Windows, including realtime sound output and MIDI input.
+- MIDI input (with optional time-stamping) supported on SGI, Linux (OSS device drivers only), and Windows operating systems.  Time stamping under IRIX and Windows is quantized to milliseconds and under Linux to hundredths of a second.
+- Various Sound Output Options - .wav, .snd, and .mat (Matlab MAT-file) soundfile outputs are supported on all operating systems.  I hacked out the MAT-file structure, so you don't have to include any platform-specific libraries.  Realtime sound output is provided as well, except under NeXTStep.
+- Multiple Reverberator Implementations - Reverb subclasses of JCRev and NRev (popular reverberator implementations from CCRMA) have been written.  Perry's original reverb implementation still exists as PRCRev.  All reverberators now take a T60 initializer argument.
+- MD2SKINI - A program which parses a MIDI input stream and spits out SKINI code.  The output of MD2SKINI is typically piped into an STK instrument executable (eg. <tt>MD2SKINI | syntmono Clarinet -r -i</tt>).  In addition, you can supply a filename argument to MD2SKINI and have it simultaneously record a SKINI score file for future reuse.
+- Modifications to <I>Object.h</I> for OS_TYPE compilation dependencies.  <I>Makefile</I> automatically determines OS_TYPE when invoked (if you have the GNU makefile utilities installed on your system).
+- A single distribution for all platforms.  The Unix and Windows versions have been merged into a single set of classes.  Makefiles and Visual C++ workspace/project files are provided for compiling.
 
 */

doc/doxygen/faq.txt

@@ -0,0 +1,80 @@
+/*! \page faq Frequently Asked Questions
+
+- \ref license
+- \ref filerate
+- \ref endianness
+- \ref xwindows
+
+\section license Does STK have a license?
+
+Yes, we finally made something official for release 4.3.0.  It is listed in the Stk class and a few other places in the distribution, but I'll repeat it here for clarity:
+
+\verbatim
+The Synthesis ToolKit in C++ (STK) is a set of open source audio
+signal processing and algorithmic synthesis classes written in the
+C++ programming language. STK was designed to facilitate rapid
+development of music synthesis and audio processing software, with
+an emphasis on cross-platform functionality, realtime control,
+ease of use, and educational example code.  STK currently runs
+with realtime support (audio and MIDI) on Linux, Macintosh OS X,
+and Windows computer platforms. Generic, non-realtime support has
+been tested under NeXTStep, Sun, and other platforms and should
+work with any standard C++ compiler.
+
+STK WWW site: http://ccrma.stanford.edu/software/stk/
+
+The Synthesis ToolKit in C++ (STK)
+Copyright (c) 1995--2016 Perry R. Cook and Gary P. Scavone
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+Any person wishing to distribute modifications to the Software is
+asked to send the modifications to the original developer so that they
+can be incorporated into the canonical version.  This is, however, not
+a binding provision of this license.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+\endverbatim
+
+\section filerate Why is my file sample rate wrong?
+
+When the FileWvIn class loads a soundfile, it automatically sets its internal read increment based on the soundfile rate and the current STK sample rate.  For example, if the current STK sample rate is 44100 Hz and the soundfile rate is 22050 Hz, the read increment, or rate, will be set to 0.5 and the file will be interpolated so that is sounds correct at 44100 Hz.  For most cases, this works fine.  However, consider the following example:
+
+\code
+FileWvIn input( "infile" );                 // read an input soundfile
+StkFloat sampleRate = input.getFileRate();
+Stk::setSampleRate( sampleRate );           // set a new STK sample rate based on the file rate
+\endcode
+
+With version 4.3 and higher of STK, the FileWvIn class will be notified of a sample rate change and it will automatically adjust its read rate accordingly.  Previous versions of STK did not perform this change and thus, the read rate could end up being incorrect.  If you do not want FileWvIn to perform this automatic adjustment, you can call the \c ignoreSampleRateChange() function for a given class instance.
+
+\section endianness Why does the sound I generated with STK sound like *&#@!?
+
+If the resultant sound generated by an STK program sounds like noise (and you're not doing an MLS experiment), the problem is likely related to the byte "endianness" of your computer.  By default, STK assumes "big endian" byte order.  If you are working with STK classes on a PC (Windows or Linux), you \e must define the <TT>__LITTLE_ENDIAN__</TT> preprocessor definition \e before compiling.  If after reading this you realize you need to make this change, do not forget to recompile all STK classes from scratch.
+
+\section xwindows Why do I get a Tk display error message?
+
+The following error may be printed to your terminal window (depending on the version of the tcl/tk interpreter you are running) if you attempt to start an STK tcl/tk interface without the X Server first running:
+
+\code
+Application initialization failed: this isn't a Tk applicationcouldn't connect to display ":0.0"
+\endcode
+
+Simply start your X server and then try the command again.
+
+*/

doc/doxygen/filtering.txt

@@ -1,9 +1,10 @@
 /*! \page filtering Using Filters
 
-In this section, we demonstrate the use of a few of the STK filter classes.  The Filter class provides functionality to implement a generalized digital filter of any type, similar to the \c filter function in Matlab.  In this example, we create a Filter instance and initialize it with specific numerator and denominator coefficients.  We then compute its impulse response for 20 samples.
+In this section, we demonstrate the use of a few of the STK filter classes.  The stk::Iir class provides functionality to implement a generalized infinite impulse response (IIR) digital filter, similar to the \c filter function in Matlab.  In this example, we create an stk::Iir instance and initialize it with specific numerator and denominator coefficients.  We then compute its impulse response for 20 samples.
 
 \code
-#include "Filter.h"
+#include "Iir.h"
+using namespace stk;
 
 int main()
 {
@@ -16,7 +17,7 @@ int main()
   denominator.push_back( 0.3 );
   denominator.push_back( -0.5 );
 
-  Filter filter( numerator, denominator );
+  Iir filter( numerator, denominator );
 
   filter.tick( output );
   for ( unsigned int i=0; i<output.size(); i++ ) {
@@ -27,22 +28,23 @@ int main()
 }
 \endcode
 
-The Filter class implements the standard difference equation
+The stk::Iir class implements the standard difference equation
 \code
  a[0]*y[n] = b[0]*x[n] + ... + b[nb]*x[n-nb] - a[1]*y[n-1] - ... - a[na]*y[n-na],
 \endcode
 
-where "b" values are numerator coefficients and "a" values are denominator coefficients.  Note that if the first denominator coefficient is not 1.0, the Filter class automatically normalizes all filter coefficients by that value.  The coefficient values are passed to the Filter class via a C++ <a href="http://www.roguewave.com/support/docs/sourcepro/stdlibref/vector.html">vector</a>, a container object provided by the C++ Standard Library.
+where "b" values are numerator coefficients and "a" values are denominator coefficients.  Note that if the first denominator coefficient is not 1.0, the Iir class automatically normalizes all filter coefficients by that value.  The coefficient values are passed to the Iir class via a C++ <a href="http://www.roguewave.com/support/docs/sourcepro/stdlibref/vector.html">vector</a>, a container object provided by the C++ Standard Library.
 
-Most STK classes use more specific types of digital filters, such as the OneZero, OnePole, TwoPole, or BiQuad varieties.  These classes inherit from the Filter class and provide specific functionality particular to their use, as well as functions to independently control individual coefficient values.
+Most STK classes use more specific types of digital filters, such as the stk::OneZero, stk::OnePole, stk::TwoPole, or stk::BiQuad varieties.  These classes inherit from the stk::Filter abstract base class and provide specific functionality particular to their use, as well as functions to independently control individual coefficient values.
 
 \section reson Resonances:
 
-The STK BiQuad and TwoPole classes provide functionality for creating resonance filters.  The following example demonstrates how to create a resonance centered at 440 Hz that is used to filter the output of a Noise generator.
+The STK stk::BiQuad and stk::TwoPole classes provide functionality for creating resonance filters.  The following example demonstrates how to create a resonance centered at 440 Hz that is used to filter the output of a stk::Noise generator.
 
 \code
 #include "BiQuad.h"
 #include "Noise.h"
+using namespace stk;
 
 int main()
 {
@@ -61,11 +63,12 @@ int main()
 }
 \endcode
 
-By passing a boolian value of \c true as the third argument to the BiQuad::setResonance() function, the filter coefficients are automatically scaled to achieve unity gain at the resonance peak frequency.  The previous code could be easily modified for "vector-based" calculations:
+By passing a boolian value of \c true as the third argument to the stk::BiQuad::setResonance() function, the filter coefficients are automatically scaled to achieve unity gain at the resonance peak frequency.  The previous code could be easily modified for "vector-based" calculations:
 
 \code
 #include "BiQuad.h"
 #include "Noise.h"
+using namespace stk;
 
 int main()
 {

doc/doxygen/footer.html

@@ -2,7 +2,7 @@
 
 <table>
   <tr><td><A HREF="http://ccrma.stanford.edu/software/stk/"><I>The Synthesis ToolKit in C++ (STK)</I></A></td></tr>
-  <tr><td>&copy;1995-2005 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
+  <tr><td>&copy;1995--2016 Perry R. Cook and Gary P. Scavone. All Rights Reserved.</td></tr>
 </table>
 
 </BODY>

doc/doxygen/fundamentals.txt

@@ -1,15 +1,16 @@
 /*! \page fundamentals STK Fundamentals
 
-The Synthesis ToolKit is implemented in the C++ programming language.  STK does not attempt to provide a new programming environment or paradigm but rather provides a set of objects which can be used within a normal C++ programming framework.  Therefore, it is expected that users of STK will have some familiarity with C/C++ programming concepts.  That said, the STK classes do have some particular idiosyncrasies that we will mention here.
+The Synthesis ToolKit is implemented in the C++ programming language.  STK does not attempt to provide a new programming environment or paradigm but rather provides a set of objects that can be used within a normal C++ programming framework.  Therefore, it is expected that users of STK will have some familiarity with C/C++ programming concepts.  That said, the STK classes do have some particular idiosyncrasies that we will mention here.  Starting with STK version 4.4, all STK classes except RtAudio and RtMidi are defined within the stk namespace.
 
 \section Signal Computations:
 
 Audio and control signals throughout STK use a floating-point data type, <tt>StkFloat</tt>, the exact precision of which can be controlled via a typedef statement in Stk.h.  By default, an StkFloat is a double-precision floating-point value.  Thus, the ToolKit can use any normalization scheme desired. The base instruments and algorithms are implemented with a general audio sample dynamic maximum of +/-1.0.
 
-In general, the computation and/or passing of values is performed on a "single-sample" basis.  For example, the Noise class outputs random floating-point numbers in the range +/-1.0.  The computation of such values occurs in the Noise::tick() function.  The following program will generate 20 random floating-point (<tt>StkFloat</tt>) values in the range -1.0 to +1.0:
+In general, the computation and/or passing of values is performed on a "single-sample" basis.  For example, the stk::Noise class outputs random floating-point numbers in the range +/-1.0.  The computation of such values occurs in the stk::Noise::tick() function.  The following program will generate 20 random floating-point (<tt>StkFloat</tt>) values in the range -1.0 to +1.0:
 
 \code
 #include "Noise.h"
+using namespace stk;
 
 int main()
 {
@@ -25,10 +26,11 @@ int main()
 }
 \endcode
 
-Nearly all STK classes implement <TT>tick()</TT> functions that take and/or return sample values. Within the <TT>tick()</TT> function, the fundamental sample calculations are performed for a given class.  Most STK classes consume/generate a single sample per operation and their <TT>tick()</TT> method takes/returns each sample "by value".  In addition, every class implementing a <TT>tick()</TT> function also provides one or more overloaded <TT>tick()</TT> functions which can be used for vectorized computations, as shown in the next example.
+Nearly all STK classes implement <TT>tick()</TT> functions that take and/or return sample values. Within the <TT>tick()</TT> function, the fundamental sample calculations are performed for a given class.  Most STK classes consume/generate a single sample per operation and their <TT>tick()</TT> method takes/returns each sample "by value".  In addition, every class implementing a <TT>tick()</TT> function also provides one or more overloaded <TT>tick()</TT> functions that can be used for vectorized computations, as shown in the next example.
 
 \code
 #include "Noise.h"
+using namespace stk;
 
 int main()
 {
@@ -44,19 +46,19 @@ int main()
 }
 \endcode
 
-In this way, it might be possible to achieve improved processing efficiency using vectorized computations.  The StkFrames class is a relatively new addition to the ToolKit to provide a general "mechanism" for handling and passing vectorized, multi-channel audio data.  The StkFrames "type" provides functions to set and/or determine the number of audio channels and sample frames it holds, as well as the format (interleaved or non-interleaved) of its data.  Further, the StkFrames class provides data interpolation and subscripting functionality by frame/channel values.
+In this way, it might be possible to achieve improved processing efficiency using vectorized computations.  The StkFrames class is a relatively new addition to the ToolKit to provide a general "mechanism" for handling and passing vectorized, multi-channel audio data.  The StkFrames "type" provides functions to set and/or determine the number of audio channels and sample frames it holds.  Further, the StkFrames class provides data interpolation and subscripting functionality by frame/channel values.
 
 \section STK Inheritance:
 
-Nearly all STK classes inherit from the Stk abstract base class, which provides common functionality related to error reporting, sample rate control, and byte swapping.  Several other base classes exist which roughly group many of the classes according to function as follows:
+Nearly all STK classes inherit from the Stk abstract base class, which provides common functionality related to error reporting, sample rate control, and byte swapping.  Several other base classes exist that roughly group many of the classes according to function as follows:
 
-- Generator: source signal unit generator classes [Envelope, ADSR, Asymp, Noise, SubNoise, Modulate, SingWave, SineWave Blit, BlitSaw, BlitSquare, Granulate]
-- Filter: digital filtering classes [OneZero, OnePole, PoleZero, TwoZero, TwoPole, BiQuad, FormSwep, Delay, DelayL, DelayA]
-- Function: input to output function mappings [BowTable, JetTable, ReedTable]
-- Instrmnt: sound synthesis algorithms, including physical, FM, modal, and particle models
-- Effect: sound processing effect classes [Echo, Chorus, PitShift, PRCRev, JCRev, NRev]
-- WvOut: audio data output classes [FileWvOut, RtWvOut, InetWvOut]
-- WvIn: audio data input classes [FileWvIn, WaveLoop, RtWvIn, InetWvIn]
+- stk::Generator: source signal unit generator classes [stk::Envelope, stk::ADSR, stk::Asymp, stk::Noise, stk::SubNoise, stk::Modulate, stk::SingWave, stk::SineWave, stk::Blit, stk::BlitSaw, stk::BlitSquare, stk::Granulate]
+- stk::Filter: digital filtering classes [stk::OneZero, stk::OnePole, stk::PoleZero, stk::TwoZero, stk::TwoPole, stk::BiQuad, stk::FormSwep, stk::Delay, stk::DelayL, stk::DelayA, stk::TapDelay]
+- stk::Function: input to output function mappings [stk::BowTable, stk::JetTable, stk::ReedTable]
+- stk::Instrmnt: sound synthesis algorithms, including physical, FM, modal, and particle models
+- stk::Effect: sound processing effect classes [stk::Echo, stk::Chorus, stk::PitShift, stk::PRCRev, stk::JCRev, stk::NRev]
+- stk::WvOut: audio data output classes [stk::FileWvOut, stk::RtWvOut, stk::InetWvOut]
+- stk::WvIn: audio data input classes [stk::FileWvIn, stk::FileLoop, stk::RtWvIn, stk::InetWvIn]
 
 
 [<A HREF="tutorial.html">Main tutorial page</A>] &nbsp; [<A HREF="hello.html">Next tutorial</A>] 

doc/doxygen/header.html

@@ -6,5 +6,5 @@
 <BODY BGCOLOR="#FFFFFF">
 <CENTER>
 <img src="princeton.gif"> &nbsp; <img src="ccrma.gif"> &nbsp; <img src="mcgill.gif"><P>
-<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
+<a class="qindex" href="index.html">Home</a> &nbsp; <a class="qindex" href="information.html">Information</a> &nbsp; <a class="qindex" href="classes.html">Classes</a> &nbsp; <a class="qindex" href="download.html">Download</a> &nbsp; <a class="qindex" href="usage.html">Usage</a> &nbsp; <a class="qindex" href="maillist.html">Mail List</a> &nbsp; <a class="qindex" href="system.html">Requirements</a> &nbsp; <a class="qindex" href="links.html">Links</a> &nbsp; <a class="qindex" href="faq.html">FAQ</a> &nbsp; <a class="qindex" href="tutorial.html">Tutorial</a></CENTER>
 <HR>

doc/doxygen/header.tex

@@ -19,13 +19,13 @@
 \vspace*{1cm}
 {\large by Perry R. Cook and Gary P. Scavone}\\
 \vspace*{0.5cm}
-{\small \copyright 1995--2002}\\
+{\small \copyright 1995--2007}\\
 \end{center}
 \end{titlepage}
 \clearemptydoublepage
 \pagenumbering{roman}
-\rfoot[\fancyplain{}{\bfseries\scriptsize The Synthesis ToolKit in C++ by Perry R. Cook and Gary P. Scavone, \copyright~1995--2002}]{}
-\lfoot[]{\fancyplain{}{\bfseries\scriptsize The Synthesis ToolKit in C++ by Perry R. Cook and Gary P. Scavone, \copyright~1995--2002}}
+\rfoot[\fancyplain{}{\bfseries\scriptsize The Synthesis ToolKit in C++ by Perry R. Cook and Gary P. Scavone, \copyright~1995--2007}]{}
+\lfoot[]{\fancyplain{}{\bfseries\scriptsize The Synthesis ToolKit in C++ by Perry R. Cook and Gary P. Scavone, \copyright~1995--2007}}
 \tableofcontents
 \clearemptydoublepage
 \pagenumbering{arabic}

doc/doxygen/hello.txt

@@ -3,24 +3,25 @@
 We'll continue our introduction to the Synthesis ToolKit with a simple
 sine-wave oscillator program.  STK provides two different classes for
 sine-wave generation.  We will first look at a generic waveform
-oscillator class, WaveLoop, that can load a variety of common file
+oscillator class, stk::FileLoop, that can load a variety of common file
 types.  In this example, we load a sine "table" from an STK RAW file
 (defined as monophonic, 16-bit, big-endian data).  We use the class
-FileWvOut to write the result to a 16-bit, WAV formatted audio file.
+stk::FileWvOut to write the result to a 16-bit, WAV formatted audio file.
 
 \code
 
 // sineosc.cpp
 
-#include "WaveLoop.h"
+#include "FileLoop.h"
 #include "FileWvOut.h"
+using namespace stk;
 
 int main()
 {
   // Set the global sample rate before creating class instances.
   Stk::setSampleRate( 44100.0 );
 
-  WaveLoop input;
+  FileLoop input;
   FileWvOut output;
 
   // Load the sine wave file.
@@ -39,29 +40,37 @@ int main()
 }
 \endcode
 
-WaveLoop is a subclass of FileWvIn, which supports WAV, SND (AU),
-AIFF, MAT-file (Matlab), and RAW file formats with 8-, 16-, and 32-bit
-integer and 32- and 64-bit floating-point data types.  FileWvIn
-provides interpolating, read-once ("oneshot") functionality, as well
-as methods for setting the read rate and read position.
+stk::FileLoop is a subclass of stk::FileWvIn, which supports WAV, SND
+(AU), AIFF, MAT-file (Matlab), and RAW file formats with 8-, 16-, and
+32-bit integer and 32- and 64-bit floating-point data types.
+stk::FileWvIn provides interpolating, read-once ("oneshot")
+functionality, as well as methods for setting the read rate and read
+position.
 
-FileWvIn provides a "tick level" and interpolating interface to the
-FileRead class.  Likewise, FileWvOut provides a "tick level" interface
-to the FileWrite class.  FileRead and FileWrite both support WAV,
-SND(AU), AIFF, MAT-file (Matlab), and RAW file formats with 8-, 16-,
-and 32-bit integer and 32- and 64-bit floating-point data types.
-FileWvOut does not currently offer data interpolation functionality.
+stk::FileWvIn provides a "tick level" and interpolating interface to
+the stk::FileRead class.  Likewise, stk::FileWvOut provides a "tick
+level" interface to the stk::FileWrite class.  stk::FileRead and
+FileWrite both support WAV, SND(AU), AIFF, MAT-file (Matlab), and RAW
+file formats with 8-, 16-, and 32-bit integer and 32- and 64-bit
+floating-point data types.  stk::FileWvOut does not currently offer
+data interpolation functionality.
 
-The WvIn and WvOut parent classes and all subclasses support
-multi-channel sample frames.  To distinguish single-sample frame
-operations from multi-channel frame operations, these classes also
-implement <TT>tickFrame()</TT> functions.  When a <TT>tick()</TT>
-method is called for multi-channel data, frame averages are returned
-or the input sample is distributed across all channels of a sample
-frame.
+A number of STK parent classes, including stk::WvIn, stk::WvOut,
+stk::Instrmnt, stk::Generator, and stk::Effect, (and some or all of
+their subclasses) support multi-channel sample frames.  If a
+single-sample version of the <TT>tick()</TT> function is called for
+these classes, a full sample frame is computed but only a single value
+is either input and/or output.  For example, if the single-sample
+<TT>tick()</TT> function is called for subclasses of stk::WvOut, the
+sample argument is written to all channels in the one computed frame.
+For classes returning values, an optional \c channel argument
+specifies which channel value is returned from the computed frame (the
+default is always channel 0). To input and/or output multichannel data
+to these classes, the overloaded <TT>tick()</TT> functions taking
+StkFrames reference arguments should be used.
 
-Nearly all STK classes inherit from the Stk base class.  Stk provides
-a static sample rate which is queried by subclasses as needed.
+Nearly all STK classes inherit from the stk::Stk base class.  Stk
+provides a static sample rate that is queried by subclasses as needed.
 Because many classes use the current sample rate value during
 instantiation, it is important that the desired value be set at the
 beginning of a program.  The default STK sample rate is 44100 Hz.
@@ -75,7 +84,11 @@ rewritten as shown below.
 
 \include sineosc.cpp
 
-In this particular case, we simply exit the program if an error occurs (an error message is automatically printed to stderr).  A more refined program might attempt to recover from or fix a particular problem and, if successful, continue processing.  See the \ref classes to determine which constructors and functions can throw an error.
+In this particular case, we simply exit the program if an error occurs
+(an error message is automatically printed to stderr).  A more refined
+program might attempt to recover from or fix a particular problem and,
+if successful, continue processing.  See the \ref classes to determine
+which constructors and functions can throw an error.
 
 [<A HREF="fundamentals.html">Main tutorial page</A>] &nbsp; [<A HREF="compile.html">Next tutorial</A>]
 */

doc/doxygen/index.txt

@@ -1,4 +1,4 @@
-/*! \mainpage <I>The Synthesis ToolKit in C++ (STK)</I>
+/*! \mainpage The Synthesis ToolKit in C++ (STK)
 
 \htmlonly
 <BODY BGCOLOR="white">
@@ -15,11 +15,11 @@ portable (it's mostly platform-independent C and C++ code), and it's
 completely user-extensible (all source included, no unusual libraries,
 and no hidden drivers).  We like to think that this increases the
 chances that our programs will still work in another 5-10 years.  In
-fact, the ToolKit has been working continuously for about 10 years
-now.  STK currently runs with "realtime" support (audio and MIDI) on
-SGI (Irix), Linux, Macintosh OS X, and Windows computer platforms.
-Generic, non-realtime support has been tested under NeXTStep, Sun, and
-other platforms and should work with any standard C++ compiler.
+fact, the ToolKit has been working continuously for nearly 20 years
+now.  STK currently runs with realtime support (audio and MIDI) on
+Linux, Macintosh OS X, and Windows computer platforms.  Generic,
+non-realtime support has been tested under NeXTStep, Sun, and other
+platforms and should work with any standard C++ compiler.
 
 - \ref information
 - \ref classes
@@ -28,6 +28,7 @@ other platforms and should work with any standard C++ compiler.
 - \ref maillist
 - \ref system
 - \ref links
+- \ref faq
 - \ref tutorial
 
 */

doc/doxygen/information.txt

@@ -18,16 +18,16 @@ Here's a link to a book that includes an chapter on STK.
 
 <H4>What is the <I>Synthesis ToolKit</I>?</H4>
 
-The Synthesis ToolKit in C++ (STK) is a set of open source audio signal processing and algorithmic synthesis classes written in the C++ programming language.  STK was designed to facilitate rapid development of music synthesis and audio processing software, with an emphasis on cross-platform functionality, realtime control, ease of use, and educational example code.  The Synthesis ToolKit is extremely portable (it's mostly platform-independent C and C++ code), and it's completely user-extensible (all source included, no unusual libraries, and no hidden drivers).  We like to think that this increases the chances that our programs will still work in another 5-10 years.  In fact, the ToolKit has been working continuously for nearly 10 years now.  STK currently runs with "realtime" support (audio and MIDI) on SGI (Irix), Linux, Macintosh OS X, and Windows computer platforms.  Generic, non-realtime support has been tested under NeXTStep, Sun, and other platforms and should work with any standard C++ compiler.
+The Synthesis ToolKit in C++ (STK) is a set of open source audio signal processing and algorithmic synthesis classes written in the C++ programming language.  STK was designed to facilitate rapid development of music synthesis and audio processing software, with an emphasis on cross-platform functionality, realtime control, ease of use, and educational example code.  The Synthesis ToolKit is extremely portable (it's mostly platform-independent C and C++ code), and it's completely user-extensible (all source included, no unusual libraries, and no hidden drivers).  We like to think that this increases the chances that our programs will still work in another 5-10 years.  In fact, the ToolKit has been working continuously for nearly 20 years now.  STK currently runs with realtime support (audio and MIDI) on Linux, Macintosh OS X, and Windows computer platforms.  Generic, non-realtime support has been tested under NeXTStep, Sun, and other platforms and should work with any standard C++ compiler.
 
-The Synthesis ToolKit is free for non-commercial use.  The only parts of the Synthesis ToolKit that are platform-dependent concern real-time audio and MIDI input and output, and that is taken care of with a few special classes.  The interface for MIDI input and the simple <A HREF="http://dev.scriptics.com">Tcl/Tk</A> graphical user interfaces (GUIs) provided is the same, so it's easy to experiment in real time using either the GUIs or MIDI.  The Synthesis ToolKit can generate simultaneous SND (AU), WAV, AIFF, and MAT-file output soundfile formats (as well as realtime sound output), so you can view your results using one of a large variety of sound/signal analysis tools already available (e.g. <A HREF="http://www-ccrma.stanford.edu/software/snd/">Snd</A>, Cool Edit, Matlab). 
+The Synthesis ToolKit is free.  The only parts of the Synthesis ToolKit that are platform-dependent concern real-time audio and MIDI input and output, and that is taken care of with a few special classes.  The interface for MIDI input and the simple <A HREF="http://dev.scriptics.com">Tcl/Tk</A> graphical user interfaces (GUIs) provided is the same, so it's easy to experiment in real time using either the GUIs or MIDI.  The Synthesis ToolKit can generate simultaneous SND (AU), WAV, AIFF, and MAT-file output soundfile formats (as well as realtime sound output), so you can view your results using one of a large variety of sound/signal analysis tools already available (e.g. <A HREF="http://www-ccrma.stanford.edu/software/snd/">Snd</A>, Cool Edit, Matlab). 
 
 
 <H4>What the <I>Synthesis ToolKit</I> is not.</H4>
 
 The Synthesis Toolkit is not one particular program.  Rather, it is a set of C++ classes that you can use to create your own programs.  A few example applications are provided to demonstrate some of the ways to use the classes.  If you have specific needs, you will probably have to either modify the example programs or write a new program altogether. Further, the example programs don't have a fancy GUI wrapper.  It is easy to embed STK classes inside a GUI environment but we have chosen to focus our energy on the audio signal processing issues.  Spending hundreds of hours making platform-dependent graphical user interfaces would go against one of the fundamental design goals of the ToolKit - platform independence.
 
-For those instances where a simple GUI with sliders and buttons is helpful, we use <A HREF="http://dev.scriptics.com">Tcl/Tk</A> (which is freely distributed for all the supported ToolKit platforms). A number of Tcl/Tk GUI scripts are distributed with the ToolKit release.  For control, the Synthesis Toolkit uses raw MIDI (on supported platforms), and SKINI (Synthesis ToolKit Instrument Network Interface, a MIDI-like text message synthesis control format).
+For those instances where a simple GUI with sliders and buttons is helpful, we use <A HREF="http://dev.scriptics.com">Tcl/Tk</A> (that is freely distributed for all the supported ToolKit platforms). A number of Tcl/Tk GUI scripts are distributed with the ToolKit release.  For control, the Synthesis Toolkit uses raw MIDI (on supported platforms), and SKINI (Synthesis ToolKit Instrument Network Interface, a MIDI-like text message synthesis control format).
 
 <H4>A brief history of the <I>Synthesis ToolKit in C++.</I></H4>
 
@@ -58,15 +58,49 @@ Stilson, Bill Putnam, and Gabriel Maldonado.
 
 <H4>Legal and Ethical Notes</H4>
 
-This software was designed and created to be made publicly available for free, primarily for academic purposes, so if you use it, pass it on with this documentation, and for free.  If you make a million dollars with it, give us some.  If you make compositions with it, put us in the program notes.
-<P>
+This software was designed and created to be made publicly available
+for free, primarily for academic purposes, so if you use it, pass it
+on with this documentation, and for free.  If you make a million
+dollars with it, it would be nice if you would share.  If you make
+compositions with it, put us in the program notes.
 
-Some of the concepts are covered by various patents, some known to us and likely others which are unknown.  Many of the ones known to us are administered by the Stanford Office of Technology and Licensing.  The good news is that large hunks of the techniques used here are public domain.  To avoid subtle legal issues, we will not state what's freely useable here, but we will try to note within the various classes where certain things are likely to be protected by patents.
+Some of the concepts are covered by various patents, some known to us
+and likely others that are unknown.  Many of the ones known to us are
+administered by the Stanford Office of Technology and Licensing.  The
+good news is that large hunks of the techniques used here are public
+domain.  To avoid subtle legal issues, we will not state what's freely
+useable here, but we will try to note within the various classes where
+certain things are likely to be protected by patents.
 
+<H4>License</H4>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+Any person wishing to distribute modifications to the Software is
+asked to send the modifications to the original developer so that they
+can be incorporated into the canonical version.  This is, however, not
+a binding provision of this license.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 <H4>Disclaimer</H4>
 
-STK is free and we do not guarantee anything.  We've been hacking on this code for a while now and most of it seems to work pretty well.  But, there surely are some bugs floating around.  Sometimes things work fine on one computer platform but not so fine on another.  FPU overflows and underflows cause <I>very</I> weird behavior which also depends on the particular CPU and OS.  Let us know about bugs you find and we'll do our best to correct them.
+STK is free and we do not guarantee anything.  We've been hacking on this code for a while now and most of it seems to work pretty well.  But, there surely are some bugs floating around.  Sometimes things work fine on one computer platform but not so fine on another.  FPU overflows and underflows cause <I>very</I> weird behavior that also depends on the particular CPU and OS.  Let us know about bugs you find and we'll do our best to correct them.
 
 <H4>Perry's Notes From the Original Distribution of STK</H4>
 
@@ -75,7 +109,7 @@ This whole world was created with no particular hardware in mind.  These example
 Your question at this point might be, "But Perry, with CMix, CMusic, CSound, CShells, CMonkeys, etc. already cluttering the landscape, why a new set of stupid C functions for music synthesis and processing?"  The answers lie below.
 
 <ol>
-<li>I needed to port many of the things I've done into something which is generic enough to port further to different machines.</li>
+<li>I needed to port many of the things I've done into something that is generic enough to port further to different machines.</li>
 
 <li>I really plan to document this stuff, so that you don't have to be me to figure out what's going on. (I'll probably be sorry I said this in a couple of years, when even I can't figure out what I was thinking.)</li>
 

doc/doxygen/instruments.txt

@@ -1,6 +1,6 @@
 /*! \page instruments Instruments
 
-The ToolKit comes with a wide variety of synthesis algorithms, all of which inherit from the Instrmnt class.  In this example, we'll fire up an instance of the BeeThree FM synthesis class and show how its frequency can be modified over time.
+The ToolKit comes with a wide variety of synthesis algorithms, all of which inherit from the stk::Instrmnt class.  In this example, we'll fire up an instance of the stk::BeeThree FM synthesis class and show how its frequency can be modified over time.
 
 \include bethree.cpp
 
@@ -10,7 +10,7 @@ with any other STK instrument class.  It should be noted, however,
 that a few classes do not respond to the setFrequency() function
 (e.g., Shakers, Drummer).
 
-The noteOn() function initiates an instrument attack.  Instruments that are continuously excited (e.g., Clarinet, BeeThree) will continue to sound until stopped with a noteOff().  Impulsively excited instrument sounds (e.g., Plucked, Wurley) typically decay within a few seconds time, requiring subsequent noteOn() messages for re-attack.
+The noteOn() function initiates an instrument attack.  Instruments that are continuously excited (e.g., stk::Clarinet, stk::BeeThree) will continue to sound until stopped with a noteOff().  Impulsively excited instrument sounds (e.g., stk::Plucked, stk::Wurley) typically decay within a few seconds time, requiring subsequent noteOn() messages for re-attack.
 
 Instrument parameters can be precisely controlled as demonstrated above.  A more flexible approach to instrument control, allowing arbitrary scorefile or realtime updates, is described in the next tutorial chapter.
 

doc/doxygen/links.txt

@@ -1,25 +1,25 @@
 /*! \page links Miscellaneous Links
 
-- <A HREF="http://music.mcgill.ca/~gary/rtaudio/">The %RtAudio WWW site</A>
+- <A HREF="http://www.music.mcgill.ca/~gary/rtaudio/">The %RtAudio WWW site</A>
 
-- <A HREF="http://music.mcgill.ca/~gary/rtmidi/">The %RtMidi WWW site</A>
+- <A HREF="http://www.music.mcgill.ca/~gary/rtmidi/">The %RtMidi WWW site</A>
+
+- <A HREF="http://momu.stanford.edu/stk/">MoMu-Stk: A lightly modified version of STK that supports the iPhone platform (iPhone, iPad, iPod Touches)</A>
+
+- <A HREF="http://ccrma.stanford.edu/~woony/software/stkx/">StkX: A Cocoa STK Framework for Mac OS X by Woon Seung Yeo</A>
+
+- <A HREF="http://sourceforge.net/projects/mobilestk">Mobile STK: A port of STK for mobile devices by Georg Essl and Michael Rohs</A>
 
 - <A HREF="http://chuck.cs.princeton.edu/">ChucK: Concurrent, On-the-fly Audio Programming Language</A> using STK unit generators
 
-- <A HREF="http://www.music.princeton.edu/paul/stkugens.tar.gz">Paul Lansky's port of STK to SuperCollider</A>
-
-- <A HREF="http://kern.humdrum.net/">Kern Scores: A Library of Electronic Musical Scores</A> (with automatic conversion to SKINI format)
+- <A HREF="http://kern.ccarh.org">Kern Scores: A Library of Electronic Musical Scores</A> (with automatic conversion to SKINI format)
 
 - <A HREF="http://stk.sapp.org/midi2skini">MIDI to SKINI file converter</A> by Craig Sapp
 
-- <A HREF="http://stk.sapp.org/kern2skini">Kern Score to SKINI file converter</A> by Craig Sapp
-
-- <A HREF="http://www.artassault.org/software/software.html">Calico - A Polyphonic Score File Parser for STK</A> by Greg Kellum
+- <A HREF="http://extra.humdrum.org/example/kern2skini/">Kern Score to SKINI file converter</A> by Craig Sapp
 
 - <A HREF="http://www.music.columbia.edu/PeRColate/">PeRColate: A Port of STK for Max/MSP</A>
 
-- <A HREF="http://mathmorphs.swiki.net/32/">A Partial Port of STK to Squeak</A>
-
 - <a href="http://airy.andre.online.fr/AU/index.html">AUStk: a demo of integration of STK instruments into an AudioUnit</a> by Airy Andre
 
 */

doc/doxygen/multichannel.txt

@@ -1,22 +1,25 @@
 /*! \page multichannel Multi-Channel I/O
 
-The ToolKit WvIn and WvOut classes (and their subclasses) support multi-channel audio data input and output.  A set of interleaved audio samples representing a single time "slice" is referred to as a <I>sample frame</I>.  At a sample rate of 44.1 kHz, a four-channel audio stream will have 44100 sample frames per second and a total of 176400 individual samples per second.
+The ToolKit stk::WvIn and stk::WvOut classes (and their subclasses) support multi-channel audio data input and output.  Several other abstract base classes, such as stk::Instrmnt, stk::Generator, and stk::Effect, also support multi-channel computations though not all of their subclasses produce or take multi-channel data.  A set of interleaved audio samples representing a single time "slice" is referred to as a <I>sample frame</I>.  At a sample rate of 44.1 kHz, a four-channel audio stream will have 44100 sample frames per second and a total of 176400 individual samples per second.
 
 Most STK classes process single-sample data streams via their
-<TT>tick()</TT> function.  In order to distinguish single-sample and
-sample frame calculations, the WvIn and WvOut classes implement both
-<TT>tick()</TT> and <TT>tickFrame()</TT> functions.  The
-<TT>tickFrame()</TT> functions take or return a reference to an StkFrames object
-representing one or more sample frames.  For single-channel
-streams, the <TT>tick()</TT> and <TT>tickFrame()</TT> functions
-produce equivalent results.  When <TT>tick()</TT> is called for a
-multi-channel stream, however, the function either returns a sample
-frame average (WvIn) or writes a single sample argument to all
-channels (WvOut).
+<TT>tick()</TT> function.  For classes supporting multi-channel data,
+one must distinguish the <TT>tick()</TT> functions taking or producing
+single \c StkFloat arguments from those taking stk::StkFrames& arguments.  If
+a single-sample version of the <TT>tick()</TT> function is called for
+these classes, a full sample frame is computed but only a single value
+is either input and/or output.  For example, if the single-sample
+<TT>tick()</TT> function is called for subclasses of WvOut, the sample
+argument is written to all channels in the one computed frame.  For
+classes returning values, an optional \c channel argument specifies
+which channel value is returned from the computed frame (the default
+is always channel 0). To input and/or output multichannel data to
+these classes, the overloaded <TT>tick()</TT> functions taking
+StkFrames reference arguments should be used.
 
 Multi-channel support for realtime audio input and output is dependent on the audio device(s) available on your system.
 
-The following example demonstrates the use of the FileWvOut class for
+The following example demonstrates the use of the stk::FileWvOut class for
 creating a four channel, 16-bit AIFF formatted audio file.  We will
 use four sinewaves of different frequencies for the first two seconds
 and then a single sinewave for the last two seconds.

doc/doxygen/polyvoices.txt

@@ -1,10 +1,10 @@
 /*! \page polyvoices Voice Management
 
-The previous tutorial chapters were concerned only with monophonic ToolKit instrument playback and control.  At this point, it should be relatively clear that one can instantiate multiple instruments and perhaps sum together their outputs or even direct their outputs to separate channels.  It is less clear how one might go about controlling a group of instruments.  The Voicer class is designed to serve just this purpose.
+The previous tutorial chapters were concerned only with monophonic ToolKit instrument playback and control.  At this point, it should be relatively clear that one can instantiate multiple instruments and perhaps sum together their outputs or even direct their outputs to separate channels.  It is less clear how one might go about controlling a group of instruments.  The stk::Voicer class is designed to serve just this purpose.
 
-The STK Voicer class is a relatively simple voice manager.  The user can dynamically add and delete instruments to/from its "control", with the option of controlling specific instruments via unique note tags and/or grouping sets of instruments via a "channel" number.  All sounding instrument outputs are summed and returned via the <TT>tick()</TT> function.  The Voicer class responds to noteOn, noteOff, setFrequency, pitchBend, and controlChange messages, automatically assigning incoming messages to the voices in its control.  When all voices are sounding and a new noteOn is encountered, the Voicer interrupts the oldest sounding voice.  The user is responsible for creating and deleting all instrument instances.
+The stk::Voicer class is a relatively simple voice manager.  The user can dynamically add and delete instruments to/from its "control", with the option of controlling specific instruments via unique note tags and/or grouping sets of instruments via a "group" number.  All sounding instrument outputs are summed and returned via the <TT>tick()</TT> function.  The stk::Voicer class responds to noteOn, noteOff, setFrequency, pitchBend, and controlChange messages, automatically assigning incoming messages to the voices in its control.  When all voices are sounding and a new noteOn is encountered, the stk::Voicer interrupts the oldest sounding voice.  The user is responsible for creating and deleting all instrument instances.
 
-In the following example, we modify the <TT>controlbee.cpp</TT> program to make use of three BeeThree instruments, all controlled using a Voicer.
+In the following example, we modify the <TT>controlbee.cpp</TT> program to make use of three stk::BeeThree instruments, all controlled using a stk::Voicer.
 
 \include threebees.cpp
 
@@ -14,9 +14,9 @@ We have written this program to accept control messages from \c STDIN.  Assuming
 threebees < scores/bachfugue.ski
 \endcode
 
-For more fun, surf to <A HREF="http://kern.humdrum.net/">Kern Scores</A> for a huge assortment of other scorefiles which can be downloaded in the SKINI format.
+For more fun, surf to <A HREF="http://kern.humdrum.net/">Kern Scores</A> for a huge assortment of other scorefiles that can be downloaded in the SKINI format.
 
-Another easy extension would be to add the \c Messager::startMidiInput() function to the program and then play the instruments via a MIDI keyboard.
+Another easy extension would be to add the \c stk::Messager::startMidiInput() function to the program and then play the instruments via a MIDI keyboard.
 
 [<A HREF="tutorial.html">Main tutorial page</A>]
 */

doc/doxygen/realtime.txt

@@ -2,30 +2,36 @@
 
 In this section, we modify the <TT>sineosc.cpp</TT> program in order
 to send the output to the default audio playback device on your
-computer system.  We also make use of the SineWave class as a
-sine-wave oscillator.  SineWave computes an internal, static sine-wave
+computer system.  We also make use of the stk::SineWave class as a
+sine-wave oscillator.  stk::SineWave computes an internal, static sine-wave
 table when its first instance is created.  Subsequent instances make
 use of the same table.  The default table length, specified in
 SineWave.h, is 2048 samples.
 
 \include rtsine.cpp
 
-The class RtWvOut is a protected subclass of WvOut.  A number of
+The class stk::RtWvOut is a protected subclass of stk::WvOut.  A number of
 optional constructor arguments can be used to fine tune its
-performance for a given system.  RtWvOut provides a "single-sample"
-interface to the RtAudio class.  Note that RtWvOut (as well as the
-RtWvIn and RtDuplex classes described below) make use of RtAudio's
-blocking input/output functionality.  On systems that implement an
-inherently callback-based audio API (Linux Jack, Windows ASIO, OS-X
-CoreAudio), this blocking functionality will be less robust.  An
-example of audio output using a callback scheme will be discussed in a
-subsequent tutorial section.
+performance for a given system.  stk::RtWvOut provides a "single-sample",
+blocking interface to the RtAudio class.  Note that stk::RtWvOut (as well
+as the stk::RtWvIn class described below) makes use of RtAudio's callback
+input/output functionality by creating a large ring-buffer into which
+data is written.  These classes should not be used when low-latency
+and robust performance is necessary
 
-Though not used here, an RtWvIn class exists as well that can be used to read realtime audio data from an input device.  See the <TT>record.cpp</TT> example program in the <TT>examples</TT> project for more information.
+Though not used here, an stk::RtWvIn class exists as well that can be used
+to read realtime audio data from an input device.  See the
+<TT>record.cpp</TT> example program in the <TT>examples</TT> project
+for more information.
 
-It may be possible to use an instance of RtWvOut and an instance of RtWvIn to simultaneously read and write realtime audio to and from a hardware device or devices.  However, it is recommended to instead use a single instance of RtDuplex to achieve this behavior, in that it guarantees better synchronization between the input and output data.  See the <TT>effects</TT> project or the <TT>io.cpp</TT> example program in the <TT>examples</TT> project for more information.
+It may be possible to use an instance of stk::RtWvOut and an instance of
+stk::RtWvIn to simultaneously read and write realtime audio to and from a
+hardware device or devices.  However, it is recommended to instead use
+a single instance of RtAudio to achieve this behavior, as described in the next section.
+See the <TT>effects</TT> project or the <TT>duplex.cpp</TT> example
+program in the <TT>examples</TT> project for more information.
 
-When using any realtime STK class (RtAudio, RtWvOut, RtWvIn, RtDuplex, RtMidi, InetWvIn, InetWvOut, Socket, UdpSocket, TcpServer, TcpClient, and Thread), it is necessary to specify an audio/MIDI API preprocessor definition and link with the appropriate libraries or frameworks.  For example, the above program could be compiled on a Linux system using the GNU g++ compiler and the ALSA audio API as follows (assuming all necessary files exist in the project directory):
+When using any realtime STK class (RtAudio, stk::RtWvOut, stk::RtWvIn, RtMidi, stk::InetWvIn, stk::InetWvOut, stk::Socket, stk::UdpSocket, stk::TcpServer, stk::TcpClient, and stk::Thread), it is necessary to specify an audio/MIDI API preprocessor definition and link with the appropriate libraries or frameworks.  For example, the above program could be compiled on a Linux system using the GNU g++ compiler and the ALSA audio API as follows (assuming all necessary files exist in the project directory):
 
 \code
 g++ -Wall -D__LINUX_ALSA__ -D__LITTLE_ENDIAN__ -o rtsine Stk.cpp Generator.cpp SineWave.cpp WvOut.cpp \

doc/doxygen/system.txt

@@ -9,33 +9,27 @@
 <B>Linux (specific):</B>
 <UL>
 <LI>A soundcard to use realtime audio input/output capabilities.  In order to use the <I><B>effects</B></I> project, the soundcard and drivers must support full duplex mode.</LI>
-<LI><A HREF="http://www.alsa-project.org/">ALSA</A> device drivers and library for realtime sound and MIDI input/output.  <A HREF="http://www.opensound.com">OSS</A> device drivers can be used for audio input/output, but MIDI support requires the ALSA library to compile.</LI>
+<LI><A HREF="http://www.alsa-project.org/">ALSA</A> device drivers and library for realtime sound and MIDI input/output.</LI>
+<LI><A HREF="http://www.opensound.com">OSS</A> device drivers (version 4.0 and higher only) can be used for audio input/output, but MIDI support requires the ALSA library to compile.</LI>
 </UL>
 
 <B>Macintosh OS X (specific):</B>
 <UL>
-<LI>A C++ compiler does install by default with OS X.  It is necessary to download the Developer Kit from the Apple WWW site in order to compile STK or load it from the installation CD-ROM.</LI>
-<LI><B>IMPORTANT:</B>The internal Macintosh audio hardware typically supports a sample rate of 44100 Hz only.  The default STK sample rate is now 44100 Hz, but there may be programs which change that value before execution.  Check the program code if you have sample rate conflicts.  Many of the example project programs allow the sample rate to be specified via the command line.</LI>
+<LI>A C++ compiler is not installed by default with OS X.  It is necessary to download the Developer Kit from the Apple WWW site in order to compile STK or load it from the installation CD-ROM.</LI>
 <LI>If you experience frequent audio input/output "glitches", try increasing the RT_BUFFER_SIZE specified in Stk.h.</LI>
-<LI>The tcl/tk interpreter does not ship by default with OS X, but must be downloaded from the internet.  The latest Tcl/Tk Aqua distribution (http://www.apple.com/downloads/macosx/unix_open_source/tcltk.html) has been successfully tested on 10.2 and 10.3 systems.  The default installation will place a link to the wish interpretor at /usr/bin/wish.
+<LI>The tcl/tk interpreter does not ship by default with OS X and must be downloaded from the internet.  The latest Tcl/Tk Aqua distribution (http://www.apple.com/downloads/macosx/unix_open_source/tcltk.html) has been successfully tested on 10.2 and 10.3 systems.  The default installation will place a link to the wish interpretor at /usr/bin/wish.
 
 It appears that socket support in Tcl/Tk uses the Nagle algorithm, which produces poor response between changes made in the tcl/tk script and the resulting audio updates.  Note that this is only a problem when using a socket connection from a Tcl/Tk script.</LI>
 
 </UL>
 
-<B>Windows95/98/2000/XP (specific):</B>
+<B>Windows95/98/2000/XP/7 (specific):</B>
 <UL>
 <LI>A soundcard to use realtime audio input/output capabilities.  In order to use the <I><B>effects</B></I> project, the soundcard and drivers must support full duplex mode.</LI>
-<LI><A HREF="http://www.microsoft.com/directx/">DirectX</A> 5.0 (or higher) runtime libraries to use the precompiled binaries.</LI>
-<LI>Visual C++ 6.0 for compiling (though a precompiled distribution is available).</LI>
+<LI><A HREF="http://www.microsoft.com/directx/">DirectX</A> 5.0 (or higher) runtime libraries.</LI>
 <LI>For compiling the source (if not already in your system): <UL><LI><A HREF="Misc/dsound.h">dsound.h</A> header file (DirectX 6.1) - put somewhere in your header search path</LI><LI><A HREF="Misc/dsound.lib">dsound.lib</A> library file (DirectX 6.1) - put somewhere in your library search path</LI></UL></LI>
 </UL>
 
-<B>WindowsNT (specific):</B>
-<UL>
-<LI>DirectX support for NT is inadequate, so it is not possible to use STK under WindowsNT with realtime DirectX support.  It may be possible to use STK under WindowsNT with realtime ASIO support, though this has not been tested.</LI>
-</UL>
-
 <P>
 
 */

doc/doxygen/tutorial.txt

@@ -1,12 +1,10 @@
 /*! \page tutorial Tutorial
 
 The Synthesis ToolKit is a set of C++ classes.  In order to go beyond the simple example programs we provide, it is necessary to know some basics about programming in C and C++.  STK's "target audience" includes people who:
-<UL>
-<LI>want to create audio DSP and/or synthesis programs</LI>
-<LI>want to use our unit generators and input/output routines rather than code their own</LI>
-<LI>want to learn about synthesis and processing algorithms</LI>
-<LI>wish to teach real-time synthesis and processing and wish to use some of our classes and examples</LI>
-</UL>
+- want to create audio DSP and/or synthesis programs
+- want to use our unit generators and input/output routines rather than code their own
+- want to learn about synthesis and processing algorithms
+- wish to teach real-time synthesis and processing and wish to use some of our classes and examples
 
 Most ToolKit programmers will likely end up writing a class or two for their own particular needs, but this task is typically simplified by making use of pre-existing STK classes (filters, oscillators, etc.).
 

doc/doxygen/usage.txt

@@ -2,6 +2,7 @@
 
 - \ref directory
 - \ref compiling
+- \ref debug
 - \ref control
 - \ref voices
 - \ref nort
@@ -31,31 +32,34 @@ The top level distribution contains the following directories:
 This release of STK comes with four separate "project" directories:
 
 <OL>
-<LI> The <I><B>demo</B></I> project is used to demonstrate nearly all of the STK instruments.  The <I><B>demo</B></I> program has been written to allow a variety of control input and sound data output options.  %Simple graphical user interfaces (GUIs) are also provided.<P></LI>
+<LI> The <I><B>demo</B></I> project is used to demonstrate nearly all of the STK instruments.  The <I><B>stk-demo</B></I> program has been written to allow a variety of control input and sound data output options.  Simple graphical user interfaces (GUIs) are also provided.<P></LI>
 
 <LI> The <I><B>effects</B></I> project demonstrates realtime duplex mode (simultaneous audio input and output) operation, when available, as well as various delay-line based effects algorithms.<P></LI>
 
 <LI> The <I><B>ragamatic</B></I> project is just cool.  Fire it up and be enlightened.<P></LI>
 
-<LI> The <I><B>examples</B></I> project contains several simple programs which demonstrate audio input/output, including the audio internet streaming classes, as well as most of the tutorial programs.</LI>
+<LI> The <I><B>eguitar</B></I> project demonstrates how to make an electric guitar with feedback and distortion.<P></LI>
+
+<LI> The <I><B>examples</B></I> project contains several simple programs that demonstrate audio input/output, including the audio internet streaming classes, as well as most of the tutorial programs.</LI>
 </OL>
 
 \section compiling Compiling:
 
 <UL>
-<LI><B>Windows95/98/2000/XP:</B> Realtime support is available using either DirectSound or ASIO audio drivers.  For DirectSound support, use the <TT>__WINDOWS_DS__</TT> preprocessor definition and link with the <TT>dsound.lib</TT>, <TT>winmm.lib</TT>, and <TT>Wsock32.lib</TT> libraries. For ASIO support, use the <TT>__WINDOWS_ASIO__</TT> preprocessor definition, include all the files in the <TT>src/asio/</TT> directory (i.e. <TT>asio.h,cpp</TT>, <TT>asiodrivers.h,cpp</TT>, ...), and link with the <TT>winmm.lib</TT>, and <TT>Wsock32.lib</TT> libraries.  In addition, the <TT>__LITTLE_ENDIAN__</TT> and <TT>__WINDOWS_MM__</TT> preprocessor definitions are necessary for all Windows systems (RtMidi uses the Windows MultiMedia MIDI API).  A distribution of the release is available with precompiled binaries (using DirectSound) for all the projects.  In order for these binaries to function properly, your system must have the DirectX 5.0 (or higher) runtime libraries installed (available from <A HREF="http://www.microsoft.com/directx/">Microsoft</A>).  Further, the <I><B>effects</B></I> project requires that your soundcard and drivers provide full duplex mode capabilities.  Visual C++ 6.0 project files are provided in each project directory as well should you wish to compile your own binaries.  It is important to link with the non-debug libraries when compiling "release" program versions and debug libraries when compiling "debug" program versions.</LI>
+<LI><B>Windows95/98/2000/XP/7:</B> Realtime support is available using either DirectSound, ASIO or WASAPI audio drivers.  For DirectSound support, use the <TT>__WINDOWS_DS__</TT> preprocessor definition and link with the <TT>dsound.lib</TT>, <TT>winmm.lib</TT>, and <TT>Wsock32.lib</TT> libraries. For ASIO support, use the <TT>__WINDOWS_ASIO__</TT> preprocessor definition, include all the files in the <TT>src/asio/</TT> directory (i.e. <TT>asio.h,cpp</TT>, <TT>asiodrivers.h,cpp</TT>, ...), and link with the <TT>winmm.lib</TT>, and <TT>Wsock32.lib</TT> libraries.  For WASAPI support, use the <TT>__WINDOWS_WASAPI__</TT> preprocessor definition.  In addition, the <TT>__LITTLE_ENDIAN__</TT> and <TT>__WINDOWS_MM__</TT> preprocessor definitions are necessary for all Windows systems (RtMidi uses the Windows MultiMedia MIDI API).  Fairly old Visual C++ project files are provided in each project directory, though they may not work on newer versions of MSVS.  As well, the MinGW compiler is supported (see below).  It is important to link with the non-debug libraries when compiling "release" program versions and debug libraries when compiling "debug" program versions.</LI>
 
-<LI><B>WindowsNT:</B> DirectX support for NT is inadequate, so it is not possible to use STK under WindowsNT with realtime DirectX support.  It may be possible to use STK under WindowsNT with realtime ASIO support, though this has not been tested.</LI>
-
-<LI><B>Unix Systems:</B> A GNU <TT>configure</TT> shell script is included in the distribution for unix-based systems.  From the top-level distribution directory, type <TT>'./configure'</TT> and the script will create <TT>Makefiles</TT> in each project directory specific to the characteristics of the host computer.  Then from within any given project directory (example <TT>demo</TT>), type <TT>'make'</TT> to compile the project.  In addition, an STK library can be compiled from within the <TT>src</TT> directory.
+<LI><B>Unix (and MinGW) Systems:</B> A GNU <TT>configure</TT> shell script is included in the distribution for unix-based systems.  From the top-level distribution directory, type <TT>'./configure'</TT> and the script will create <TT>Makefiles</TT> in each project directory specific to the characteristics of the host computer.  Then from within any given project directory (example <TT>demo</TT>), type <TT>'make'</TT> to compile the project.  In addition, an STK library can be compiled from within the <TT>src</TT> directory.
 
 Several options can be supplied to the <TT>configure</TT> script to customize the build behavior:
 <UL>
 <LI><TT>--disable-realtime</TT> to only compile generic non-realtime classes</LI>
 <LI><TT>--enable-debug</TT> to enable various debug output</LI>
 <LI><TT>--with-alsa</TT> to choose native ALSA API support (default, linux only)</LI>
-<LI><TT>--with-jack</TT> to choose native JACK API support (linux only)</LI>
 <LI><TT>--with-oss</TT> to choose native OSS audio API support (linux only, no native OSS MIDI support)</LI>
+<LI><TT>--with-jack</TT> to choose native JACK API support (linux and Macintosh OS-X)</LI>
+<LI><TT>--with-core</TT> to choose Core Audio API support (Macintosh OS-X)</LI>
+<LI><TT>--with-asio</TT> to choose ASIO Audio API support (Windows)</LI>
+<LI><TT>--with-ds</TT> to choose Windows Direct Sound Audio API support (Windows)</LI>
 </UL>
 <P>
 Note that it is possible to specify as many of the "--with-" options as desired to compile multi-API support.  In addition, it is possible to specify the location of the STK rawwaves and the STK include path as follows:
@@ -69,15 +73,16 @@ For novice STK users, the default configuration should be adequate.
 
 For those who wish to create their own system-specific <TT>Makefiles</TT>:
 <UL>
-<LI><B>Linux:</B> Realtime audio support is enabled with either the <TT>__LINUX_ALSA__</TT>, <TT>__LINUX_JACK__</TT>, and/or <TT>__LINUX_OSS__</TT> preprocessor definitions, which are used to select the underlying audio system API(s).  Because the ALSA library is now integrated into the standard Linux kernel, it is the default audio/MIDI API with STK versions 4.2 and higher.  The <TT>__LINUX_ALSASEQ__</TT> preprocessor definition must be included for MIDI support.  Note that native OSS MIDI support no longer exists in RtMidi.  If the <TT>__LINUX_OSS__</TT> preprocessor definition is specified, only OSS audio support will be compiled and RtMidi will still be compiled using the ALSA API (assuming the <TT>__LINUX_ALSASEQ__</TT> definition is defined).  For this reason, STK now requires the <TT>asound</TT> library for realtime support.  Realtime programs must also link with the <TT>pthread</TT> library.  In addition, the <TT>__LITTLE_ENDIAN__</TT> preprocessor definition is necessary if compiling on a little-endian system.  See the README-Linux file for further system configuration information.</LI>
+<LI><B>Linux:</B> Realtime audio support is enabled with either the <TT>__LINUX_ALSA__</TT>, <TT>__UNIX_JACK__</TT>, and/or <TT>__LINUX_OSS__</TT> preprocessor definitions, which are used to select the underlying audio system API(s).  Because the ALSA library is now integrated into the standard Linux kernel, it is the default audio/MIDI API with STK versions 4.2 and higher.  The <TT>__LINUX_ALSASEQ__</TT> preprocessor definition must be included for MIDI support.  Note that native OSS MIDI support no longer exists in RtMidi.  If the <TT>__LINUX_OSS__</TT> preprocessor definition is specified, only OSS (version 4.0) audio support will be compiled and RtMidi will still be compiled using the ALSA API (assuming the <TT>__LINUX_ALSASEQ__</TT> definition is defined).  For this reason, STK now requires the <TT>asound</TT> library for realtime support.  Realtime programs must also link with the <TT>pthread</TT> library.  In addition, the <TT>__LITTLE_ENDIAN__</TT> preprocessor definition is necessary if compiling on a little-endian system.  See the README-Linux file for further system configuration information.</LI>
 
-<LI><B>Macintosh OS X:</B> Realtime support is enabled with the <TT>__MACOSX_CORE__</TT> preprocessor definitions, which incorporates the CoreAudio audio/MIDI API.  Realtime programs must also link with the <TT>pthread</TT> library and the <TT>CoreAudio</TT>, <TT>CoreMIDI</TT>, and <TT>CoreFoundation</TT> frameworks.  See the README-MacOSX file for further system configuration information.</LI>
-
-<LI><B>SGI:</B> Realtime audio and MIDI support is enabled with the <TT>__IRIX_AL__</TT> and <TT>__IRIX_MD__</TT> preprocessor definitions and linkage with the <TT>audio</TT>, <TT>md</TT>, and <TT>pthread</TT> libraries.  STK 4.0 (and higher) is confirmed to compile using CC version 7.30.  There may be problems with old compiler versions.</LI>
+<LI><B>Macintosh OS X:</B> Realtime support is enabled with the <TT>__MACOSX_CORE__</TT> and <TT>__UNIX_JACK__</TT> preprocessor definitions, which incorporate the CoreAudio audio/MIDI API and/or the JACK API.  Realtime programs must also link with the <TT>pthread</TT> library and the <TT>CoreAudio</TT>, <TT>CoreMIDI</TT>, and <TT>CoreFoundation</TT> frameworks (for Core Audio support) and/or the JACK library.  See the README-MacOSX file for further system configuration information.</LI>
 
 <LI><B>Generic (non-realtime):</B> Most STK classes are operating system <I>independent</I> and can be compiled using any current C++ compiler. STK assumes big-endian host byte order by default, so if your system is little-endian (i.e. Intel processor), you must provide the <TT>__LITTLE_ENDIAN__</TT> preprocessor definition to your compiler.  The <I><B>demo</B></I> project will compile without realtime support, allowing the use of SKINI scorefiles for input control and output to a variety of soundfile formats.  The following classes <I>cannot</I> be used without realtime support: RtAudio, RtWvIn, RtWvOut, RtDuplex, RtMidi, Socket, Thread, Mutex, TcpWvIn, TcpWvOut.  Because of this, it is not possible to compile the <I><B>effects</B></I>, <I><B>ragamatic</B></I>, and most of the <I><B>examples</B></I> projects for non-realtime use.</LI>
 </UL>
 
+\section debug Debugging:
+
+When developing applications with STK, it is recommended that you define the preprocessor definition <TT>_STK_DEBUG_</TT> when compiling (or specify the <TT>--enable-debug</TT> option to the <TT>configure</TT> script).  This will enable all levels of function argument and error checking within the STK classes.  Without this definition, argument checking does not occur in functions that are expected to be called frequently in an iterative manner.
 
 \section control Control Data:
 
@@ -86,11 +91,10 @@ All STK programs in this distribution take input control data in the form of <A
 <OL>
 <LI>Redirect or pipe SKINI scorefiles to an executable.</LI>
 <LI>Pipe realtime SKINI input messages to an executable (not possible under Windows95/98).</LI>
-<LI>Socket realtime SKINI input messages to an executable.</LI>
 <LI>Acquire realtime MIDI messages from a MIDI port on your computer.</LI>
 </OL>
 
-<A HREF="http://dev.scriptics.com">Tcl/Tk</A> graphical user interfaces (GUI) are provided with this distribution which can generate realtime SKINI messages.  Note that the Messager class allows multiple simultaneous socket client connections, together with MIDI and/or piped input.  The <I><B>Md2Skini</B></I> program (in the <I><B>demo</B></I> directory) is mostly obsolete but can be used to create SKINI scorefiles from realtime MIDI input.  
+<A HREF="http://dev.scriptics.com">Tcl/Tk</A> graphical user interfaces (GUI) are provided with this distribution that can generate realtime SKINI messages.  Note that the Messager class allows multiple simultaneous socket client connections, together with MIDI and/or piped input.  The <I><B>Md2Skini</B></I> program (in the <I><B>demo</B></I> directory) is mostly obsolete but can be used to create SKINI scorefiles from realtime MIDI input.  
 
 
 \section voices Demo: STK Instruments
@@ -99,7 +103,7 @@ The <I><B>demo</B></I> project demonstrates the behavior of all the distributed
 <UL>
 <LI>Clarinet: Pretty good physical model of the clarinet</LI>
 <LI>BlowHole: A clarinet physical model with one tonehole and one register vent</LI>
-<LI>Saxofony: A psuedo-conical bore reed instrument which sometimes sounds like a saxophone</LI>
+<LI>Saxofony: A psuedo-conical bore reed instrument that sometimes sounds like a saxophone</LI>
 <LI>Flute: Pretty good physical model of the flute</LI>
 <LI>Brass: Not so bad physical model of a brass instrument</LI>
 <LI>BlowBotl: A basic helmholtz resonator and air jet model</LI>
@@ -130,23 +134,23 @@ The <I><B>demo</B></I> project demonstrates the behavior of all the distributed
 
 See the information above with respect to compiling STK for non-realtime use.
 
-In non-realtime mode, it is assumed that input control messages are provided from a SKINI scorefile and that audio output is written to a soundfile (.snd, .wav, .aif, .mat, .raw).  A number of SKINI scorefiles are provided in the <I>scores</I> directory of the <I><B>demo</B></I> project.  Assuming a successful compilation of the <I><B>demo</B></I> program, typing:
+In non-realtime mode, it is assumed that input control messages are provided from a SKINI scorefile and that audio output is written to a soundfile (.snd, .wav, .aif, .mat, .raw).  A number of SKINI scorefiles are provided in the <I>scores</I> directory of the <I><B>demo</B></I> project.  Assuming a successful compilation of the <I><B>stk-demo</B></I> program, typing:
 
 \code
-demo BeeThree -ow myfile.wav -if scores/bookert.ski
+stk-demo BeeThree -ow myfile.wav -if scores/bookert.ski
 \endcode
 
-from the <I><B>demo</B></I> directory will play the scorefile <I>bookert.ski</I> using the STK BeeThree instrument and write the resulting audio data to a WAV formatted soundfile called "myfile.wav" (note that you may need to append <TT>./</TT> to the program name if your default shell setup is not set to look in the current directory).  Typing <TT>demo</TT> without any arguments will provide a full program usage description.
+from the <I><B>demo</B></I> directory will play the scorefile <I>bookert.ski</I> using the STK BeeThree instrument and write the resulting audio data to a WAV formatted soundfile called "myfile.wav" (note that you may need to append <TT>./</TT> to the program name if your default shell setup is not set to look in the current directory).  Typing <TT>stk-demo</TT> without any arguments will provide a full program usage description.
 
 
 \section rt Demo: Realtime Use
 
-STK realtime audio and MIDI input/output and realtime SKINI control input via socketing support is provided for Linux, SGI, Mac OS X, and Windows95/98/2000/XP operating systems.  STK realtime SKINI control input via piping is possible under Linux, SGI, Mac OS X, and Windows2000/XP only.
+STK realtime audio and MIDI input/output and realtime SKINI control input via socketing support is provided for Linux, Mac OS-X, and Windows95/98/2000/XP operating systems.  STK realtime SKINI control input via piping is possible under Linux, Mac OS X, and Windows2000/XP only.
 <P>
-Control input and audio output options are typically specified as command-line arguments to STK programs.  For example, the <I><B>demo</B></I> program is invoked as:
+Control input and audio output options are typically specified as command-line arguments to STK programs.  For example, the <I><B>stk-demo</B></I> program is invoked as:
 
 \code
-demo instrument flags
+stk-demo instrument flags
 \endcode
 
 where instruments include those described above and flags can be any or all of:
@@ -157,20 +161,19 @@ where instruments include those described above and flags can be any or all of:
 <LI><I>-om \<file name\></I> for MAT-file output,</LI>
 <LI><I>-if \<file name\></I> for a SKINI formatted control file,</LI>
 <LI><I>-ip</I> for realtime SKINI control input via piping,</LI>
-<LI><I>-is \<port\></I> for realtime SKINI control input via socketing (with an optional port number),</LI>
 <LI><I>-im \<port\></I> for MIDI control input (with optional port, -1 = virtual port where possible),</LI>
 <LI><I>-s RATE</I> to specify a sample rate,</LI>
 <LI><I>-n NUMBER</I> to specify multivoice polyphony</LI>
 </UL>
-The <i>-ip</i> and <i>-is</i> flags must be used when piping or socketing realtime SKINI control data to an STK program.  The <i>-im</i> flag must be used to read MIDI control input from your MIDI port.  Note that you can use all three input types simultaneously.
+The <i>-ip</i> flag must be used when piping realtime SKINI control data to an STK program.  The <i>-im</i> flag must be used to read MIDI control input from your MIDI port.  Note that you can use both input types simultaneously.
 
-Assuming a successful compilation of the <I><B>demo</B></I> program, typing:
+Assuming a successful compilation of the <I><B>stk-demo</B></I> program, typing:
 
 \code
-demo BeeThree -or -if scores/bookert.ski
+stk-demo BeeThree -or -if scores/bookert.ski
 \endcode
 
-from the <I><B>demo</B></I> directory will play the scorefile <I>bookert.ski</I> using the STK BeeThree instrument and stream the resulting audio data in realtime to the audio output channel of your computer.  Typing <TT>demo</TT> without any arguments will provide a full program usage description.
+from the <I><B>demo</B></I> directory will play the scorefile <I>bookert.ski</I> using the STK BeeThree instrument and stream the resulting audio data in realtime to the audio output channel of your computer.  Typing <TT>stk-demo</TT> without any arguments will provide a full program usage description.
 
 
 \section tcl Realtime Control Input using Tcl/Tk Graphical User Interfaces:
@@ -178,35 +181,25 @@ from the <I><B>demo</B></I> directory will play the scorefile <I>bookert.ski</I>
 There are a number of <A HREF="http://dev.scriptics.com">Tcl/Tk</A> GUIs supplied with the STK projects.  These scripts require Tcl/Tk version 8.0 or later, which can be downloaded for free over the WWW.  On Unix and Windows2000/XP platforms, you can run the various executable scripts (e.g. StkDemo.bat) provided with each project to start everything up (you may need to symbolically link the wishXX executable to the name <I>wish</I>).  The Physical.bat script just implements the following command-line sequence:
 
 \code
-wish < tcl/Physical.tcl | demo Clarinet -or -ip
+wish < tcl/Physical.tcl | stk-demo Clarinet -or -ip
 \endcode
 
-On WindowsXX and Unix platforms, the following operations are necessary to establish a socket connection between the Tcl/Tk GUI and the STK program:
-<OL>
-<LI>Open a DOS shell and start the STK program with the <I>-is</I> flag (ex. <I><B>demo Clarinet -or -is</B></I>).</LI>
-<LI>Open the Tcl/Tk GUI (e.g. tcl/Physical.tcl) by double-clicking on it, or type <TT>wish < tcl/Physical.tcl</TT> in another DOS shell.</LI>
-<LI>Establish the socket connection by selecting <I>Socket</I> under the Communications menu item in the Tcl/Tk GUI.</LI>
-</OL>
-
-Note that it is possible to specify a hostname when establishing the socket connection from the socket client.  Thus, the STK socket server program and the Tcl/Tk GUI need not necessarily reside on the same computer.
-
-
 \section midi Realtime MIDI Control Input:
 
 On all supported realtime platforms, you can direct realtime MIDI input to the STK Clarinet by typing:
 
 \code
-demo Clarinet -or -im
+stk-demo Clarinet -or -im
 \endcode
 
-This will attempt to use the default MIDI port for input.  An optional MIDI port number can be specified after the <TT>-im</TT> flag.  Valid MIDI ports are numbered from 0 (default) and higher.  On Linux and Macintosh OS-X systems, it is possible to open a virtual MIDI input port (which other software applications can connect to) by specifying a port identifier of -1.
+This will attempt to use the default MIDI port for input.  An optional MIDI port number can be specified after the <TT>-im</TT> flag.  Valid MIDI ports are numbered from 0 (default) and higher.  On Linux and Macintosh OS-X systems, it is possible to open a virtual MIDI input port (that other software applications can connect to) by specifying a port identifier of -1.
 
 \section polyphony Polyphony:
 
-The <I><B>demo</B></I> program supports an arbitrary number of voices via the <TT>-n NUMBER</TT> command-line flag and argument.  For example, you can play eight BeeThree instruments with realtime output and control them from a MIDI device by typing:
+The <I><B>stk-demo</B></I> program supports an arbitrary number of voices via the <TT>-n NUMBER</TT> command-line flag and argument.  For example, you can play eight BeeThree instruments with realtime output and control them from a MIDI device by typing:
 
 \code
-demo BeeThree -n 8 -or -im
+stk-demo BeeThree -n 8 -or -im
 \endcode
 
 */

doc/hierarchy.txt

@@ -1,14 +1,11 @@
 STK: A ToolKit of Audio Synthesis Classes and Instruments in C++
 
-By Perry R. Cook and Gary P. Scavone, 1995-2005.
+By Perry R. Cook and Gary P. Scavone, 1995--2016.
 
 STK Classes - See the HTML documentation in the html directory for complete information.
 
 
-     .- Generator - (Modulate, Noise, SingWave, Envelope, SineWave, Blit, BlitSaw, BlitSquare, Granulate)
-     |                           |                 |
-     |                        SubNoise            ADSR
-     |                                            Asymp
+     .- Generator - (Modulate, Noise, SingWave, Envelope, ADSR, Asymp, SineWave, Blit, BlitSaw, BlitSquare, Granulate)
      |
      |- Function - (BowTable, JetTable, ReedTable)
      |
@@ -16,29 +13,28 @@ STK Classes - See the HTML documentation in the html directory for complete info
      |
      |- WvIn - (FileWvIn, RtWvIn, InetWvIn)
      |             |
-     |          WaveLoop
+     |          FileLoop
      |
      |- WvOut - (FileWvOut, RtWvOut, TcpWvOut)
      |
-     |- Filter - (OnePole, OneZero, Delay, TwoPole, TwoZero, PoleZero, Biquad)
-     |                                |                                  |
-     |                              DelayL                             FormSwep
-     |                              DelayA
+     |- Filter - (OnePole, OneZero, TwoPole, TwoZero, PoleZero, Biquad, FormSwep, Delay, DelayL, DelayA, TapDelay)
      |
-     |- RtAudio, RtMidi, RtDuplex, Socket, Thread, Mutex
-     |                               |
-Stk -|                           UdpSocket
-     |                           TcpServer
-     |                           TcpClient
+     |- RtAudio, RtMidi, Socket, Thread, Mutex
+     |                      |
+Stk -|                  UdpSocket
+     |                  TcpServer
+     |                  TcpClient
      |
      |- StkFrames
      |
-     |- Effect - (Echo, Chorus, PitShift, PRCRev, JCRev, NRev)
+     |- Effect - (Echo, Chorus, PitShift, LentPitShift, PRCRev, JCRev, NRev, FreeVerb)
      |
      |- Voicer, Message, Skini, MidiFileIn, Phonemes, Sphere, Vector3D
      |
      |- Messager
      |
+     |- Twang, Guitar
+     |
      |            .- FM - (HevyMetl, PercFlut, Rhodey, Wurley, TubeBell, BeeThree, FMVoices)
      |            |
      |            |- Modal - ModalBar
@@ -49,7 +45,7 @@ Stk -|                           UdpSocket
      |            |
      |            |- Resonate
      |            |
-     |            |- PluckedTwo - Mandolin
+     |            |- Mandolin
      .- Instrmnt -|
                   |- Drummer
                   |
@@ -68,34 +64,33 @@ Stk -|                           UdpSocket
 
 Master Class:  Stk.cpp         Sample rate, byte-swapping, error handling functionality
 
-Sources:       Generator.cpp   Abstract base class for various source signal classes
-               Function.cpp    Abstract base class for various input/output mapping classes
+Sources:       Generator.h     Abstract base class for various source signal classes
+               Function.h      Abstract base class for various input/output mapping classes
                Envelope.cpp    Linearly goes to target by rate
-               ADSR.cpp        ADSR flavor of Envelope
+               ADSR.cpp        ADSR envelope
                Asymp.cpp       Exponentially approaches target
                Noise.cpp       Random number generator
-               SubNoise.cpp    Random numbers each N samples
                SineWave.cpp    Sinusoidal oscillator with internally computed static table
                Blit.cpp        Bandlimited impulse train
                BlitSaw.cpp     Bandlimited sawtooth generator
                BlitSquare.cpp  Bandlimited square wave generator
                Granulate.cpp   Granular synthesis class that processes a monophonic audio file
                FileRead.cpp    Audio file input class (no internal data storage) for RAW, WAV, SND (AU), AIFF, MAT-file files
-               WvIn.cpp        Abstract base class for audio data input classes
+               WvIn.h          Abstract base class for audio data input classes
                FileWvIn.cpp    Audio file input interface class with interpolation
-               WaveLoop.cpp    Wavetable looping (subclass of FileWvIn)
+               FileLoop.cpp    Wavetable looping (subclass of FileWvIn)
                RtWvIn.cpp      Realtime audio input class (subclass of WvIn)
                InetWvIn.cpp    Audio streaming (socket server) input class (subclass of WvIn)
 
 Sinks:         FileWrite.cpp   Audio file output class (no internal data storage) for RAW, WAV, SND (AU), AIFF, MAT-file files
-               WvOut.cpp       Abstract base class for audio data output classes
+               WvOut.h         Abstract base class for audio data output classes
                FileWvOut.cpp   Audio file output interface class to FileWrite
                RtWvOut.cpp     Realtime audio output class (subclass of WvOut)
                InetWvOut.cpp   Audio streaming (socket client) output class (subclass of WvOut)
 
-Duplex:        RtDuplex.cpp    Synchronous realtime audio input/output class (blocking)
-
-Filters:       Filter.cpp      Filter master class
+Filters:       Filter.h        Filter master class
+               Iir.h           General infinite-impulse response filter
+               Fir.h           General finite-impulse response filter
                OneZero.cpp     One zero filter
                OnePole.cpp     One pole filter
                PoleZero.cpp    One pole/one zero filter
@@ -104,15 +99,16 @@ Filters:       Filter.cpp      Filter master class
                BiQuad.cpp      Two pole/two zero filter
                FormSwep.cpp    Sweepable biquad filter (goes to target by rate)
                Delay.cpp       Non-interpolating delay line class
-               DelayL.cpp      Linearly interpolating delay line (subclass of Delay)
-               DelayA.cpp      Allpass interpolating delay line (subclass of Delay)
+               DelayL.cpp      Linearly interpolating delay line
+               DelayA.cpp      Allpass interpolating delay line
+               TapDelay.cpp    Multi-tap non-interpolating delay line class
 
-Non-Linear:    JetTabl.cpp     Cubic jet non-linearity
-               BowTabl.cpp     x^(-3) Bow non-linearity
-               ReedTabl.cpp    One breakpoint saturating reed non-linearity
+Non-Linear:    JetTabl.h       Cubic jet non-linearity
+               BowTabl.h       x^(-3) Bow non-linearity
+               ReedTabl.h      One breakpoint saturating reed non-linearity
                                 
-Derived:       Modulate.cpp    Periodic and random vibrato: WvIn, SubNoise, OnePole
-               SingWave.cpp    Looping wave table with randomness: Modulate, WaveLoop, Envelope
+Derived:       Modulate.cpp    Periodic and random vibrato: WvIn, Noise, OnePole
+               SingWave.cpp    Looping wave table with randomness: Modulate, FileLoop, Envelope
 
 
 ********** INSTRUMENTS AND ALGORITHMS **************
@@ -121,45 +117,48 @@ Each class is listed either with some of the unit generators it uses,
 or in terms of the algorithm it implements.  All inherit from Instrmnt,
 which inherits from Stk.
 
-Simple.cpp      Simple Instrument              Pulse oscillator + resonant filtered noise
-Plucked.cpp     Basic Plucked String           DelayA, OneZero, OnePole, Noise
-StifKarp.cpp    Plucked String with Stiffness  DelayA, DelayL, OneZero, BiQuad, Noise
-PluckTwo.cpp    Not So Basic Pluck             DelayL, DlineA, OneZero
-Mandolin.cpp    Commuted Mandolin              <<flavor of PluckTwo>>
-Bowed.cpp       So So Bowed String             DelayL, BowTabl, OnePole, BiQuad, WaveLoop, ADSR
-Brass.cpp       Not So Bad Brass Instrument    DelayA, BiQuad, PoleZero, ADSR, WaveLoop
-Clarinet.cpp    Pretty Good Clarinet           DelayL, ReedTabl, OneZero, Envelope, Noise, WaveLoop
-BlowHole.cpp    Clarinet w/ Tone & Vent Holes  DelayL, ReedTabl, OneZero, Envelope, Noise, WaveLoop, PoleZero
-Saxofony.cpp    A Faux Saxophone               DelayL, ReedTabl, OneZero, Envelope, Noise, WaveLoop
-Flute.cpp       Pretty Good Flute              JetTabl, DelayL, OnePole, PoleZero, Noise, ADSR, WaveLoop
-BlowBotl.cpp    Blown Bottle                   JetTabl, BiQuad, PoleZero, Noise, ADSR, WaveLoop
-BandedWG.cpp    Banded Waveguide Meta-Object   Delay, BowTabl, ADSR, BiQuad
-Modal.cpp       N Resonances                   Envelope, WaveLoop, BiQuad, OnePole
-ModalBar.cpp    Various presets                4 Resonance Models
-FM.cpp          N Operator FM Master           ADSR, WaveLoop, TwoZero
-HevyMetl.cpp    Distorted FM Synthesizer       3 Cascade with FB Modulator
-PercFlut.cpp    Percussive Flute               3 Cascade Operators
-Rhodey.cpp      Rhodes-Like Electric Piano     2 Parallel Simple FMs
-Wurley.cpp      Wurlitzer Electric Piano       2 Parallel Simple FMs
-TubeBell.cpp    Classic FM Bell                2 Parallel Simple FMs
-FMVoices.cpp    3 Formant FM Voice             3 Carriers Share 1 Modulator
-VoicForm.cpp    4 Formant Voice Synthesis      FormSwep, SingWave, OnePole, OneZero, Envelope, Noise
-BeeThree.cpp    Cheezy Additive Organ          4 Oscillators Additive
-Sampler.cpp     Sampling Synthesizer           5 each ADSR, WvIn, WaveLoop, OnePole
-Moog.cpp        Swept Filter                   Sampler with Swept Filter
-Resonate.cpp    Filtered Noise                 ADSR, BiQuad, Noise
-Drummer.cpp     Drum Synthesizer               Bunch of WvIns, and OnePole
-Shakers.cpp     PhISM statistical model for shakers and real-world sound effects
-Mesh2D.cpp      Two-dimensional, rectilinear digital waveguide mesh.
-Whistle.cpp     Hybrid physical/spectral model of a police whistle.
+Simple.cpp       Simple Instrument              Pulse oscillator + resonant filtered noise
+Plucked.cpp      Basic Plucked String           DelayA, OneZero, OnePole, Noise
+Twang.cpp        Not So Basic Pluck             DelayL, DlineA, Fir, allows commuted synthesis
+Mandolin.cpp     Commuted Mandolin              2 Twangs
+Guitar.cpp       N-String Guitar                N Twangs, bridge coupling, allows feedback and body filter
+StifKarp.cpp     Plucked String with Stiffness  DelayA, DelayL, OneZero, BiQuad, Noise
+Bowed.cpp        So So Bowed String             DelayL, BowTabl, OnePole, BiQuad, WaveLoop, ADSR
+Brass.cpp        Not So Bad Brass Instrument    DelayA, BiQuad, PoleZero, ADSR, WaveLoop
+Clarinet.cpp     Pretty Good Clarinet           DelayL, ReedTabl, OneZero, Envelope, Noise, WaveLoop
+BlowHole.cpp     Clarinet w/ Tone & Vent Holes  DelayL, ReedTabl, OneZero, Envelope, Noise, WaveLoop, PoleZero
+Saxofony.cpp     A Faux Saxophone               DelayL, ReedTabl, OneZero, Envelope, Noise, WaveLoop
+Flute.cpp        Pretty Good Flute              JetTabl, DelayL, OnePole, PoleZero, Noise, ADSR, WaveLoop
+BlowBotl.cpp     Blown Bottle                   JetTabl, BiQuad, PoleZero, Noise, ADSR, WaveLoop
+BandedWG.cpp     Banded Waveguide Meta-Object   Delay, BowTabl, ADSR, BiQuad
+Modal.cpp        N Resonances                   Envelope, WaveLoop, BiQuad, OnePole
+ModalBar.cpp     Various presets                4 Resonance Models
+FM.cpp           N Operator FM Master           ADSR, WaveLoop, TwoZero
+HevyMetl.cpp     Distorted FM Synthesizer       3 Cascade with FB Modulator
+PercFlut.cpp     Percussive Flute               3 Cascade Operators
+Rhodey.cpp       Rhodes-Like Electric Piano     2 Parallel Simple FMs
+Wurley.cpp       Wurlitzer Electric Piano       2 Parallel Simple FMs
+TubeBell.cpp     Classic FM Bell                2 Parallel Simple FMs
+FMVoices.cpp     3 Formant FM Voice             3 Carriers Share 1 Modulator
+VoicForm.cpp     4 Formant Voice Synthesis      FormSwep, SingWave, OnePole, OneZero, Envelope, Noise
+BeeThree.cpp     Cheezy Additive Organ          4 Oscillators Additive
+Sampler.cpp      Sampling Synthesizer           5 each ADSR, WvIn, WaveLoop, OnePole
+Moog.cpp         Swept Filter                   Sampler with Swept Filter
+Resonate.cpp     Filtered Noise                 ADSR, BiQuad, Noise
+Drummer.cpp      Drum Synthesizer               Bunch of WvIns, and OnePole
+Shakers.cpp      PhISM statistical model for shakers and real-world sound effects
+Mesh2D.cpp       Two-dimensional, rectilinear digital waveguide mesh.
+Whistle.cpp      Hybrid physical/spectral model of a police whistle.
 
-Effect.cpp      Effects Processor Base Class
-JCRev.cpp       Chowning Reverberator           3 series allpass units, 4 parallel combs, 2 stereo delays
-NRev.cpp        Another famous CCRMA Reverb	    8 allpass, 6 parallel comb filters
-PRCRev.cpp      Dirt Cheap Reverb by Cook	      2 allpass, 2 comb filters
-Flanger.cpp     Flanger Effects Processor       DelayL, WaveLoop
-Chorus.cpp      Chorus Effects Processor        DelayL, WaveLoop
-PitShift.cpp    Cheap Pitch Shifter             DelayL
+Effect.h         Effects Processor Base Class
+JCRev.cpp        Chowning Reverberator           3 series allpass units, 4 parallel combs, 2 stereo delays
+NRev.cpp         Another famous CCRMA Reverb	    8 allpass, 6 parallel comb filters
+PRCRev.cpp       Dirt Cheap Reverb by Cook	      2 allpass, 2 comb filters
+FreeVerb.cpp     Jezar at Dreampoint's FreeVerb  4 allpass, 8 lowpass comb filters
+Flanger.cpp      Flanger Effects Processor       DelayL, WaveLoop
+Chorus.cpp       Chorus Effects Processor        DelayL, WaveLoop
+PitShift.cpp     Cheap Pitch Shifter             DelayL
+LentPitShift.cpp Pitch Shifter based Lent Algorithm
 
 
 ***********   OTHER SUPPORT CLASSES AND FILES   **************
@@ -174,7 +173,7 @@ effects.cpp     Effects demonstration program
 ragamatic.cpp   Nirvana just waiting to happen
 
 Skini.cpp	      SKINI file/message parser object
-SKINI.msg	      #defines for often used and universal MIDI/SKINI symbols
-SKINI.tbl	      Table of SKINI messages
+SKINImsg.h	      #defines for often used and universal MIDI/SKINI symbols
+SKINItbl.h	      Table of SKINI messages
 
 

iOS/README-iOS.md

@@ -0,0 +1,94 @@
+This file contains instructions for integrating the STK in Xcode projects and solutions to common integration issues. 
+
+## Setup
+
+### If you have [Cocoapods](http://cocoapods.org/)
+
+1. Add `pod 'STK', '~> 4.5'` to your Podfile.
+
+1. Run `pod install`
+
+### If you don't have Cocoapods
+
+1. Clone or [download][download_link] the STK into your project's directory.
+
+1. Open the **STK for iOS** folder, and drag and drop **STK.xcodeproj** into your Xcode project.
+
+1. Open your project's settings, open the *Build Phases* tab. In the *Link Binary with Libraries* section, add **libSTK.a**. 
+![][linking_libSTK_screenshot]
+
+1. In your project's settings, open the *Build Settings* tab. In the *Search Paths* section, double click on the field to the right of *Header Search Paths*, and add the path to the STK's **include** directory relative to your Xcode project's directory.
+![][header_search_paths_screenshot]
+
+
+## Usage
+
+1. Import the STK classes in the source files you require. 
+  * E.g. `#import "SineWave.h"`
+
+1. Change the extension of Objective-C files that import STK files to **.mm**. 
+  * E.g. **ViewController.m** —> **ViewController.mm**
+
+You can also look at the [iOS Demo project](..projects/demo/iOS%20Demo) for a sample usage. 
+
+
+## Troubleshooting
+
+### 'FileName.h' file not found
+
+If you get this error when `#import`ing an STK header, you have added the wrong header search path for the STK in your project's settings (see Step 4 in Setup)
+
+The STK's header search path you need to add is the path to the STK's **include** directory relative to your project's directory (as if you were `cd`ing into it). For example, it is `stk/include/` if the stk directory is inside your project's directory, but it is `../stk/include/` if both share the same directory. 
+
+If this problem doesn't go away:
+
+1. Delete **STK.xcodeproj** from your Xcode project
+1. Move the STK directory within your project's directory. 
+1. Follow step 1 from **Setup**, add `stk/include` to the *Header Search Paths*.
+
+If that doesn't solve it:
+Install Cocoapods and use it to install the STK. It takes one minute and will make your life easier. Visit the [Cocoapods website](http://cocoapods.org/) for installation instructions. 
+
+### FileRead::open: could not open or find file (../../rawwaves/filename.raw)!
+
+If you use a class that makes use of raw waves (such as `Mandolin`, `Wurley`, or `Rhodey`) you need to make sure that the STK's raw wave files are copied into your bundle and that the STK knows where they are. You'll know you need to if you get this runtime error:
+`FileRead::open: could not open or find file (../../rawwaves/filename.raw)!`
+
+#### If you're using Cocoapods
+
+Add this code before using a class that needs the raw waves: 
+```objective-c
+stk::Stk::setRawwavePath([[[NSBundle mainBundle] pathForResource:@"rawwaves" ofType:@"bundle"] UTF8String]);
+```
+
+#### If you're not using Cocoapods
+
+1. Open your project's settings, open the *Build Phases* tab. 
+1. In the *Copy Bundle Resources*, drag and drop **rawwaves.bundle** (it's located in **STK.xcodeproj**'s **Helpers** folder). 
+1. Then add this code before using a class that needs the raw waves: 
+
+```objective-c
+NSBundle *rawwaveBundle = [NSBundle bundleWithURL:[[NSBundle mainBundle] URLForResource:@"rawwaves" withExtension:@"bundle"]];
+stk::Stk::setRawwavePath([[rawwaveBundle resourcePath] UTF8String]);
+```
+
+
+### rawwaves.bundle: No such file or directory
+
+This means that **rawwaves.bundle** hasn't been copied to the build folder, so you'll need to do it manually:
+
+Select the rawwaves scheme:
+
+![][rawwaves_scheme_screenshot]
+  
+Build it (⌘+B)  then build your project's main scheme. 
+
+### Apple Mach-O Linker Error
+
+This means that **STKLib.a** isn't being linked to your binary. Follow step 2 above in [Setup](#setup). 
+
+
+[download_link]: https://github.com/thestk/stk/archive/master.zip
+[linking_libSTK_screenshot]: http://i.imgur.com/cLbGrtq.png
+[header_search_paths_screenshot]: http://i.imgur.com/iBTC06h.png
+[rawwaves_scheme_screenshot]: http://i.imgur.com/PKd7epf.png

iOS/STK.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:STK for iOS.xcodeproj">
+   </FileRef>
+</Workspace>

iOS/demo/README.MD

@@ -0,0 +1,10 @@
+##iOS Demo Xcode project
+
+This project briefly shows how to manually integrate the STK static library into an Xcode project. See the **README** file in the STK's `iOS` directory for precise instructions.
+
+Currently, this project does not output sound, it only shows how to generate audio samples from the STK classes within an iOS project, and how to control STK objects via UI controls.
+
+Note the following:
+
+ * ViewController needs to be renamed with the **.mm** extension as it's importing STK files, which are C++.
+ * The header search paths in the *Build Settings* of **iOS Demo.xcodeproj** point to `../../include/` because the STK's `include` directory is two directories up relative to it.

iOS/demo/iOS Demo.xcodeproj/project.pbxproj

@@ -0,0 +1,524 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		B02FD53618C520D60009ECA9 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B02FD53518C520D60009ECA9 /* Foundation.framework */; };
+		B02FD53818C520D60009ECA9 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B02FD53718C520D60009ECA9 /* CoreGraphics.framework */; };
+		B02FD53A18C520D60009ECA9 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B02FD53918C520D60009ECA9 /* UIKit.framework */; };
+		B02FD54018C520D60009ECA9 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = B02FD53E18C520D60009ECA9 /* InfoPlist.strings */; };
+		B02FD54218C520D60009ECA9 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = B02FD54118C520D60009ECA9 /* main.m */; };
+		B02FD54618C520D60009ECA9 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = B02FD54518C520D60009ECA9 /* AppDelegate.m */; };
+		B02FD54818C520D60009ECA9 /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = B02FD54718C520D60009ECA9 /* Images.xcassets */; };
+		B02FD54F18C520D70009ECA9 /* XCTest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B02FD54E18C520D70009ECA9 /* XCTest.framework */; };
+		B02FD55018C520D70009ECA9 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B02FD53518C520D60009ECA9 /* Foundation.framework */; };
+		B02FD55118C520D70009ECA9 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B02FD53918C520D60009ECA9 /* UIKit.framework */; };
+		B02FD55918C520D70009ECA9 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = B02FD55718C520D70009ECA9 /* InfoPlist.strings */; };
+		B02FD55B18C520D70009ECA9 /* iOS_DemoTests.m in Sources */ = {isa = PBXBuildFile; fileRef = B02FD55A18C520D70009ECA9 /* iOS_DemoTests.m */; };
+		B02FD57018C521560009ECA9 /* ViewController.mm in Sources */ = {isa = PBXBuildFile; fileRef = B02FD56F18C521560009ECA9 /* ViewController.mm */; };
+		B0779A8718D376F5004DA9B7 /* libSTK.a in Frameworks */ = {isa = PBXBuildFile; fileRef = B0779A8418D376A6004DA9B7 /* libSTK.a */; };
+		B0779A8B18D37C13004DA9B7 /* rawwaves.bundle in Resources */ = {isa = PBXBuildFile; fileRef = B0779A8618D376A6004DA9B7 /* rawwaves.bundle */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		B02FD55218C520D70009ECA9 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = B02FD52A18C520D60009ECA9 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = B02FD53118C520D60009ECA9;
+			remoteInfo = "iOS Demo";
+		};
+		B0779A8318D376A6004DA9B7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = B0779A7E18D376A5004DA9B7 /* STK.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = B0AC5BEE18CB31DE00D860C0;
+			remoteInfo = STK;
+		};
+		B0779A8518D376A6004DA9B7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = B0779A7E18D376A5004DA9B7 /* STK.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = B0EC33B718CB73A70005787B;
+			remoteInfo = rawwaves;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		B02FD53218C520D60009ECA9 /* iOS Demo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "iOS Demo.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+		B02FD53518C520D60009ECA9 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; };
+		B02FD53718C520D60009ECA9 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; };
+		B02FD53918C520D60009ECA9 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; };
+		B02FD53D18C520D60009ECA9 /* iOS Demo-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "iOS Demo-Info.plist"; sourceTree = "<group>"; };
+		B02FD53F18C520D60009ECA9 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		B02FD54118C520D60009ECA9 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
+		B02FD54318C520D60009ECA9 /* iOS Demo-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "iOS Demo-Prefix.pch"; sourceTree = "<group>"; };
+		B02FD54418C520D60009ECA9 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
+		B02FD54518C520D60009ECA9 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
+		B02FD54718C520D60009ECA9 /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Images.xcassets; sourceTree = "<group>"; };
+		B02FD54D18C520D70009ECA9 /* iOS DemoTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "iOS DemoTests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; };
+		B02FD54E18C520D70009ECA9 /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; };
+		B02FD55618C520D70009ECA9 /* iOS DemoTests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "iOS DemoTests-Info.plist"; sourceTree = "<group>"; };
+		B02FD55818C520D70009ECA9 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		B02FD55A18C520D70009ECA9 /* iOS_DemoTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = iOS_DemoTests.m; sourceTree = "<group>"; };
+		B02FD56E18C521560009ECA9 /* ViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = "<group>"; };
+		B02FD56F18C521560009ECA9 /* ViewController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ViewController.mm; sourceTree = "<group>"; };
+		B0779A7E18D376A5004DA9B7 /* STK.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = STK.xcodeproj; path = ../STK.xcodeproj; sourceTree = "<group>"; };
+		B0779A8918D37977004DA9B7 /* README.MD */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = README.MD; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		B02FD52F18C520D60009ECA9 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B0779A8718D376F5004DA9B7 /* libSTK.a in Frameworks */,
+				B02FD53818C520D60009ECA9 /* CoreGraphics.framework in Frameworks */,
+				B02FD53A18C520D60009ECA9 /* UIKit.framework in Frameworks */,
+				B02FD53618C520D60009ECA9 /* Foundation.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		B02FD54A18C520D70009ECA9 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B02FD54F18C520D70009ECA9 /* XCTest.framework in Frameworks */,
+				B02FD55118C520D70009ECA9 /* UIKit.framework in Frameworks */,
+				B02FD55018C520D70009ECA9 /* Foundation.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		B02FD52918C520D60009ECA9 = {
+			isa = PBXGroup;
+			children = (
+				B0779A8918D37977004DA9B7 /* README.MD */,
+				B0779A7E18D376A5004DA9B7 /* STK.xcodeproj */,
+				B02FD53B18C520D60009ECA9 /* iOS Demo */,
+				B02FD55418C520D70009ECA9 /* iOS DemoTests */,
+				B02FD53418C520D60009ECA9 /* Frameworks */,
+				B02FD53318C520D60009ECA9 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		B02FD53318C520D60009ECA9 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				B02FD53218C520D60009ECA9 /* iOS Demo.app */,
+				B02FD54D18C520D70009ECA9 /* iOS DemoTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		B02FD53418C520D60009ECA9 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				B02FD53518C520D60009ECA9 /* Foundation.framework */,
+				B02FD53718C520D60009ECA9 /* CoreGraphics.framework */,
+				B02FD53918C520D60009ECA9 /* UIKit.framework */,
+				B02FD54E18C520D70009ECA9 /* XCTest.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		B02FD53B18C520D60009ECA9 /* iOS Demo */ = {
+			isa = PBXGroup;
+			children = (
+				B02FD54418C520D60009ECA9 /* AppDelegate.h */,
+				B02FD54518C520D60009ECA9 /* AppDelegate.m */,
+				B02FD56E18C521560009ECA9 /* ViewController.h */,
+				B02FD56F18C521560009ECA9 /* ViewController.mm */,
+				B02FD54718C520D60009ECA9 /* Images.xcassets */,
+				B02FD53C18C520D60009ECA9 /* Supporting Files */,
+			);
+			path = "iOS Demo";
+			sourceTree = "<group>";
+		};
+		B02FD53C18C520D60009ECA9 /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				B02FD53D18C520D60009ECA9 /* iOS Demo-Info.plist */,
+				B02FD53E18C520D60009ECA9 /* InfoPlist.strings */,
+				B02FD54118C520D60009ECA9 /* main.m */,
+				B02FD54318C520D60009ECA9 /* iOS Demo-Prefix.pch */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		B02FD55418C520D70009ECA9 /* iOS DemoTests */ = {
+			isa = PBXGroup;
+			children = (
+				B02FD55A18C520D70009ECA9 /* iOS_DemoTests.m */,
+				B02FD55518C520D70009ECA9 /* Supporting Files */,
+			);
+			path = "iOS DemoTests";
+			sourceTree = "<group>";
+		};
+		B02FD55518C520D70009ECA9 /* Supporting Files */ = {
+			isa = PBXGroup;
+			children = (
+				B02FD55618C520D70009ECA9 /* iOS DemoTests-Info.plist */,
+				B02FD55718C520D70009ECA9 /* InfoPlist.strings */,
+			);
+			name = "Supporting Files";
+			sourceTree = "<group>";
+		};
+		B0779A7F18D376A5004DA9B7 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				B0779A8418D376A6004DA9B7 /* libSTK.a */,
+				B0779A8618D376A6004DA9B7 /* rawwaves.bundle */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		B02FD53118C520D60009ECA9 /* iOS Demo */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = B02FD55E18C520D70009ECA9 /* Build configuration list for PBXNativeTarget "iOS Demo" */;
+			buildPhases = (
+				B02FD52E18C520D60009ECA9 /* Sources */,
+				B02FD52F18C520D60009ECA9 /* Frameworks */,
+				B02FD53018C520D60009ECA9 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "iOS Demo";
+			productName = "iOS Demo";
+			productReference = B02FD53218C520D60009ECA9 /* iOS Demo.app */;
+			productType = "com.apple.product-type.application";
+		};
+		B02FD54C18C520D70009ECA9 /* iOS DemoTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = B02FD56118C520D70009ECA9 /* Build configuration list for PBXNativeTarget "iOS DemoTests" */;
+			buildPhases = (
+				B02FD54918C520D70009ECA9 /* Sources */,
+				B02FD54A18C520D70009ECA9 /* Frameworks */,
+				B02FD54B18C520D70009ECA9 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				B02FD55318C520D70009ECA9 /* PBXTargetDependency */,
+			);
+			name = "iOS DemoTests";
+			productName = "iOS DemoTests";
+			productReference = B02FD54D18C520D70009ECA9 /* iOS DemoTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		B02FD52A18C520D60009ECA9 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0510;
+				ORGANIZATIONNAME = "Ariel Elkin";
+				TargetAttributes = {
+					B02FD54C18C520D70009ECA9 = {
+						TestTargetID = B02FD53118C520D60009ECA9;
+					};
+				};
+			};
+			buildConfigurationList = B02FD52D18C520D60009ECA9 /* Build configuration list for PBXProject "iOS Demo" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = B02FD52918C520D60009ECA9;
+			productRefGroup = B02FD53318C520D60009ECA9 /* Products */;
+			projectDirPath = "";
+			projectReferences = (
+				{
+					ProductGroup = B0779A7F18D376A5004DA9B7 /* Products */;
+					ProjectRef = B0779A7E18D376A5004DA9B7 /* STK.xcodeproj */;
+				},
+			);
+			projectRoot = "";
+			targets = (
+				B02FD53118C520D60009ECA9 /* iOS Demo */,
+				B02FD54C18C520D70009ECA9 /* iOS DemoTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXReferenceProxy section */
+		B0779A8418D376A6004DA9B7 /* libSTK.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libSTK.a;
+			remoteRef = B0779A8318D376A6004DA9B7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		B0779A8618D376A6004DA9B7 /* rawwaves.bundle */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = rawwaves.bundle;
+			remoteRef = B0779A8518D376A6004DA9B7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+/* End PBXReferenceProxy section */
+
+/* Begin PBXResourcesBuildPhase section */
+		B02FD53018C520D60009ECA9 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B0779A8B18D37C13004DA9B7 /* rawwaves.bundle in Resources */,
+				B02FD54018C520D60009ECA9 /* InfoPlist.strings in Resources */,
+				B02FD54818C520D60009ECA9 /* Images.xcassets in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		B02FD54B18C520D70009ECA9 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B02FD55918C520D70009ECA9 /* InfoPlist.strings in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		B02FD52E18C520D60009ECA9 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B02FD57018C521560009ECA9 /* ViewController.mm in Sources */,
+				B02FD54618C520D60009ECA9 /* AppDelegate.m in Sources */,
+				B02FD54218C520D60009ECA9 /* main.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		B02FD54918C520D70009ECA9 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B02FD55B18C520D70009ECA9 /* iOS_DemoTests.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		B02FD55318C520D70009ECA9 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = B02FD53118C520D60009ECA9 /* iOS Demo */;
+			targetProxy = B02FD55218C520D70009ECA9 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		B02FD53E18C520D60009ECA9 /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				B02FD53F18C520D60009ECA9 /* en */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+		B02FD55718C520D70009ECA9 /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				B02FD55818C520D70009ECA9 /* en */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		B02FD55C18C520D70009ECA9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		B02FD55D18C520D70009ECA9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				SDKROOT = iphoneos;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		B02FD55F18C520D70009ECA9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME = LaunchImage;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "iOS Demo/iOS Demo-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					../../include/,
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+				);
+				INFOPLIST_FILE = "iOS Demo/iOS Demo-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = app;
+			};
+			name = Debug;
+		};
+		B02FD56018C520D70009ECA9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME = LaunchImage;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "iOS Demo/iOS Demo-Prefix.pch";
+				HEADER_SEARCH_PATHS = (
+					../../include/,
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+				);
+				INFOPLIST_FILE = "iOS Demo/iOS Demo-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				WRAPPER_EXTENSION = app;
+			};
+			name = Release;
+		};
+		B02FD56218C520D70009ECA9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/iOS Demo.app/iOS Demo";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(SDKROOT)/Developer/Library/Frameworks",
+					"$(inherited)",
+					"$(DEVELOPER_FRAMEWORKS_DIR)",
+				);
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "iOS Demo/iOS Demo-Prefix.pch";
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				INFOPLIST_FILE = "iOS DemoTests/iOS DemoTests-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUNDLE_LOADER)";
+				WRAPPER_EXTENSION = xctest;
+			};
+			name = Debug;
+		};
+		B02FD56318C520D70009ECA9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(BUILT_PRODUCTS_DIR)/iOS Demo.app/iOS Demo";
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(SDKROOT)/Developer/Library/Frameworks",
+					"$(inherited)",
+					"$(DEVELOPER_FRAMEWORKS_DIR)",
+				);
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "iOS Demo/iOS Demo-Prefix.pch";
+				INFOPLIST_FILE = "iOS DemoTests/iOS DemoTests-Info.plist";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				TEST_HOST = "$(BUNDLE_LOADER)";
+				WRAPPER_EXTENSION = xctest;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		B02FD52D18C520D60009ECA9 /* Build configuration list for PBXProject "iOS Demo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B02FD55C18C520D70009ECA9 /* Debug */,
+				B02FD55D18C520D70009ECA9 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		B02FD55E18C520D70009ECA9 /* Build configuration list for PBXNativeTarget "iOS Demo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B02FD55F18C520D70009ECA9 /* Debug */,
+				B02FD56018C520D70009ECA9 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		B02FD56118C520D70009ECA9 /* Build configuration list for PBXNativeTarget "iOS DemoTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B02FD56218C520D70009ECA9 /* Debug */,
+				B02FD56318C520D70009ECA9 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = B02FD52A18C520D60009ECA9 /* Project object */;
+}

iOS/demo/iOS Demo.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:iOS Demo.xcodeproj">
+   </FileRef>
+</Workspace>

iOS/demo/iOS Demo.xcodeproj/project.xcworkspace/xcshareddata/iOS Demo.xccheckout

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDESourceControlProjectFavoriteDictionaryKey</key>
+	<false/>
+	<key>IDESourceControlProjectIdentifier</key>
+	<string>4E1BA790-84C0-4F40-AECE-98269B537CE6</string>
+	<key>IDESourceControlProjectName</key>
+	<string>iOS Demo</string>
+	<key>IDESourceControlProjectOriginsDictionary</key>
+	<dict>
+		<key>CB047168-D1C4-40BC-85A3-6EB0A20AD217</key>
+		<string>ssh://github.com/arielelkin/stk.git</string>
+	</dict>
+	<key>IDESourceControlProjectPath</key>
+	<string>iOS/Demo/iOS Demo.xcodeproj/project.xcworkspace</string>
+	<key>IDESourceControlProjectRelativeInstallPathDictionary</key>
+	<dict>
+		<key>CB047168-D1C4-40BC-85A3-6EB0A20AD217</key>
+		<string>../../../..</string>
+	</dict>
+	<key>IDESourceControlProjectURL</key>
+	<string>ssh://github.com/arielelkin/stk.git</string>
+	<key>IDESourceControlProjectVersion</key>
+	<integer>110</integer>
+	<key>IDESourceControlProjectWCCIdentifier</key>
+	<string>CB047168-D1C4-40BC-85A3-6EB0A20AD217</string>
+	<key>IDESourceControlProjectWCConfigurations</key>
+	<array>
+		<dict>
+			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
+			<string>public.vcs.git</string>
+			<key>IDESourceControlWCCIdentifierKey</key>
+			<string>CB047168-D1C4-40BC-85A3-6EB0A20AD217</string>
+			<key>IDESourceControlWCCName</key>
+			<string>stk</string>
+		</dict>
+	</array>
+</dict>
+</plist>

iOS/demo/iOS Demo/AppDelegate.h

@@ -0,0 +1,14 @@
+//
+//  AppDelegate.h
+//  iOS Demo
+//
+//  Created by Ariel Elkin on 03/03/2014.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@property (strong, nonatomic) UIWindow *window;
+
+@end

iOS/demo/iOS Demo/AppDelegate.m

@@ -0,0 +1,25 @@
+//
+//  AppDelegate.m
+//  iOS Demo
+//
+//  Created by Ariel Elkin on 03/03/2014.
+//
+
+#import "AppDelegate.h"
+#import "ViewController.h"
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
+    
+    ViewController *vc = [[ViewController alloc] initWithNibName:nil bundle:nil];
+    [self.window setRootViewController:vc];
+    
+    [self.window makeKeyAndVisible];
+    
+    return YES;
+}
+
+@end

iOS/demo/iOS Demo/Images.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,23 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "size" : "29x29",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "40x40",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "iphone",
+      "size" : "60x60",
+      "scale" : "2x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

iOS/demo/iOS Demo/Images.xcassets/LaunchImage.launchimage/Contents.json

@@ -0,0 +1,23 @@
+{
+  "images" : [
+    {
+      "orientation" : "portrait",
+      "idiom" : "iphone",
+      "extent" : "full-screen",
+      "minimum-system-version" : "7.0",
+      "scale" : "2x"
+    },
+    {
+      "orientation" : "portrait",
+      "idiom" : "iphone",
+      "subtype" : "retina4",
+      "extent" : "full-screen",
+      "minimum-system-version" : "7.0",
+      "scale" : "2x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

iOS/demo/iOS Demo/ViewController.h

@@ -0,0 +1,12 @@
+//
+//  ViewController.h
+//  iOS Demo
+//
+//  Created by Ariel Elkin on 03/03/2014.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface ViewController : UIViewController
+
+@end

iOS/demo/iOS Demo/ViewController.mm

@@ -0,0 +1,108 @@
+//
+//  ViewController.m
+//  iOS Demo
+//
+//  Created by Ariel Elkin on 03/03/2014.
+//
+
+#import "ViewController.h"
+
+#import "SineWave.h"
+#import "Brass.h"
+#import "Mandolin.h"
+
+@implementation ViewController {
+    stk::SineWave *sineWave;
+    stk::Brass *brass;
+}
+
+- (void)loadView {
+    self.view = [UIView new];
+    [self.view setBackgroundColor:[UIColor whiteColor]];
+    [self setupUI];
+}
+
+- (void)viewDidAppear:(BOOL)animated {
+    [super viewDidAppear:animated];
+    
+    NSUInteger samplesToGenerate = 1000;
+    
+    //Test SineWave:
+    sineWave = new stk::SineWave();
+    
+    for (NSUInteger i = 0; i < samplesToGenerate; i ++) {
+        float sample = sineWave->tick();
+        NSLog(@"SineWave sample: %f", sample);
+    }
+    
+    //Test Brass:
+    brass = new stk::Brass();
+    
+    brass->noteOn(400, 1);
+    
+    for (NSUInteger i = 0; i < samplesToGenerate; i ++) {
+        float sample = brass->tick();
+        NSLog(@"Brass sample: %f", sample);
+    }
+
+    //We're going to be making use of a class that needs
+    //raw wave files, we need to tell the STK where
+    //the files are:
+    stk::Stk::setRawwavePath([[[NSBundle mainBundle] pathForResource:@"rawwaves" ofType:@"bundle"] UTF8String]);
+
+
+    //Test Mandolin:
+    stk::Mandolin *mandolin = new stk::Mandolin(400);
+    
+    mandolin->pluck(1);
+    
+    for (NSUInteger i = 0; i < samplesToGenerate; i ++) {
+        float sample = mandolin->tick();
+        NSLog(@"Mandolin sample: %f", sample);
+    }
+    
+    
+    #pragma mark TODO - Audio playback
+}
+
+
+- (void)sineSliderMoved:(UISlider *)slider {
+    sineWave->setFrequency(slider.value);
+    NSLog(@"Setting SineWave frequency to %.2f", slider.value);
+}
+
+- (void)brassSliderMoved:(UISlider *)slider {
+    brass->setFrequency(slider.value);
+    NSLog(@"Setting Brass frequency to %.2f", slider.value);
+}
+
+- (void)setupUI {
+    
+    //Add slider to control sine wave frequency:
+    UISlider *sineSlider = [[UISlider alloc] init];
+    [sineSlider addTarget:self action:@selector(sineSliderMoved:) forControlEvents:UIControlEventValueChanged];
+    [sineSlider setMinimumValue:0];
+    [sineSlider setMaximumValue:800];
+    [sineSlider setTranslatesAutoresizingMaskIntoConstraints:NO];
+    [self.view addSubview:sineSlider];
+    
+    NSDictionary *metrics = @{@"sliderWidth": @200};
+    
+    NSArray *sliderConstraints = [NSLayoutConstraint constraintsWithVisualFormat:@"H:|-40-[sineSlider(sliderWidth)]" options:0 metrics:metrics views:@{@"sineSlider": sineSlider}];
+    [self.view addConstraints:sliderConstraints];
+    
+    //Add slider to control brass's frequency:
+    UISlider *brassSlider = [[UISlider alloc] init];
+    [brassSlider addTarget:self action:@selector(brassSliderMoved:) forControlEvents:UIControlEventValueChanged];
+    [brassSlider setMinimumValue:0];
+    [brassSlider setMaximumValue:800];
+    [brassSlider setTranslatesAutoresizingMaskIntoConstraints:NO];
+    [self.view addSubview:brassSlider];
+    
+    sliderConstraints = [NSLayoutConstraint constraintsWithVisualFormat:@"H:|-40-[brassSlider(sliderWidth)]" options:0 metrics:metrics views:@{@"brassSlider": brassSlider}];
+    [self.view addConstraints:sliderConstraints];
+    sliderConstraints = [NSLayoutConstraint constraintsWithVisualFormat:@"V:|-40-[sineSlider]-[brassSlider]" options:0 metrics:nil views:@{@"sineSlider": sineSlider, @"brassSlider": brassSlider}];
+    [self.view addConstraints:sliderConstraints];
+}
+
+@end

iOS/demo/iOS Demo/en.lproj/InfoPlist.strings

@@ -0,0 +1,2 @@
+/* Localized versions of Info.plist keys */
+

iOS/demo/iOS Demo/iOS Demo-Info.plist

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleDisplayName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>stk.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${PRODUCT_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>

iOS/demo/iOS Demo/iOS Demo-Prefix.pch

@@ -0,0 +1,16 @@
+//
+//  Prefix header
+//
+//  The contents of this file are implicitly included at the beginning of every source file.
+//
+
+#import <Availability.h>
+
+#ifndef __IPHONE_3_0
+#warning "This project uses features only available in iOS SDK 3.0 and later."
+#endif
+
+#ifdef __OBJC__
+    #import <UIKit/UIKit.h>
+    #import <Foundation/Foundation.h>
+#endif

iOS/demo/iOS Demo/main.m

@@ -0,0 +1,18 @@
+//
+//  main.m
+//  iOS Demo
+//
+//  Created by Ariel Elkin on 03/03/2014.
+//  Copyright (c) 2014 Ariel Elkin. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+#import "AppDelegate.h"
+
+int main(int argc, char * argv[])
+{
+    @autoreleasepool {
+        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
+    }
+}

iOS/demo/iOS DemoTests/en.lproj/InfoPlist.strings

@@ -0,0 +1,2 @@
+/* Localized versions of Info.plist keys */
+

iOS/demo/iOS DemoTests/iOS DemoTests-Info.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>stk.${PRODUCT_NAME:rfc1034identifier}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>

iOS/demo/iOS DemoTests/iOS_DemoTests.m

@@ -0,0 +1,34 @@
+//
+//  iOS_DemoTests.m
+//  iOS DemoTests
+//
+//  Created by Ariel Elkin on 03/03/2014.
+//  Copyright (c) 2014 Ariel Elkin. All rights reserved.
+//
+
+#import <XCTest/XCTest.h>
+
+@interface iOS_DemoTests : XCTestCase
+
+@end
+
+@implementation iOS_DemoTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testExample
+{
+    XCTFail(@"No implementation for \"%s\"", __PRETTY_FUNCTION__);
+}
+
+@end

include/ADSR.h

@@ -1,85 +1,179 @@
+#ifndef STK_ADSR_H
+#define STK_ADSR_H
+
+#include "Generator.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class ADSR
     \brief STK ADSR envelope class.
 
-    This Envelope subclass implements a
-    traditional ADSR (Attack, Decay,
-    Sustain, Release) envelope.  It
-    responds to simple keyOn and keyOff
-    messages, keeping track of its state.
-    The \e state = ADSR::DONE after the
-    envelope value reaches 0.0 in the
-    ADSR::RELEASE state.
+    This class implements a traditional ADSR (Attack, Decay, Sustain,
+    Release) envelope.  It responds to simple keyOn and keyOff
+    messages, keeping track of its state.  The \e state = ADSR::IDLE
+    before being triggered and after the envelope value reaches 0.0 in
+    the ADSR::RELEASE state.  All rate, target and level settings must
+    be non-negative.  All time settings are in seconds and must be
+    positive.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_ADSR_H
-#define STK_ADSR_H
-
-#include "Envelope.h"
-
-class ADSR : public Envelope
+class ADSR : public Generator
 {
  public:
 
-  //! Envelope states.
-  enum { ATTACK, DECAY, SUSTAIN, RELEASE, DONE };
+  //! ADSR envelope states.
+  enum {
+    ATTACK,   /*!< Attack */
+    DECAY,    /*!< Decay */
+    SUSTAIN,  /*!< Sustain */
+    RELEASE,  /*!< Release */
+    IDLE      /*!< Before attack / after release */
+  };
 
   //! Default constructor.
-  ADSR(void);
+  ADSR( void );
 
   //! Class destructor.
-  ~ADSR(void);
+  ~ADSR( void );
 
   //! Set target = 1, state = \e ADSR::ATTACK.
-  void keyOn(void);
+  void keyOn( void );
 
   //! Set target = 0, state = \e ADSR::RELEASE.
-  void keyOff(void);
+  void keyOff( void );
 
-  //! Set the attack rate.
-  void setAttackRate(StkFloat rate);
+  //! Set the attack rate (gain / sample).
+  void setAttackRate( StkFloat rate );
 
-  //! Set the decay rate.
-  void setDecayRate(StkFloat rate);
+  //! Set the target value for the attack (default = 1.0).
+  void setAttackTarget( StkFloat target );
+
+  //! Set the decay rate (gain / sample).
+  void setDecayRate( StkFloat rate );
 
   //! Set the sustain level.
-  void setSustainLevel(StkFloat level);
+  void setSustainLevel( StkFloat level );
 
-  //! Set the release rate.
-  void setReleaseRate(StkFloat rate);
+  //! Set the release rate (gain / sample).
+  void setReleaseRate( StkFloat rate );
 
-  //! Set the attack rate based on a time duration.
-  void setAttackTime(StkFloat time);
+  //! Set the attack rate based on a time duration (seconds).
+  void setAttackTime( StkFloat time );
 
-  //! Set the decay rate based on a time duration.
-  void setDecayTime(StkFloat time);
+  //! Set the decay rate based on a time duration (seconds).
+  void setDecayTime( StkFloat time );
 
-  //! Set the release rate based on a time duration.
-  void setReleaseTime(StkFloat time);
+  //! Set the release rate based on a time duration (seconds).
+  void setReleaseTime( StkFloat time );
 
-  //! Set sustain level and attack, decay, and release time durations.
-  void setAllTimes(StkFloat aTime, StkFloat dTime, StkFloat sLevel, StkFloat rTime);
+  //! Set sustain level and attack, decay, and release time durations (seconds).
+  void setAllTimes( StkFloat aTime, StkFloat dTime, StkFloat sLevel, StkFloat rTime );
 
-  //! Set the target value.
-  void setTarget(StkFloat target);
+  //! Set a sustain target value and attack or decay from current value to target.
+  void setTarget( StkFloat target );
 
-  //! Return the current envelope \e state (ATTACK, DECAY, SUSTAIN, RELEASE, DONE).
-  int getState(void) const;
+  //! Return the current envelope \e state (ATTACK, DECAY, SUSTAIN, RELEASE, IDLE).
+  int getState( void ) const { return state_; };
 
-  //! Set to state = ADSR::SUSTAIN with current and target values of \e aValue.
-  void setValue(StkFloat value);
+  //! Set to state = ADSR::SUSTAIN with current and target values of \e value.
+  void setValue( StkFloat value );
+
+  //! 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:  
 
-  StkFloat computeSample( void );
+  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
+  int state_;
+  StkFloat value_;
+  StkFloat target_;
   StkFloat attackRate_;
   StkFloat decayRate_;
-  StkFloat sustainLevel_;
   StkFloat releaseRate_;
+  StkFloat releaseTime_;
+  StkFloat sustainLevel_;
 };
 
+inline StkFloat ADSR :: tick( void )
+{
+  switch ( state_ ) {
+
+  case ATTACK:
+    value_ += attackRate_;
+    if ( value_ >= target_ ) {
+      value_ = target_;
+      target_ = sustainLevel_;
+	    state_ = DECAY;
+    }
+    lastFrame_[0] = value_;
+    break;
+
+  case DECAY:
+    if ( value_ > sustainLevel_ ) {
+      value_ -= decayRate_;
+      if ( value_ <= sustainLevel_ ) {
+        value_ = sustainLevel_;
+        state_ = SUSTAIN;
+      }
+    }
+    else {
+      value_ += decayRate_; // attack target < sustain level
+      if ( value_ >= sustainLevel_ ) {
+        value_ = sustainLevel_;
+        state_ = SUSTAIN;
+      }
+    }
+    lastFrame_[0] = value_;
+    break;
+
+  case RELEASE:
+    value_ -= releaseRate_;
+    if ( value_ <= 0.0 ) {
+      value_ = 0.0;
+      state_ = IDLE;
+    }
+    lastFrame_[0] = value_;
+
+  }
+
+  return value_;
+}
+
+inline StkFrames& ADSR :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "ADSR::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 = ADSR::tick();
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/Asymp.h

@@ -1,3 +1,10 @@
+#ifndef STK_ASYMP_H
+#define STK_ASYMP_H
+
+#include "Generator.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Asymp
     \brief STK asymptotic curve envelope class
@@ -6,7 +13,7 @@
     which asymptotically approaches a target value.
     The algorithm used is of the form:
 
-    x[n] = a x[n-1] + (1-a) target,
+    y[n] = a y[n-1] + (1-a) target,
 
     where a = exp(-T/tau), T is the sample period, and
     tau is a time constant.  The user can set the time
@@ -19,32 +26,27 @@
     to \e keyOn and \e keyOff messages by ramping to
     1.0 on keyOn and to 0.0 on keyOff.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_ASYMP_H
-#define STK_ASYMP_H
-
-#include "Envelope.h"
-
 const StkFloat TARGET_THRESHOLD = 0.000001;
 
-class Asymp : public Envelope
+class Asymp : public Generator
 {
  public:
 
   //! Default constructor.
-  Asymp(void);
+  Asymp( void );
 
   //! Class destructor.
-  ~Asymp(void);
+  ~Asymp( void );
 
   //! Set target = 1.
-  void keyOn(void);
+  void keyOn( void );
 
   //! Set target = 0.
-  void keyOff(void);
+  void keyOff( void );
 
   //! Set the asymptotic rate via the time factor \e tau (must be > 0).
   /*!
@@ -53,20 +55,92 @@ class Asymp : public Envelope
     fast approach rates, while values greater than 1.0 produce rather
     slow rates.
   */
-  void setTau(StkFloat tau);
+  void setTau( StkFloat tau );
 
   //! Set the asymptotic rate based on a time duration (must be > 0).
-  void setTime(StkFloat time);
+  void setTime( StkFloat time );
+
+  //! Set the asymptotic rate such that the target value is perceptually reached (to within -60dB of the target) in \e t60 seconds.
+  void setT60( StkFloat t60 );
 
   //! Set the target value.
-  void setTarget(StkFloat target);
+  void setTarget( StkFloat target );
+
+  //! Set current and target values to \e value.
+  void setValue( StkFloat value );
+
+  //! Return the current envelope \e state (0 = at target, 1 otherwise).
+  int getState( void ) const { return state_; };
+
+  //! 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:
 
-  StkFloat computeSample( void );
+  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
+  StkFloat value_;
+  StkFloat target_;
   StkFloat factor_;
   StkFloat constant_;
+  int state_;
 };
 
+inline StkFloat Asymp :: tick( void )
+{
+  if ( state_ ) {
+
+    value_ = factor_ * value_ + constant_;
+
+    // Check threshold.
+    if ( target_ > value_ ) {
+      if ( target_ - value_ <= TARGET_THRESHOLD ) {
+        value_ = target_;
+        state_ = 0;
+      }
+    }
+    else {
+      if ( value_ - target_ <= TARGET_THRESHOLD ) {
+        value_ = target_;
+        state_ = 0;
+      }
+    }
+    lastFrame_[0] = value_;
+  }
+
+  return value_;
+}
+
+inline StkFrames& Asymp :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Asymp::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 = Asymp::tick();
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BandedWG.h

@@ -1,3 +1,14 @@
+#ifndef STK_BANDEDWG_H
+#define STK_BANDEDWG_H
+
+#include "Instrmnt.h"
+#include "DelayL.h"
+#include "BowTable.h"
+#include "ADSR.h"
+#include "BiQuad.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class BandedWG
     \brief Banded waveguide modeling class.
@@ -25,64 +36,66 @@
          - Tibetan Bowl = 3
 
     by Georg Essl, 1999 - 2004.
-    Modified for Stk 4.0 by Gary Scavone.
+    Modified for STK 4.0 by Gary Scavone.
 */
 /***************************************************/
 
-#ifndef STK_BANDEDWG_H
-#define STK_BANDEDWG_H
-
 const int MAX_BANDED_MODES = 20;
 
-#include "Instrmnt.h"
-#include "DelayL.h"
-#include "BowTable.h"
-#include "ADSR.h"
-#include "BiQuad.h"
-
 class BandedWG : public Instrmnt
 {
  public:
   //! Class constructor.
-  BandedWG();
+  BandedWG( void );
 
   //! Class destructor.
-  ~BandedWG();
+  ~BandedWG( void );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
   //! Set strike position (0.0 - 1.0).
-  void setStrikePosition(StkFloat position);
+  void setStrikePosition( StkFloat position );
 
   //! Select a preset.
-  void setPreset(int preset);
+  void setPreset( int preset );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Apply bow velocity/pressure to instrument with given amplitude and rate of increase.
-  void startBowing(StkFloat amplitude, StkFloat rate);
+  void startBowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease bow velocity/breath pressure with given rate of decrease.
-  void stopBowing(StkFloat rate);
+  void stopBowing( StkFloat rate );
 
   //! Pluck the instrument with given amplitude.
-  void pluck(StkFloat amp);
+  void pluck( StkFloat amp );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   bool doPluck_;
   bool trackVelocity_;
   int nModes_;
@@ -108,4 +121,33 @@ class BandedWG : public Instrmnt
 
 };
 
+inline StkFrames& BandedWG :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "BandedWG::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BeeThree.h

@@ -1,3 +1,10 @@
+#ifndef STK_BEETHREE_H
+#define STK_BEETHREE_H
+
+#include "FM.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class BeeThree
     \brief STK Hammond-oid organ FM synthesis instrument.
@@ -28,15 +35,10 @@
     type who should worry about this (making
     money) worry away.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_BEETHREE_H
-#define STK_BEETHREE_H
-
-#include "FM.h"
-
 class BeeThree : public FM
 {
  public:
@@ -44,17 +46,82 @@ class BeeThree : public FM
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  BeeThree();
+  BeeThree( void );
 
   //! Class destructor.
-  ~BeeThree();
+  ~BeeThree( void );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
 };
 
+inline StkFloat BeeThree :: tick( unsigned int )
+{
+  StkFloat temp;
+
+  if ( modDepth_ > 0.0 )	{
+    temp = 1.0 + ( modDepth_ * vibrato_.tick() * 0.1 );
+    waves_[0]->setFrequency( baseFrequency_ * temp * ratios_[0] );
+    waves_[1]->setFrequency( baseFrequency_ * temp * ratios_[1] );
+    waves_[2]->setFrequency( baseFrequency_ * temp * ratios_[2] );
+    waves_[3]->setFrequency( baseFrequency_ * temp * ratios_[3] );
+  }
+
+  waves_[3]->addPhaseOffset( twozero_.lastOut() );
+  temp = control1_ * 2.0 * gains_[3] * adsr_[3]->tick() * waves_[3]->tick();
+  twozero_.tick( temp );
+
+  temp += control2_ * 2.0 * gains_[2] * adsr_[2]->tick() * waves_[2]->tick();
+  temp += gains_[1] * adsr_[1]->tick() * waves_[1]->tick();
+  temp += gains_[0] * adsr_[0]->tick() * waves_[0]->tick();
+
+  lastFrame_[0] = temp * 0.125;
+  return lastFrame_[0];
+}
+
+inline StkFrames& BeeThree :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "BeeThree::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BiQuad.h

@@ -1,23 +1,23 @@
-/***************************************************/
-/*! \class BiQuad
-    \brief STK biquad (two-pole, two-zero) filter class.
-
-    This protected Filter subclass implements a
-    two-pole, two-zero digital filter.  A method
-    is provided for creating a resonance in the
-    frequency response while maintaining a constant
-    filter gain.
-
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
-*/
-/***************************************************/
-
 #ifndef STK_BIQUAD_H
 #define STK_BIQUAD_H
 
 #include "Filter.h"
 
-class BiQuad : protected Filter
+namespace stk {
+
+/***************************************************/
+/*! \class BiQuad
+    \brief STK biquad (two-pole, two-zero) filter class.
+
+    This class implements a two-pole, two-zero digital filter.
+    Methods are provided for creating a resonance or notch in the
+    frequency response while maintaining a constant filter gain.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
+
+class BiQuad : public Filter
 {
 public:
 
@@ -25,25 +25,28 @@ public:
   BiQuad();
 
   //! Class destructor.
-  virtual ~BiQuad();
+  ~BiQuad();
 
-  //! Clears all internal states of the filter.
-  void clear(void);
+  //! A function to enable/disable the automatic updating of class data when the STK sample rate changes.
+  void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; };
+
+  //! Set all filter coefficients.
+  void setCoefficients( StkFloat b0, StkFloat b1, StkFloat b2, StkFloat a1, StkFloat a2, bool clearState = false );
 
   //! Set the b[0] coefficient value.
-  void setB0(StkFloat b0);
+  void setB0( StkFloat b0 ) { b_[0] = b0; };
 
   //! Set the b[1] coefficient value.
-  void setB1(StkFloat b1);
+  void setB1( StkFloat b1 ) { b_[1] = b1; };
 
   //! Set the b[2] coefficient value.
-  void setB2(StkFloat b2);
+  void setB2( StkFloat b2 ) { b_[2] = b2; };
 
   //! Set the a[1] coefficient value.
-  void setA1(StkFloat a1);
+  void setA1( StkFloat a1 ) { a_[1] = a1; };
 
   //! Set the a[2] coefficient value.
-  void setA2(StkFloat a2);
+  void setA2( StkFloat a2 ) { a_[2] = a2; };
 
   //! Sets the filter coefficients for a resonance at \e frequency (in Hz).
   /*!
@@ -56,17 +59,20 @@ public:
     filter frequency response has a resonance at the given \e
     frequency.  The closer the poles are to the unit-circle (\e radius
     close to one), the narrower the resulting resonance width.
+    An unstable filter will result for \e radius >= 1.0.  The
+    \e frequency value should be between zero and half the sample rate.
   */
-  void setResonance(StkFloat frequency, StkFloat radius, bool normalize = false);
+  void setResonance( StkFloat frequency, StkFloat radius, bool normalize = false );
 
   //! Set the filter coefficients for a notch at \e frequency (in Hz).
   /*!
     This method determines the filter coefficients corresponding to
     two complex-conjugate zeros with the given \e frequency (in Hz)
-    and \e radius from the z-plane origin.  No filter normalization
-    is attempted.
+    and \e radius from the z-plane origin.  No filter normalization is
+    attempted.  The \e frequency value should be between zero and half
+    the sample rate.  The \e radius value should be positive.
   */
-  void setNotch(StkFloat frequency, StkFloat radius);
+  void setNotch( StkFloat frequency, StkFloat radius );
 
   //! Sets the filter zeroes for equal resonance gain.
   /*!
@@ -75,38 +81,106 @@ public:
     where R is the pole radius setting.
 
   */
-  void setEqualGainZeroes();
-
-  //! Set the filter gain.
-  /*!
-    The gain is applied at the filter input and does not affect the
-    coefficient values.  The default gain value is 1.0.
-   */
-  void setGain(StkFloat gain);
-
-  //! Return the current filter gain.
-  StkFloat getGain(void) const;
+  void setEqualGainZeroes( void );
 
   //! Return the last computed output value.
-  StkFloat lastOut(void) const;
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
-  //! Input one sample to the filter and return one output.
-  virtual StkFloat tick(StkFloat sample);
+  //! Input one sample to the filter and return a reference to one output.
+  StkFloat tick( StkFloat input );
 
   //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
   /*!
-    The \c channel argument should be zero or greater (the first
-    channel is specified by 0).  An StkError will be thrown if the \c
-    channel argument is equal to or greater than the number of
-    channels in the StkFrames object.
+    The StkFrames argument reference is returned.  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.
   */
-  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+
+  //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
  protected:
 
-  // This function must be implemented in all subclasses. It is used
-  // to get around a C++ problem with overloaded virtual functions.
-  virtual StkFloat computeSample( StkFloat input );
+  virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 };
 
+inline StkFloat BiQuad :: tick( StkFloat input )
+{
+  inputs_[0] = gain_ * input;
+  lastFrame_[0] = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
+  lastFrame_[0] -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
+  inputs_[2] = inputs_[1];
+  inputs_[1] = inputs_[0];
+  outputs_[2] = outputs_[1];
+  outputs_[1] = lastFrame_[0];
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& BiQuad :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "BiQuad::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 ) {
+    inputs_[0] = gain_ * *samples;
+    *samples = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
+    *samples -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
+    inputs_[2] = inputs_[1];
+    inputs_[1] = inputs_[0];
+    outputs_[2] = outputs_[1];
+    outputs_[1] = *samples;
+  }
+
+  lastFrame_[0] = outputs_[1];
+  return frames;
+}
+
+inline StkFrames& BiQuad :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "BiQuad::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    inputs_[0] = gain_ * *iSamples;
+    *oSamples = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
+    *oSamples -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
+    inputs_[2] = inputs_[1];
+    inputs_[1] = inputs_[0];
+    outputs_[2] = outputs_[1];
+    outputs_[1] = *oSamples;
+  }
+
+  lastFrame_[0] = outputs_[1];
+  return iFrames;
+}
+
+} // stk namespace
+
+#endif
+

include/Blit.h

@@ -1,3 +1,12 @@
+#ifndef STK_BLIT_H
+#define STK_BLIT_H
+
+#include "Generator.h"
+#include <cmath>
+#include <limits>
+
+namespace stk {
+
 /***************************************************/
 /*! \class Blit
     \brief STK band-limited impulse train class.
@@ -21,11 +30,6 @@
 */
 /***************************************************/
 
-#ifndef STK_BLIT_H
-#define STK_BLIT_H
-
-#include "Generator.h"
-
 class Blit: public Generator
 {
  public:
@@ -68,10 +72,25 @@ class Blit: public Generator
   */
   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 );
-  StkFloat computeSample( void );
 
   unsigned int nHarmonics_;
   unsigned int m_;
@@ -81,4 +100,52 @@ class Blit: public Generator
 
 };
 
+inline StkFloat Blit :: tick( void )
+{
+  // The code below implements the SincM algorithm of Stilson and
+  // Smith with an additional scale factor of P / M applied to
+  // normalize the output.
+
+  // A fully optimized version of this code 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 at the sinc peak, which has a limiting
+  // value of 1.0.
+  StkFloat tmp, denominator = sin( phase_ );
+  if ( denominator <= std::numeric_limits<StkFloat>::epsilon() )
+    tmp = 1.0;
+  else {
+    tmp =  sin( m_ * phase_ );
+    tmp /= m_ * denominator;
+  }
+
+  phase_ += rate_;
+  if ( phase_ >= PI ) phase_ -= PI;
+
+  lastFrame_[0] = tmp;
+	return lastFrame_[0];
+}
+
+inline StkFrames& Blit :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Blit::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 = Blit::tick();
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BlitSaw.h

@@ -1,3 +1,12 @@
+#ifndef STK_BLITSAW_H
+#define STK_BLITSAW_H
+
+#include "Generator.h"
+#include <cmath>
+#include <limits>
+
+namespace stk {
+
 /***************************************************/
 /*! \class BlitSaw
     \brief STK band-limited sawtooth wave class.
@@ -19,11 +28,6 @@
 */
 /***************************************************/
 
-#ifndef STK_BLITSAW_H
-#define STK_BLITSAW_H
-
-#include "Generator.h"
-
 class BlitSaw: public Generator
 {
  public:
@@ -54,10 +58,25 @@ class BlitSaw: public Generator
   */
   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 );
-  StkFloat computeSample( void );
 
   unsigned int nHarmonics_;
   unsigned int m_;
@@ -70,4 +89,60 @@ class BlitSaw: public Generator
 
 };
 
+inline StkFloat BlitSaw :: tick( void )
+{
+  // The code below implements the BLIT algorithm of Stilson and
+  // Smith, followed by a summation and filtering operation to produce
+  // a sawtooth waveform.  After experimenting with various approaches
+  // to calculate the average value of the BLIT over one period, I
+  // found that an estimate of C2_ = 1.0 / period (in samples) worked
+  // most consistently.  A "leaky integrator" is then applied to the
+  // difference of the BLIT output and C2_. (GPS - 1 October 2005)
+
+  // A fully  optimized version of this code 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 denormalized divisor 
+  // at the sinc peak, which has a limiting value of m_ / p_.
+  StkFloat tmp, denominator = sin( phase_ );
+  if ( fabs(denominator) <= std::numeric_limits<StkFloat>::epsilon() )
+    tmp = a_;
+  else {
+    tmp =  sin( m_ * phase_ );
+    tmp /= p_ * denominator;
+  }
+
+  tmp += state_ - C2_;
+  state_ = tmp * 0.995;
+
+  phase_ += rate_;
+  if ( phase_ >= PI ) phase_ -= PI;
+    
+  lastFrame_[0] = tmp;
+	return lastFrame_[0];
+}
+
+inline StkFrames& BlitSaw :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "BlitSaw::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 = BlitSaw::tick();
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BlitSquare.h

@@ -1,3 +1,12 @@
+#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.
@@ -8,8 +17,8 @@
     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 but that is
-    subtracted off the output signal.
+    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
@@ -19,18 +28,17 @@
     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).
+    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.
+    Modified algorithm code by Gary Scavone, 2005 - 2006.
 */
 /***************************************************/
 
-#ifndef STK_BLITSQUARE_H
-#define STK_BLITSQUARE_H
-
-#include "Generator.h"
-
 class BlitSquare: public Generator
 {
  public:
@@ -73,17 +81,90 @@ class BlitSquare: public Generator
   */
   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 );
-  StkFloat computeSample( void );
 
   unsigned int nHarmonics_;
   unsigned int m_;
   StkFloat rate_;
   StkFloat phase_;
   StkFloat p_;
-  StkFloat offset_;
+  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

include/BlowBotl.h

@@ -1,3 +1,16 @@
+#ifndef STK_BLOWBOTL_H
+#define STK_BLOWBOTL_H
+
+#include "Instrmnt.h"
+#include "JetTable.h"
+#include "BiQuad.h"
+#include "PoleZero.h"
+#include "Noise.h"
+#include "ADSR.h"
+#include "SineWave.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class BlowBotl
     \brief STK blown bottle instrument class.
@@ -12,21 +25,10 @@
        - Vibrato Gain = 1
        - Volume = 128
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_BLOWBOTL_H
-#define STK_BLOWBOTL_H
-
-#include "Instrmnt.h"
-#include "JetTable.h"
-#include "BiQuad.h"
-#include "PoleZero.h"
-#include "Noise.h"
-#include "ADSR.h"
-#include "SineWave.h"
-
 class BlowBotl : public Instrmnt
 {
  public:
@@ -34,36 +36,47 @@ class BlowBotl : public Instrmnt
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  BlowBotl();
+  BlowBotl( void );
 
   //! Class destructor.
-  ~BlowBotl();
+  ~BlowBotl( void );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Apply breath velocity to instrument with given amplitude and rate of increase.
-  void startBlowing(StkFloat amplitude, StkFloat rate);
+  void startBlowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease breath velocity with given rate of decrease.
-  void stopBlowing(StkFloat rate);
+  void stopBlowing( StkFloat rate );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-  
   JetTable jetTable_;
   BiQuad resonator_;
   PoleZero dcBlock_;
@@ -77,4 +90,55 @@ class BlowBotl : public Instrmnt
 
 };
 
+inline StkFloat BlowBotl :: tick( unsigned int )
+{
+  StkFloat breathPressure;
+  StkFloat randPressure;
+  StkFloat pressureDiff;
+
+  // Calculate the breath pressure (envelope + vibrato)
+  breathPressure = maxPressure_ * adsr_.tick();
+  breathPressure += vibratoGain_ * vibrato_.tick();
+
+  pressureDiff = breathPressure - resonator_.lastOut();
+
+  randPressure = noiseGain_ * noise_.tick();
+  randPressure *= breathPressure;
+  randPressure *= (1.0 + pressureDiff);
+
+  resonator_.tick( breathPressure + randPressure - ( jetTable_.tick( pressureDiff ) * pressureDiff ) );
+  lastFrame_[0] = 0.2 * outputGain_ * dcBlock_.tick( pressureDiff );
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& BlowBotl :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "BlowBotl::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BlowHole.h

@@ -1,3 +1,17 @@
+#ifndef STK_BLOWHOLE_H
+#define STK_BLOWHOLE_H
+
+#include "Instrmnt.h"
+#include "DelayL.h"
+#include "ReedTable.h"
+#include "OneZero.h"
+#include "PoleZero.h"
+#include "Envelope.h"
+#include "Noise.h"
+#include "SineWave.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class BlowHole
     \brief STK clarinet physical model with one
@@ -29,22 +43,10 @@
        - Register State = 1
        - Breath Pressure = 128
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_BLOWHOLE_H
-#define STK_BLOWHOLE_H
-
-#include "Instrmnt.h"
-#include "DelayL.h"
-#include "ReedTable.h"
-#include "OneZero.h"
-#include "PoleZero.h"
-#include "Envelope.h"
-#include "Noise.h"
-#include "SineWave.h"
-
 class BlowHole : public Instrmnt
 {
  public:
@@ -52,42 +54,53 @@ class BlowHole : public Instrmnt
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  BlowHole(StkFloat lowestFrequency);
+  BlowHole( StkFloat lowestFrequency );
 
   //! Class destructor.
-  ~BlowHole();
+  ~BlowHole( void );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Set the tonehole state (0.0 = closed, 1.0 = fully open).
-  void setTonehole(StkFloat newValue);
+  void setTonehole( StkFloat newValue );
 
   //! Set the register hole state (0.0 = closed, 1.0 = fully open).
-  void setVent(StkFloat newValue);
+  void setVent( StkFloat newValue );
 
   //! Apply breath pressure to instrument with given amplitude and rate of increase.
-  void startBlowing(StkFloat amplitude, StkFloat rate);
+  void startBlowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease breath pressure with given rate of decrease.
-  void stopBlowing(StkFloat rate);
+  void stopBlowing( StkFloat rate );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   DelayL    delays_[3];
   ReedTable reedTable_;
   OneZero   filter_;
@@ -95,15 +108,78 @@ class BlowHole : public Instrmnt
   PoleZero  vent_;
   Envelope  envelope_;
   Noise     noise_;
-  SineWave vibrato_;
-  unsigned long length_;
+  SineWave  vibrato_;
+
   StkFloat scatter_;
   StkFloat thCoeff_;
   StkFloat rhGain_;
   StkFloat outputGain_;
   StkFloat noiseGain_;
   StkFloat vibratoGain_;
-
 };
 
+  inline StkFloat BlowHole :: tick( unsigned int )
+{
+  StkFloat pressureDiff;
+  StkFloat breathPressure;
+  StkFloat temp;
+
+  // Calculate the breath pressure (envelope + noise + vibrato)
+  breathPressure = envelope_.tick(); 
+  breathPressure += breathPressure * noiseGain_ * noise_.tick();
+  breathPressure += breathPressure * vibratoGain_ * vibrato_.tick();
+
+  // Calculate the differential pressure = reflected - mouthpiece pressures
+  pressureDiff = delays_[0].lastOut() - breathPressure;
+
+  // Do two-port junction scattering for register vent
+  StkFloat pa = breathPressure + pressureDiff * reedTable_.tick( pressureDiff );
+  StkFloat pb = delays_[1].lastOut();
+  vent_.tick( pa+pb );
+
+  lastFrame_[0] = delays_[0].tick( vent_.lastOut()+pb );
+  lastFrame_[0] *= outputGain_;
+
+  // Do three-port junction scattering (under tonehole)
+  pa += vent_.lastOut();
+  pb = delays_[2].lastOut();
+  StkFloat pth = tonehole_.lastOut();
+  temp = scatter_ * (pa + pb - 2 * pth);
+
+  delays_[2].tick( filter_.tick(pa + temp) * -0.95 );
+  delays_[1].tick( pb + temp );
+  tonehole_.tick( pa + pb - pth + temp );
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& BlowHole :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "BlowHole::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/BowTable.h

@@ -1,27 +1,29 @@
+#ifndef STK_BOWTABL_H
+#define STK_BOWTABL_H
+
+#include "Function.h"
+#include <cmath>
+
+namespace stk {
+
 /***************************************************/
 /*! \class BowTable
     \brief STK bowed string table class.
 
     This class implements a simple bowed string
-    non-linear function, as described by Smith (1986).
+    non-linear function, as described by Smith
+    (1986).  The output is an instantaneous
+    reflection coefficient value.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_BOWTABL_H
-#define STK_BOWTABL_H
-
-#include "Function.h"
-
 class BowTable : public Function
 {
 public:
   //! Default constructor.
-  BowTable();
-
-  //! Class destructor.
-  ~BowTable();
+  BowTable( void ) : offset_(0.0), slope_(0.1), minOutput_(0.01), maxOutput_(0.98) {};
 
   //! Set the table offset value.
   /*!
@@ -30,22 +32,119 @@ public:
     friction to vary with direction, use a non-zero
     value for the offset.  The default value is zero.
   */
-  void setOffset(StkFloat offset);
+  void setOffset( StkFloat offset ) { offset_ = offset; };
 
   //! Set the table slope value.
   /*!
    The table slope controls the width of the friction
    pulse, which is related to bow force.
   */
-  void setSlope(StkFloat slope);
+  void setSlope( StkFloat slope ) { slope_ = slope; };
+
+  //! Set the minimum table output value (0.0 - 1.0).
+  void setMinOutput( StkFloat minimum ) { minOutput_ = minimum; };
+
+  //! Set the maximum table output value (0.0 - 1.0).
+  void setMaxOutput( StkFloat maximum ) { maxOutput_ = maximum; };
+
+  //! Take one sample input and map to one sample of output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the table and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the table and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:
 
-  StkFloat computeSample( StkFloat input );
-
   StkFloat offset_;
   StkFloat slope_;
+  StkFloat minOutput_;
+  StkFloat maxOutput_;
 
 };
 
+inline StkFloat BowTable :: tick( StkFloat input )
+{
+  // The input represents differential string vs. bow velocity.
+  StkFloat sample  = input + offset_;  // add bias to input
+  sample *= slope_;          // then scale it
+  lastFrame_[0] = (StkFloat) fabs( (double) sample ) + (StkFloat) 0.75;
+  lastFrame_[0] = (StkFloat) pow( lastFrame_[0], (StkFloat) -4.0 );
+
+  // Set minimum threshold
+  if ( lastFrame_[0] < minOutput_ ) lastFrame_[0] = minOutput_;
+
+  // Set maximum threshold
+  if ( lastFrame_[0] > maxOutput_ ) lastFrame_[0] = maxOutput_;
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& BowTable :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "BowTable::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 = *samples + offset_;
+    *samples *= slope_;
+    *samples = (StkFloat) fabs( (double) *samples ) + 0.75;
+    *samples = (StkFloat) pow( *samples, (StkFloat) -4.0 );
+    if ( *samples > 1.0) *samples = 1.0;
+  }
+
+  lastFrame_[0] = *(samples-hop);
+  return frames;
+}
+
+inline StkFrames& BowTable :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "BowTable::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    *oSamples = *iSamples + offset_;
+    *oSamples *= slope_;
+    *oSamples = (StkFloat) fabs( (double) *oSamples ) + 0.75;
+    *oSamples = (StkFloat) pow( *oSamples, (StkFloat) -4.0 );
+    if ( *oSamples > 1.0) *oSamples = 1.0;
+  }
+
+  lastFrame_[0] = *(oSamples-oHop);
+  return iFrames;
+}
+
+} // stk namespace
+
 #endif

include/Bowed.h

@@ -1,3 +1,16 @@
+#ifndef STK_BOWED_H
+#define STK_BOWED_H
+
+#include "Instrmnt.h"
+#include "DelayL.h"
+#include "BowTable.h"
+#include "OnePole.h"
+#include "BiQuad.h"
+#include "SineWave.h"
+#include "ADSR.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Bowed
     \brief STK bowed string instrument class.
@@ -15,67 +28,72 @@
        - Bow Position = 4
        - Vibrato Frequency = 11
        - Vibrato Gain = 1
+       - Bow Velocity = 100
+       - Frequency = 101
        - Volume = 128
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+    Contributions by Esteban Maestre, 2011.
 */
 /***************************************************/
 
-#ifndef STK_BOWED_H
-#define STK_BOWED_H
-
-#include "Instrmnt.h"
-#include "DelayL.h"
-#include "BowTable.h"
-#include "OnePole.h"
-#include "BiQuad.h"
-#include "SineWave.h"
-#include "ADSR.h"
-
 class Bowed : public Instrmnt
 {
  public:
   //! Class constructor, taking the lowest desired playing frequency.
-  Bowed(StkFloat lowestFrequency);
+  Bowed( StkFloat lowestFrequency = 8.0 );
 
   //! Class destructor.
-  ~Bowed();
+  ~Bowed( void );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Set vibrato gain.
-  void setVibrato(StkFloat gain);
+  void setVibrato( StkFloat gain ) { vibratoGain_ = gain; };
 
   //! Apply breath pressure to instrument with given amplitude and rate of increase.
-  void startBowing(StkFloat amplitude, StkFloat rate);
+  void startBowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease breath pressure with given rate of decrease.
-  void stopBowing(StkFloat rate);
+  void stopBowing( StkFloat rate );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   DelayL   neckDelay_;
   DelayL   bridgeDelay_;
   BowTable bowTable_;
   OnePole  stringFilter_;
-  BiQuad   bodyFilter_;
+  BiQuad   bodyFilters_[6];
   SineWave vibrato_;
   ADSR     adsr_;
+
+  bool     bowDown_;
   StkFloat maxVelocity_;
   StkFloat baseDelay_;
   StkFloat vibratoGain_;
@@ -83,4 +101,57 @@ class Bowed : public Instrmnt
 
 };
 
+inline StkFloat Bowed :: tick( unsigned int )
+{
+  StkFloat bowVelocity = maxVelocity_ * adsr_.tick();
+  StkFloat bridgeReflection = -stringFilter_.tick( bridgeDelay_.lastOut() );
+  StkFloat nutReflection = -neckDelay_.lastOut();
+  StkFloat stringVelocity = bridgeReflection + nutReflection;
+  StkFloat deltaV = bowVelocity - stringVelocity;             // Differential velocity
+
+  StkFloat newVelocity = 0.0;
+  if ( bowDown_ )
+    newVelocity = deltaV * bowTable_.tick( deltaV );     // Non-Linear bow function
+  neckDelay_.tick( bridgeReflection + newVelocity);      // Do string propagations
+  bridgeDelay_.tick(nutReflection + newVelocity);
+    
+  if ( vibratoGain_ > 0.0 )  {
+    neckDelay_.setDelay( (baseDelay_ * (1.0 - betaRatio_) ) + 
+                         (baseDelay_ * vibratoGain_ * vibrato_.tick()) );
+  }
+
+  lastFrame_[0] = 0.1248 * bodyFilters_[5].tick( bodyFilters_[4].tick( bodyFilters_[3].tick( bodyFilters_[2].tick( bodyFilters_[1].tick( bodyFilters_[0].tick( bridgeDelay_.lastOut() ) ) ) ) ) );
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Bowed :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "Bowed::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/Brass.h

@@ -1,3 +1,15 @@
+#ifndef STK_BRASS_H
+#define STK_BRASS_H
+
+#include "Instrmnt.h"
+#include "DelayA.h"
+#include "BiQuad.h"
+#include "PoleZero.h"
+#include "ADSR.h"
+#include "SineWave.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Brass
     \brief STK simple brass instrument class.
@@ -16,20 +28,10 @@
        - Vibrato Gain = 1
        - Volume = 128
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_BRASS_H
-#define STK_BRASS_H
-
-#include "Instrmnt.h"
-#include "DelayA.h"
-#include "BiQuad.h"
-#include "PoleZero.h"
-#include "ADSR.h"
-#include "SineWave.h"
-
 class Brass: public Instrmnt
 {
  public:
@@ -37,45 +39,56 @@ class Brass: public Instrmnt
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  Brass(StkFloat lowestFrequency);
+  Brass( StkFloat lowestFrequency = 8.0 );
 
   //! Class destructor.
-  ~Brass();
+  ~Brass(  );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear(  );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Set the lips frequency.
-  void setLip(StkFloat frequency);
+  void setLip( StkFloat frequency );
 
   //! Apply breath pressure to instrument with given amplitude and rate of increase.
-  void startBlowing(StkFloat amplitude, StkFloat rate);
+  void startBlowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease breath pressure with given rate of decrease.
-  void stopBlowing(StkFloat rate);
+  void stopBlowing( StkFloat rate );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   DelayA   delayLine_;
   BiQuad   lipFilter_;
   PoleZero dcBlock_;
   ADSR     adsr_;
   SineWave vibrato_;
-  unsigned long length_;
+
   StkFloat lipTarget_;
   StkFloat slideTarget_;
   StkFloat vibratoGain_;
@@ -83,4 +96,52 @@ class Brass: public Instrmnt
 
 };
 
+inline StkFloat Brass :: tick( unsigned int )
+{
+  StkFloat breathPressure = maxPressure_ * adsr_.tick();
+  breathPressure += vibratoGain_ * vibrato_.tick();
+
+  StkFloat mouthPressure = 0.3 * breathPressure;
+  StkFloat borePressure = 0.85 * delayLine_.lastOut();
+  StkFloat deltaPressure = mouthPressure - borePressure; // Differential pressure.
+  deltaPressure = lipFilter_.tick( deltaPressure );      // Force - > position.
+  deltaPressure *= deltaPressure;                        // Basic position to area mapping.
+  if ( deltaPressure > 1.0 ) deltaPressure = 1.0;        // Non-linear saturation.
+
+  // The following input scattering assumes the mouthPressure = area.
+  lastFrame_[0] = deltaPressure * mouthPressure + ( 1.0 - deltaPressure) * borePressure;
+  lastFrame_[0] = delayLine_.tick( dcBlock_.tick( lastFrame_[0] ) );
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Brass :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "Brass::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/Chorus.h

@@ -1,20 +1,23 @@
+#ifndef STK_CHORUS_H
+#define STK_CHORUS_H
+
+#include "Effect.h"
+#include "DelayL.h"
+#include "SineWave.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Chorus
     \brief STK chorus effect class.
 
-    This class implements a chorus effect.
+    This class implements a chorus effect.  It takes a monophonic
+    input signal and produces a stereo output signal.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_CHORUS_H
-#define STK_CHORUS_H
-
-#include "Effect.h" 
-#include "DelayL.h" 
-#include "SineWave.h" 
-
 class Chorus : public Effect
 {
  public:
@@ -24,22 +27,62 @@ class Chorus : public Effect
   */
   Chorus( StkFloat baseDelay = 6000 );
 
-  //! Class destructor.
-  ~Chorus();
-
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
-  //! Set modulation depth.
-  void setModDepth(StkFloat depth);
+  //! Set modulation depth in range 0.0 - 1.0.
+  void setModDepth( StkFloat depth );
 
   //! Set modulation frequency.
-  void setModFrequency(StkFloat frequency);
+  void setModFrequency( StkFloat frequency );
+
+  //! Return the specified channel value of the last computed stereo frame.
+  /*!
+    Use the lastFrame() function to get both values of the last
+    computed stereo frame.  The \c channel argument must be 0 or 1
+    (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.
+  */
+  StkFloat lastOut( unsigned int channel = 0 );
+
+  //! Input one sample to the effect and return the specified \c channel value of the computed stereo frame.
+  /*!
+    Use the lastFrame() function to get both values of the computed
+    stereo output frame. The \c channel argument must be 0 or 1 (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.
+  */
+  StkFloat tick( StkFloat input, unsigned int channel = 0 );
+
+  //! Take a channel of the StkFrames object as inputs to the effect and replace with stereo outputs.
+  /*!
+    The StkFrames argument reference is returned.  The stereo
+    outputs are written to the StkFrames argument starting at the
+    specified \c channel.  Therefore, the \c channel argument must be
+    less than ( channels() - 1 ) of 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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the effect and write stereo outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  The \c iChannel
+    argument must be less than the number of channels in the \c
+    iFrames argument (the first channel is specified by 0).  The \c
+    oChannel argument must be less than ( channels() - 1 ) of the \c
+    oFrames argument.  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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
  protected:
 
-  StkFloat computeSample( StkFloat input );
-
   DelayL delayLine_[2];
   SineWave mods_[2];
   StkFloat baseLength_;
@@ -47,5 +90,83 @@ class Chorus : public Effect
 
 };
 
+inline StkFloat Chorus :: lastOut( unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel > 1 ) {
+    oStream_ << "Chorus::lastOut(): channel argument must be less than 2!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  return lastFrame_[channel];
+}
+
+inline StkFloat Chorus :: tick( StkFloat input, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel > 1 ) {
+    oStream_ << "Chorus::tick(): channel argument must be less than 2!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  delayLine_[0].setDelay( baseLength_ * 0.707 * ( 1.0 + modDepth_ * mods_[0].tick() ) );
+  delayLine_[1].setDelay( baseLength_  * 0.5 *  ( 1.0 - modDepth_ * mods_[1].tick() ) );
+  lastFrame_[0] = effectMix_ * ( delayLine_[0].tick( input ) - input ) + input;
+  lastFrame_[1] = effectMix_ * ( delayLine_[1].tick( input ) - input ) + input;
+  return lastFrame_[channel];
+}
+
+inline StkFrames& Chorus :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() - 1 ) {
+    oStream_ << "Chorus::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int hop = frames.channels() - 1;
+  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+    delayLine_[0].setDelay( baseLength_ * 0.707 * ( 1.0 + modDepth_ * mods_[0].tick() ) );
+    delayLine_[1].setDelay( baseLength_  * 0.5 *  ( 1.0 - modDepth_ * mods_[1].tick() ) );
+    *samples = effectMix_ * ( delayLine_[0].tick( *samples ) - *samples ) + *samples;
+    samples++;
+    *samples = effectMix_ * ( delayLine_[1].tick( *samples ) - *samples ) + *samples;
+  }
+
+  lastFrame_[0] = *(samples-hop);
+  lastFrame_[1] = *(samples-hop+1);
+  return frames;
+}
+
+inline StkFrames& Chorus :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() - 1 ) {
+    oStream_ << "Chorus::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    delayLine_[0].setDelay( baseLength_ * 0.707 * ( 1.0 + modDepth_ * mods_[0].tick() ) );
+    delayLine_[1].setDelay( baseLength_  * 0.5 *  ( 1.0 - modDepth_ * mods_[1].tick() ) );
+    *oSamples = effectMix_ * ( delayLine_[0].tick( *iSamples ) - *iSamples ) + *iSamples;
+    *(oSamples+1) = effectMix_ * ( delayLine_[1].tick( *iSamples ) - *iSamples ) + *iSamples;
+  }
+
+  lastFrame_[0] = *(oSamples-oHop);
+  lastFrame_[1] = *(oSamples-oHop+1);
+  return iFrames;
+}
+
+} // stk namespace
+
 #endif
 

include/Clarinet.h

@@ -1,3 +1,16 @@
+#ifndef STK_CLARINET_H
+#define STK_CLARINET_H
+
+#include "Instrmnt.h"
+#include "DelayL.h"
+#include "ReedTable.h"
+#include "OneZero.h"
+#include "Envelope.h"
+#include "Noise.h"
+#include "SineWave.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Clarinet
     \brief STK clarinet physical model class.
@@ -18,21 +31,10 @@
        - Vibrato Gain = 1
        - Breath Pressure = 128
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_CLARINET_H
-#define STK_CLARINET_H
-
-#include "Instrmnt.h"
-#include "DelayL.h"
-#include "ReedTable.h"
-#include "OneZero.h"
-#include "Envelope.h"
-#include "Noise.h"
-#include "SineWave.h"
-
 class Clarinet : public Instrmnt
 {
  public:
@@ -40,47 +42,111 @@ class Clarinet : public Instrmnt
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  Clarinet(StkFloat lowestFrequency);
+  Clarinet( StkFloat lowestFrequency = 8.0 );
 
   //! Class destructor.
-  ~Clarinet();
+  ~Clarinet( void );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Apply breath pressure to instrument with given amplitude and rate of increase.
-  void startBlowing(StkFloat amplitude, StkFloat rate);
+  void startBlowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease breath pressure with given rate of decrease.
-  void stopBlowing(StkFloat rate);
+  void stopBlowing( StkFloat rate );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   DelayL delayLine_;
   ReedTable reedTable_;
   OneZero filter_;
   Envelope envelope_;
   Noise noise_;
   SineWave vibrato_;
-  long length_;
+
   StkFloat outputGain_;
   StkFloat noiseGain_;
   StkFloat vibratoGain_;
-
 };
 
+inline StkFloat Clarinet :: tick( unsigned int )
+{
+  StkFloat pressureDiff;
+  StkFloat breathPressure;
+
+  // Calculate the breath pressure (envelope + noise + vibrato)
+  breathPressure = envelope_.tick(); 
+  breathPressure += breathPressure * noiseGain_ * noise_.tick();
+  breathPressure += breathPressure * vibratoGain_ * vibrato_.tick();
+
+  // Perform commuted loss filtering.
+  pressureDiff = -0.95 * filter_.tick( delayLine_.lastOut() );
+
+  // Calculate pressure difference of reflected and mouthpiece pressures.
+  pressureDiff = pressureDiff - breathPressure;
+
+  // Perform non-linear scattering using pressure difference in reed function.
+  lastFrame_[0] = delayLine_.tick(breathPressure + pressureDiff * reedTable_.tick(pressureDiff));
+
+  // Apply output gain.
+  lastFrame_[0] *= outputGain_;
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Clarinet :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "Clarinet::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/Cubic.h

@@ -0,0 +1,138 @@
+#ifndef STK_CUBIC_H
+#define STK_CUBIC_H
+
+#include "Function.h"
+#include <cmath>
+
+namespace stk {
+
+/***************************************************/
+/*! \class Cubic
+    \brief STK cubic non-linearity class.
+
+    This class implements the cubic non-linearity
+    that was used in SynthBuilder.
+
+    The formula implemented is:
+ 
+    \code
+    output = gain * (a1 * input + a2 * input^2 + a3 * input^3)
+    \endcode
+
+    followed by a limiter for values outside +-threshold.
+
+    Ported to STK by Nick Porcaro, 2007. Updated for inclusion
+    in STK distribution by Gary Scavone, 2011.
+*/
+/***************************************************/
+
+class Cubic : public Function
+{
+public:
+  //! Default constructor.
+  Cubic( void ) : a1_(0.5), a2_(0.5), a3_(0.5), gain_(1.0), threshold_(1.0) {};
+
+  //! Set the a1 coefficient value.
+  void setA1( StkFloat a1 ) { a1_ = a1; };
+
+  //! Set the a2 coefficient value.
+  void setA2( StkFloat a2 )  { a2_ = a2; };
+
+  //! Set the a3 coefficient value.
+  void setA3( StkFloat a3 )  { a3_ = a3; };
+
+  //! Set the gain value.
+  void setGain( StkFloat gain ) { gain_ = gain; };
+
+  //! Set the threshold value.
+  void setThreshold( StkFloat threshold ) { threshold_ = threshold; };
+
+  //! Input one sample to the function and return one output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the function and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the function and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
+
+protected:
+
+  StkFloat a1_;
+  StkFloat a2_;
+  StkFloat a3_;
+  StkFloat gain_; 
+  StkFloat threshold_;
+};
+
+inline StkFloat Cubic :: tick( StkFloat input )
+{
+  StkFloat inSquared = input * input;
+  StkFloat inCubed = inSquared * input;
+
+  lastFrame_[0] = gain_ * (a1_ * input + a2_ * inSquared + a3_ * inCubed);
+
+  // Apply threshold if we are out of range.
+  if ( fabs( lastFrame_[0] ) > threshold_ ) {
+    lastFrame_[0] = ( lastFrame_[0] < 0 ? -threshold_ : threshold_ );
+  }
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Cubic :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Cubic::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 = tick( *samples );
+
+  lastFrame_[0] = *(samples-hop);
+  return frames;
+}
+
+inline StkFrames& Cubic :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "Cubic::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop )
+    *oSamples = tick( *iSamples );
+
+  lastFrame_[0] = *(oSamples-oHop);
+  return iFrames;
+}
+
+} // stk namespace
+
+#endif

include/Delay.h

@@ -1,48 +1,43 @@
-/***************************************************/
-/*! \class Delay
-    \brief STK non-interpolating delay line class.
-
-    This protected Filter subclass implements
-    a non-interpolating digital delay-line.
-    A fixed maximum length of 4095 and a delay
-    of zero is set using the default constructor.
-    Alternatively, the delay and maximum length
-    can be set during instantiation with an
-    overloaded constructor.
-    
-    A non-interpolating delay line is typically
-    used in fixed delay-length applications, such
-    as for reverberation.
-
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
-*/
-/***************************************************/
-
 #ifndef STK_DELAY_H
 #define STK_DELAY_H
 
 #include "Filter.h"
 
-class Delay : protected Filter
+namespace stk {
+
+/***************************************************/
+/*! \class Delay
+    \brief STK non-interpolating delay line class.
+
+    This class implements a non-interpolating digital delay-line.  If
+    the delay and maximum length are not specified during
+    instantiation, a fixed maximum length of 4095 and a delay of zero
+    is set.
+    
+    A non-interpolating delay line is typically used in fixed
+    delay-length applications, such as for reverberation.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
+
+class Delay : public Filter
 {
 public:
 
-  //! Default constructor creates a delay-line with maximum length of 4095 samples and zero delay.
-  Delay();
-
-  //! Overloaded constructor which specifies the current and maximum delay-line lengths.
+  //! The default constructor creates a delay-line with maximum length of 4095 samples and zero delay.
   /*!
     An StkError will be thrown if the delay parameter is less than
     zero, the maximum delay parameter is less than one, or the delay
     parameter is greater than the maxDelay value.
    */
-  Delay(unsigned long delay, unsigned long maxDelay);
+  Delay( unsigned long delay = 0, unsigned long maxDelay = 4095 );
 
   //! Class destructor.
-  virtual ~Delay();
+  ~Delay();
 
-  //! Clears the internal state of the delay line.
-  void clear();
+  //! Get the maximum delay-line length.
+  unsigned long getMaximumDelay( void ) { return inputs_.size() - 1; };
 
   //! Set the maximum delay-line length.
   /*!
@@ -50,21 +45,18 @@ public:
     of the delay line.  If it is used between calls to the tick()
     function, without a call to clear(), a signal discontinuity will
     likely occur.  If the current maximum length is greater than the
-    new length, no change will be made.
+    new length, no memory allocation change is made.
   */
-  void setMaximumDelay(unsigned long delay);
+  void setMaximumDelay( unsigned long delay );
 
   //! Set the delay-line length.
   /*!
-    The valid range for \e theDelay is from 0 to the maximum delay-line length.
+    The valid range for \e delay is from 0 to the maximum delay-line length.
   */
-  void setDelay(unsigned long delay);
+  void setDelay( unsigned long delay );
 
   //! Return the current delay-line length.
-  unsigned long getDelay(void) const;
-
-  //! Calculate and return the signal energy in the delay-line.
-  StkFloat energy(void) const;
+  unsigned long getDelay( void ) const { return delay_; };
 
   //! Return the value at \e tapDelay samples from the delay-line input.
   /*!
@@ -72,39 +64,125 @@ public:
     relative to the last input value (i.e., a tapDelay of zero returns
     the last input value).
   */
-  StkFloat contentsAt(unsigned long tapDelay);
+  StkFloat tapOut( unsigned long tapDelay );
+
+  //! Set the \e value at \e tapDelay samples from the delay-line input.
+  void tapIn( StkFloat value, unsigned long tapDelay );
+
+  //! Sum the provided \e value into the delay line at \e tapDelay samples from the input.
+  /*!
+    The new value is returned.  The tap point is determined modulo
+    the delay-line length and is relative to the last input value
+    (i.e., a tapDelay of zero sums into the last input value).
+  */
+  StkFloat addTo( StkFloat value, unsigned long tapDelay );
 
   //! Return the last computed output value.
-  StkFloat lastOut(void) const;
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
-  //! Return the value which will be output by the next call to tick().
+  //! Return the value that will be output by the next call to tick().
   /*!
     This method is valid only for delay settings greater than zero!
    */
-  virtual StkFloat nextOut(void);
+  StkFloat nextOut( void ) { return inputs_[outPoint_]; };
+
+  //! Calculate and return the signal energy in the delay-line.
+  StkFloat energy( void ) const;
 
   //! Input one sample to the filter and return one output.
-  virtual StkFloat tick(StkFloat sample);
+  StkFloat tick( StkFloat input );
 
   //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
   /*!
-    The \c channel argument should be zero or greater (the first
-    channel is specified by 0).  An StkError will be thrown if the \c
-    channel argument is equal to or greater than the number of
-    channels in the StkFrames object.
+    The StkFrames argument reference is returned.  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.
   */
-  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+
+  //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:
 
-  // This function must be implemented in all subclasses. It is used
-  // to get around a C++ problem with overloaded virtual functions.
-  virtual StkFloat computeSample( StkFloat input );
-
   unsigned long inPoint_;
   unsigned long outPoint_;
-  StkFloat delay_;
+  unsigned long delay_;
 };
 
+inline StkFloat Delay :: tick( StkFloat input )
+{
+  inputs_[inPoint_++] = input * gain_;
+
+  // Check for end condition
+  if ( inPoint_ == inputs_.size() )
+    inPoint_ = 0;
+
+  // Read out next value
+  lastFrame_[0] = inputs_[outPoint_++];
+
+  if ( outPoint_ == inputs_.size() )
+    outPoint_ = 0;
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Delay :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Delay::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 ) {
+    inputs_[inPoint_++] = *samples * gain_;
+    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
+    *samples = inputs_[outPoint_++];
+    if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
+  }
+
+  lastFrame_[0] = *(samples-hop);
+  return frames;
+}
+
+inline StkFrames& Delay :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "Delay::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    inputs_[inPoint_++] = *iSamples * gain_;
+    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
+    *oSamples = inputs_[outPoint_++];
+    if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
+  }
+
+  lastFrame_[0] = *(oSamples-oHop);
+  return iFrames;
+}
+
+} // stk namespace
+
+#endif

include/DelayA.h

@@ -1,12 +1,18 @@
+#ifndef STK_DELAYA_H
+#define STK_DELAYA_H
+
+#include "Filter.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class DelayA
     \brief STK allpass interpolating delay line class.
 
-    This Delay subclass implements a fractional-length digital
-    delay-line using a first-order allpass filter.  A fixed maximum
-    length of 4095 and a delay of 0.5 is set using the default
-    constructor.  Alternatively, the delay and maximum length can be
-    set during instantiation with an overloaded constructor.
+    This class implements a fractional-length digital delay-line using
+    a first-order allpass filter.  If the delay and maximum length are
+    not specified during instantiation, a fixed maximum length of 4095
+    and a delay of 0.5 is set.
 
     An allpass filter has unity magnitude gain but variable phase
     delay properties, making it useful in achieving fractional delays
@@ -15,55 +21,100 @@
     minimum delay possible in this implementation is limited to a
     value of 0.5.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_DELAYA_H
-#define STK_DELAYA_H
-
-#include "Delay.h"
-
-class DelayA : public Delay
+class DelayA : public Filter
 {
 public:
 
-  //! Default constructor creates a delay-line with maximum length of 4095 samples and zero delay.
-  DelayA();
-
-  //! Overloaded constructor which specifies the current and maximum delay-line lengths.
+  //! Default constructor creates a delay-line with maximum length of 4095 samples and delay = 0.5.
   /*!
     An StkError will be thrown if the delay parameter is less than
     zero, the maximum delay parameter is less than one, or the delay
     parameter is greater than the maxDelay value.
    */  
-  DelayA(StkFloat delay, unsigned long maxDelay);
+  DelayA( StkFloat delay = 0.5, unsigned long maxDelay = 4095 );
 
   //! Class destructor.
   ~DelayA();
 
-  //! Clears the internal state of the delay line.
-  void clear();
+  //! Clears all internal states of the delay line.
+  void clear( void );
+
+  //! Get the maximum delay-line length.
+  unsigned long getMaximumDelay( void ) { return inputs_.size() - 1; };
+  
+  //! Set the maximum delay-line length.
+  /*!
+    This method should generally only be used during initial setup
+    of the delay line.  If it is used between calls to the tick()
+    function, without a call to clear(), a signal discontinuity will
+    likely occur.  If the current maximum length is greater than the
+    new length, no memory allocation change is made.
+  */
+  void setMaximumDelay( unsigned long delay );
 
   //! Set the delay-line length
   /*!
-    The valid range for \e theDelay is from 0.5 to the maximum delay-line length.
+    The valid range for \e delay is from 0.5 to the maximum delay-line length.
   */
-  void setDelay(StkFloat delay);
+  void setDelay( StkFloat delay );
 
   //! Return the current delay-line length.
-  StkFloat getDelay(void) const;
+  StkFloat getDelay( void ) const { return delay_; };
+
+  //! Return the value at \e tapDelay samples from the delay-line input.
+  /*!
+    The tap point is determined modulo the delay-line length and is
+    relative to the last input value (i.e., a tapDelay of zero returns
+    the last input value).
+  */
+  StkFloat tapOut( unsigned long tapDelay );
+
+  //! Set the \e value at \e tapDelay samples from the delay-line input.
+  void tapIn( StkFloat value, unsigned long tapDelay );
+
+  //! Return the last computed output value.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
   //! Return the value which will be output by the next call to tick().
   /*!
     This method is valid only for delay settings greater than zero!
    */
-  StkFloat nextOut(void);
+  StkFloat nextOut( void );
+
+  //! Input one sample to the filter and return one output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:  
 
-  StkFloat computeSample( StkFloat input );
-
+  unsigned long inPoint_;
+  unsigned long outPoint_;
+  StkFloat delay_;
   StkFloat alpha_;
   StkFloat coeff_;
   StkFloat apInput_;
@@ -71,4 +122,86 @@ protected:
   bool doNextOut_;
 };
 
+inline StkFloat DelayA :: nextOut( void )
+{
+  if ( doNextOut_ ) {
+    // Do allpass interpolation delay.
+    nextOutput_ = -coeff_ * lastFrame_[0];
+    nextOutput_ += apInput_ + ( coeff_ * inputs_[outPoint_] );
+    doNextOut_ = false;
+  }
+
+  return nextOutput_;
+}
+
+inline StkFloat DelayA :: tick( StkFloat input )
+{
+  inputs_[inPoint_++] = input * gain_;
+
+  // Increment input pointer modulo length.
+  if ( inPoint_ == inputs_.size() )
+    inPoint_ = 0;
+
+  lastFrame_[0] = nextOut();
+  doNextOut_ = true;
+
+  // Save the allpass input and increment modulo length.
+  apInput_ = inputs_[outPoint_++];
+  if ( outPoint_ == inputs_.size() )
+    outPoint_ = 0;
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& DelayA :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "DelayA::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 ) {
+    inputs_[inPoint_++] = *samples * gain_;
+    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
+    *samples = nextOut();
+    lastFrame_[0] = *samples;
+    doNextOut_ = true;
+    apInput_ = inputs_[outPoint_++];
+    if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
+  }
+
+  return frames;
+}
+
+inline StkFrames& DelayA :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "DelayA::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    inputs_[inPoint_++] = *iSamples * gain_;
+    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
+    *oSamples = nextOut();
+    lastFrame_[0] = *oSamples;
+    doNextOut_ = true;
+    apInput_ = inputs_[outPoint_++];
+    if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
+  }
+
+  return iFrames;
+}
+
+} // stk namespace
+
 #endif

include/DelayL.h

@@ -1,73 +1,230 @@
+#ifndef STK_DELAYL_H
+#define STK_DELAYL_H
+
+#include "Filter.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class DelayL
     \brief STK linear interpolating delay line class.
 
-    This Delay subclass implements a fractional-
-    length digital delay-line using first-order
-    linear interpolation.  A fixed maximum length
-    of 4095 and a delay of zero is set using the
-    default constructor.  Alternatively, the
-    delay and maximum length can be set during
-    instantiation with an overloaded constructor.
+    This class implements a fractional-length digital delay-line using
+    first-order linear interpolation.  If the delay and maximum length
+    are not specified during instantiation, a fixed maximum length of
+    4095 and a delay of zero is set.
 
-    Linear interpolation is an efficient technique
-    for achieving fractional delay lengths, though
-    it does introduce high-frequency signal
-    attenuation to varying degrees depending on the
-    fractional delay setting.  The use of higher
-    order Lagrange interpolators can typically
-    improve (minimize) this attenuation characteristic.
+    Linear interpolation is an efficient technique for achieving
+    fractional delay lengths, though it does introduce high-frequency
+    signal attenuation to varying degrees depending on the fractional
+    delay setting.  The use of higher order Lagrange interpolators can
+    typically improve (minimize) this attenuation characteristic.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_DELAYL_H
-#define STK_DELAYL_H
-
-#include "Delay.h"
-
-class DelayL : public Delay
+class DelayL : public Filter
 {
 public:
 
   //! Default constructor creates a delay-line with maximum length of 4095 samples and zero delay.
-  DelayL();
-
-  //! Overloaded constructor which specifies the current and maximum delay-line lengths.
   /*!
     An StkError will be thrown if the delay parameter is less than
     zero, the maximum delay parameter is less than one, or the delay
     parameter is greater than the maxDelay value.
    */  
-  DelayL(StkFloat delay, unsigned long maxDelay);
+  DelayL( StkFloat delay = 0.0, unsigned long maxDelay = 4095 );
 
   //! Class destructor.
   ~DelayL();
 
+  //! Get the maximum delay-line length.
+  unsigned long getMaximumDelay( void ) { return inputs_.size() - 1; };
+
+  //! Set the maximum delay-line length.
+  /*!
+    This method should generally only be used during initial setup
+    of the delay line.  If it is used between calls to the tick()
+    function, without a call to clear(), a signal discontinuity will
+    likely occur.  If the current maximum length is greater than the
+    new length, no memory allocation change is made.
+  */
+  void setMaximumDelay( unsigned long delay );
+
   //! Set the delay-line length.
   /*!
-    The valid range for \e theDelay is from 0 to the maximum delay-line length.
+    The valid range for \e delay is from 0 to the maximum delay-line length.
   */
-  void setDelay(StkFloat delay);
+  void setDelay( StkFloat delay );
 
   //! Return the current delay-line length.
-  StkFloat getDelay(void) const;
+  StkFloat getDelay( void ) const { return delay_; };
+
+  //! Return the value at \e tapDelay samples from the delay-line input.
+  /*!
+    The tap point is determined modulo the delay-line length and is
+    relative to the last input value (i.e., a tapDelay of zero returns
+    the last input value).
+  */
+  StkFloat tapOut( unsigned long tapDelay );
+
+  //! Set the \e value at \e tapDelay samples from the delay-line input.
+  void tapIn( StkFloat value, unsigned long tapDelay );
+
+  //! Return the last computed output value.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
   //! Return the value which will be output by the next call to tick().
   /*!
     This method is valid only for delay settings greater than zero!
    */
-  StkFloat nextOut(void);
+  StkFloat nextOut( void );
+
+  //! Input one sample to the filter and return one output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
  protected:
 
-  StkFloat computeSample( StkFloat input );
-
+  unsigned long inPoint_;
+  unsigned long outPoint_;
+  StkFloat delay_;
   StkFloat alpha_;
   StkFloat omAlpha_;
   StkFloat nextOutput_;
   bool doNextOut_;
 };
 
+inline StkFloat DelayL :: nextOut( void )
+{
+  if ( doNextOut_ ) {
+    // First 1/2 of interpolation
+    nextOutput_ = inputs_[outPoint_] * omAlpha_;
+    // Second 1/2 of interpolation
+    if (outPoint_+1 < inputs_.size())
+      nextOutput_ += inputs_[outPoint_+1] * alpha_;
+    else
+      nextOutput_ += inputs_[0] * alpha_;
+    doNextOut_ = false;
+  }
+
+  return nextOutput_;
+}
+
+inline void DelayL :: setDelay( StkFloat delay )
+{
+  if ( delay + 1 > inputs_.size() ) { // The value is too big.
+    oStream_ << "DelayL::setDelay: argument (" << delay << ") greater than  maximum!";
+    handleError( StkError::WARNING ); return;
+  }
+
+  if (delay < 0 ) {
+    oStream_ << "DelayL::setDelay: argument (" << delay << ") less than zero!";
+    handleError( StkError::WARNING ); return;
+  }
+
+  StkFloat outPointer = inPoint_ - delay;  // read chases write
+  delay_ = delay;
+
+  while ( outPointer < 0 )
+    outPointer += inputs_.size(); // modulo maximum length
+
+  outPoint_ = (long) outPointer;   // integer part
+
+  alpha_ = outPointer - outPoint_; // fractional part
+  omAlpha_ = (StkFloat) 1.0 - alpha_;
+
+  if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
+  doNextOut_ = true;
+}
+
+inline StkFloat DelayL :: tick( StkFloat input )
+{
+  inputs_[inPoint_++] = input * gain_;
+
+  // Increment input pointer modulo length.
+  if ( inPoint_ == inputs_.size() )
+    inPoint_ = 0;
+
+  lastFrame_[0] = nextOut();
+  doNextOut_ = true;
+
+  // Increment output pointer modulo length.
+  if ( ++outPoint_ == inputs_.size() )
+    outPoint_ = 0;
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& DelayL :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "DelayL::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 ) {
+    inputs_[inPoint_++] = *samples * gain_;
+    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
+    *samples = nextOut();
+    doNextOut_ = true;
+    if ( ++outPoint_ == inputs_.size() ) outPoint_ = 0;
+  }
+
+  lastFrame_[0] = *(samples-hop);
+  return frames;
+}
+
+inline StkFrames& DelayL :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "DelayL::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    inputs_[inPoint_++] = *iSamples * gain_;
+    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
+    *oSamples = nextOut();
+    doNextOut_ = true;
+    if ( ++outPoint_ == inputs_.size() ) outPoint_ = 0;
+  }
+
+  lastFrame_[0] = *(oSamples-oHop);
+  return iFrames;
+}
+
+} // stk namespace
+
 #endif

include/Drummer.h

@@ -1,3 +1,12 @@
+#ifndef STK_DRUMMER_H
+#define STK_DRUMMER_H
+
+#include "Instrmnt.h"
+#include "FileWvIn.h"
+#include "OnePole.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Drummer
     \brief STK drum sample player class.
@@ -11,17 +20,10 @@
     of simultaneous voices) via a #define in the
     Drummer.h.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_DRUMMER_H
-#define STK_DRUMMER_H
-
-#include "Instrmnt.h"
-#include "FileWvIn.h"
-#include "OnePole.h"
-
 const int DRUM_NUMWAVES = 11;
 const int DRUM_POLYPHONY = 4;
 
@@ -32,10 +34,10 @@ class Drummer : public Instrmnt
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  Drummer();
+  Drummer( void );
 
   //! Class destructor.
-  ~Drummer();
+  ~Drummer( void );
 
   //! Start a note with the given drum type and amplitude.
   /*!
@@ -44,15 +46,26 @@ class Drummer : public Instrmnt
     instrument.  An StkError will be thrown if the rawwave path is
     incorrectly set.
   */
-  void noteOn(StkFloat instrument, StkFloat amplitude);
+  void noteOn( StkFloat instrument, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   FileWvIn waves_[DRUM_POLYPHONY];
   OnePole  filters_[DRUM_POLYPHONY];
   std::vector<int> soundOrder_;
@@ -60,4 +73,58 @@ class Drummer : public Instrmnt
   int      nSounding_;
 };
 
+inline StkFloat Drummer :: tick( unsigned int )
+{
+  lastFrame_[0] = 0.0;
+  if ( nSounding_ == 0 ) return lastFrame_[0];
+
+  for ( int i=0; i<DRUM_POLYPHONY; i++ ) {
+    if ( soundOrder_[i] >= 0 ) {
+      if ( waves_[i].isFinished() ) {
+        // Re-order the list.
+        for ( int j=0; j<DRUM_POLYPHONY; j++ ) {
+          if ( soundOrder_[j] > soundOrder_[i] )
+            soundOrder_[j] -= 1;
+        }
+        soundOrder_[i] = -1;
+        nSounding_--;
+      }
+      else
+        lastFrame_[0] += filters_[i].tick( waves_[i].tick() );
+    }
+  }
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Drummer :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "Drummer::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+
+} // stk namespace
+
 #endif

include/Echo.h

@@ -1,19 +1,21 @@
+#ifndef STK_ECHO_H
+#define STK_ECHO_H
+
+#include "Effect.h" 
+#include "Delay.h" 
+
+namespace stk {
+
 /***************************************************/
 /*! \class Echo
     \brief STK echo effect class.
 
     This class implements an echo effect.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_ECHO_H
-#define STK_ECHO_H
-
-#include "Effect.h" 
-#include "Delay.h" 
-
 class Echo : public Effect
 {
  public:
@@ -23,9 +25,6 @@ class Echo : public Effect
   */
   Echo( unsigned long maximumDelay = (unsigned long) Stk::sampleRate() );
 
-  //! Class destructor.
-  ~Echo();
-
   //! Reset and clear all internal state.
   void clear();
 
@@ -35,14 +34,87 @@ class Echo : public Effect
   //! Set the delay line length in samples.
   void setDelay( unsigned long delay );
 
- protected:
+  //! Return the last computed output value.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
-  StkFloat computeSample( StkFloat input );
+  //! Input one sample to the effect and return one output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the effect and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the effect and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
+
+ protected:
 
   Delay delayLine_;
   unsigned long length_;
 
 };
 
+inline StkFloat Echo :: tick( StkFloat input )
+{
+  lastFrame_[0] = effectMix_ * ( delayLine_.tick( input ) - input ) + input;
+  return lastFrame_[0];
+}
+
+inline StkFrames& Echo :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Echo::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 = effectMix_ * ( delayLine_.tick( *samples ) - *samples ) + *samples;
+  }
+
+  lastFrame_[0] = *(samples-hop);
+  return frames;
+}
+
+inline StkFrames& Echo :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "Echo::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
+    *oSamples = effectMix_ * ( delayLine_.tick( *iSamples ) - *iSamples ) + *iSamples;
+  }
+
+  lastFrame_[0] = *(oSamples-oHop);
+  return iFrames;
+}
+
+} // stk namespace
+
 #endif
 

include/Effect.h

@@ -1,69 +1,79 @@
+#ifndef STK_EFFECT_H
+#define STK_EFFECT_H
+
+#include "Stk.h"
+#include <cmath>
+
+namespace stk {
+
 /***************************************************/
 /*! \class Effect
     \brief STK abstract effects parent class.
 
-    This class provides common functionality for
-    STK effects subclasses.
+    This class provides common functionality for STK effects
+    subclasses.  It is general enough to support both monophonic and
+    polyphonic input/output classes.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#include "Stk.h"
-
-#ifndef STK_EFFECT_H
-#define STK_EFFECT_H
-
 class Effect : public Stk
 {
  public:
   //! Class constructor.
-  Effect();
+  Effect( void ) { lastFrame_.resize( 1, 1, 0.0 ); };
 
-  //! Class destructor.
-  virtual ~Effect();
+  //! Return the number of output channels for the class.
+  unsigned int channelsOut( void ) const { return lastFrame_.channels(); };
+
+  //! Return an StkFrames reference to the last output sample frame.
+  const StkFrames& lastFrame( void ) const { return lastFrame_; };
 
   //! Reset and clear all internal state.
   virtual void clear() = 0;
 
-  //! Set the mixture of input and "effected" levels in the output (0.0 = input only, 1.0 = reverb only). 
-  void setEffectMix(StkFloat mix);
-
-  //! Return the last output value.
-  StkFloat lastOut() const;
-
-  //! Return the last left output value.
-  StkFloat lastOutLeft() const;
-
-  //! Return the last right output value.
-  StkFloat lastOutRight() const;
-
-  //! Take one sample input and compute one sample of output.
-  StkFloat tick( StkFloat input );
-
-  //! Take a channel of the StkFrames object as inputs to the effect and replace with corresponding outputs.
-  /*!
-    The \c channel argument should be zero or greater (the first
-    channel is specified by 0).  An StkError will be thrown if the \c
-    channel argument is equal to or greater than the number of
-    channels in the StkFrames object.
-  */
-  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+  //! Set the mixture of input and "effected" levels in the output (0.0 = input only, 1.0 = effect only). 
+  virtual void setEffectMix( StkFloat mix );
 
  protected:
 
-  // This abstract function must be implemented in all subclasses.
-  // It is used to get around a C++ problem with overloaded virtual
-  // functions.
-  virtual StkFloat computeSample( StkFloat input ) = 0;
-
   // Returns true if argument value is prime.
-  bool isPrime( int number );
+  bool isPrime( unsigned int number );
 
-  StkFloat lastOutput_[2];
+  StkFrames lastFrame_;
   StkFloat effectMix_;
 
 };
 
+inline void Effect :: setEffectMix( StkFloat mix )
+{
+  if ( mix < 0.0 ) {
+    oStream_ << "Effect::setEffectMix: mix parameter is less than zero ... setting to zero!";
+    handleError( StkError::WARNING );
+    effectMix_ = 0.0;
+  }
+  else if ( mix > 1.0 ) {
+    oStream_ << "Effect::setEffectMix: mix parameter is greater than 1.0 ... setting to one!";
+    handleError( StkError::WARNING );
+    effectMix_ = 1.0;
+  }
+  else
+    effectMix_ = mix;
+}
+
+inline bool Effect :: isPrime( unsigned int number )
+{
+  if ( number == 2 ) return true;
+  if ( number & 1 ) {
+	  for ( int i=3; i<(int)sqrt((double)number)+1; i+=2 )
+		  if ( (number % i) == 0 ) return false;
+	  return true; // prime
+	}
+  else return false; // even
+}
+
+} // stk namespace
+
 #endif
 

include/Envelope.h

@@ -1,63 +1,83 @@
-/***************************************************/
-/*! \class Envelope
-    \brief STK envelope base class.
-
-    This class implements a simple envelope
-    generator which is capable of ramping to
-    a target value by a specified \e rate.
-    It also responds to simple \e keyOn and
-    \e keyOff messages, ramping to 1.0 on
-    keyOn and to 0.0 on keyOff.
-
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
-*/
-/***************************************************/
-
 #ifndef STK_ENVELOPE_H
 #define STK_ENVELOPE_H
 
 #include "Generator.h"
 
+namespace stk {
+
+/***************************************************/
+/*! \class Envelope
+    \brief STK linear line envelope class.
+
+    This class implements a simple linear line envelope generator
+    which is capable of ramping to an arbitrary target value by a
+    specified \e rate.  It also responds to simple \e keyOn and \e
+    keyOff messages, ramping to 1.0 on keyOn and to 0.0 on keyOff.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
+
 class Envelope : public Generator
 {
  public:
 
   //! Default constructor.
-  Envelope(void);
-
-  //! Copy constructor.
-  Envelope( const Envelope& e );
+  Envelope( void );
 
   //! Class destructor.
-  virtual ~Envelope(void);
+  ~Envelope( void );
 
   //! Assignment operator.
   Envelope& operator= ( const Envelope& e );
 
   //! Set target = 1.
-  virtual void keyOn(void);
+  void keyOn( void ) { this->setTarget( 1.0 ); };
 
   //! Set target = 0.
-  virtual void keyOff(void);
+  void keyOff( void ) { this->setTarget( 0.0 ); };
 
   //! Set the \e rate.
-  void setRate(StkFloat rate);
+  /*!
+    The \e rate must be positive (though a value of 0.0 is allowed).
+   */
+  void setRate( StkFloat rate );
 
-  //! Set the \e rate based on a time duration.
-  void setTime(StkFloat time);
+  //! Set the \e rate based on a positive time duration (seconds).
+  /*!
+    The \e rate is calculated such that the envelope will ramp from
+    a value of 0.0 to 1.0 in the specified time duration.
+   */
+  void setTime( StkFloat time );
 
   //! Set the target value.
-  virtual void setTarget(StkFloat target);
+  void setTarget( StkFloat target );
 
-  //! Set current and target values to \e aValue.
-  virtual void setValue(StkFloat value);
+  //! Set current and target values to \e value.
+  void setValue( StkFloat value );
 
   //! Return the current envelope \e state (0 = at target, 1 otherwise).
-  virtual int getState(void) const;
+  int getState( void ) const { return state_; };
+
+  //! 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:
 
-  virtual StkFloat computeSample( void );
+  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
   StkFloat value_;
   StkFloat target_;
@@ -65,4 +85,46 @@ class Envelope : public Generator
   int state_;
 };
 
+inline StkFloat Envelope :: tick( void )
+{
+  if ( state_ ) {
+    if ( target_ > value_ ) {
+      value_ += rate_;
+      if ( value_ >= target_ ) {
+        value_ = target_;
+        state_ = 0;
+      }
+    }
+    else {
+      value_ -= rate_;
+      if ( value_ <= target_ ) {
+        value_ = target_;
+        state_ = 0;
+      }
+    }
+    lastFrame_[0] = value_;
+  }
+
+  return value_;
+}
+
+inline StkFrames& Envelope :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Envelope::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 = tick();
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/FM.h

@@ -1,3 +1,14 @@
+#ifndef STK_FM_H
+#define STK_FM_H
+
+#include "Instrmnt.h"
+#include "ADSR.h"
+#include "FileLoop.h"
+#include "SineWave.h"
+#include "TwoZero.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class FM
     \brief STK abstract FM synthesis base class.
@@ -19,19 +30,10 @@
     type who should worry about this (making
     money) worry away.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FM_H
-#define STK_FM_H
-
-#include "Instrmnt.h"
-#include "ADSR.h"
-#include "WaveLoop.h"
-#include "SineWave.h"
-#include "TwoZero.h"
-
 class FM : public Instrmnt
 {
  public:
@@ -42,53 +44,61 @@ class FM : public Instrmnt
   FM( unsigned int operators = 4 );
 
   //! Class destructor.
-  virtual ~FM();
-
-  //! Reset and clear all wave and envelope states.
-  void clear();
+  virtual ~FM( void );
 
   //! Load the rawwave filenames in waves.
-  void loadWaves(const char **filenames);
+  void loadWaves( const char **filenames );
 
   //! Set instrument parameters for a particular frequency.
-  virtual void setFrequency(StkFloat frequency);
+  virtual void setFrequency( StkFloat frequency );
 
   //! Set the frequency ratio for the specified wave.
-  void setRatio(unsigned int waveIndex, StkFloat ratio);
+  void setRatio( unsigned int waveIndex, StkFloat ratio );
 
   //! Set the gain for the specified wave.
-  void setGain(unsigned int waveIndex, StkFloat gain);
+  void setGain( unsigned int waveIndex, StkFloat gain );
 
   //! Set the modulation speed in Hz.
-  void setModulationSpeed(StkFloat mSpeed);
+  void setModulationSpeed( StkFloat mSpeed ) { vibrato_.setFrequency( mSpeed ); };
 
   //! Set the modulation depth.
-  void setModulationDepth(StkFloat mDepth);
+  void setModulationDepth( StkFloat mDepth ) { modDepth_ = mDepth; };
 
   //! Set the value of control1.
-  void setControl1(StkFloat cVal);
+  void setControl1( StkFloat cVal ) { control1_ = cVal * 2.0; };
 
   //! Set the value of control1.
-  void setControl2(StkFloat cVal);
+  void setControl2( StkFloat cVal ) { control2_ = cVal * 2.0; };
 
   //! Start envelopes toward "on" targets.
-  void keyOn();
+  void keyOn( void );
 
   //! Start envelopes toward "off" targets.
-  void keyOff();
+  void keyOff( void );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  virtual void controlChange(int number, StkFloat value);
+  virtual void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  virtual StkFloat tick( unsigned int ) = 0;
+
+  //! 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.
+  */
+  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0;
 
  protected:
 
-  virtual StkFloat computeSample( void ) = 0;
-
   std::vector<ADSR *> adsr_; 
-  std::vector<WaveLoop *> waves_;
+  std::vector<FileLoop *> waves_;
   SineWave vibrato_;
   TwoZero  twozero_;
   unsigned int nOperators_;
@@ -104,4 +114,6 @@ class FM : public Instrmnt
 
 };
 
+} // stk namespace
+
 #endif

include/FMVoices.h

@@ -1,3 +1,10 @@
+#ifndef STK_FMVOICES_H
+#define STK_FMVOICES_H
+
+#include "FM.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class FMVoices
     \brief STK singing FM synthesis instrument.
@@ -26,15 +33,10 @@
     type who should worry about this (making
     money) worry away.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FMVOICES_H
-#define STK_FMVOICES_H
-
-#include "FM.h"
-
 class FMVoices : public FM
 {
  public:
@@ -42,27 +44,92 @@ class FMVoices : public FM
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  FMVoices();
+  FMVoices( void );
 
   //! Class destructor.
-  ~FMVoices();
+  ~FMVoices( void );
 
   //! Set instrument parameters for a particular frequency.
-  virtual void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  virtual void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   int currentVowel_;
   StkFloat tilt_[3];
   StkFloat mods_[3];
 };
 
+inline StkFloat FMVoices :: tick( unsigned int )
+{
+  StkFloat temp, temp2;
+
+  temp = gains_[3] * adsr_[3]->tick() * waves_[3]->tick();
+  temp2 = vibrato_.tick() * modDepth_ * 0.1;
+
+  waves_[0]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[0]);
+  waves_[1]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[1]);
+  waves_[2]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[2]);
+  waves_[3]->setFrequency(baseFrequency_ * (1.0 + temp2) * ratios_[3]);
+
+  waves_[0]->addPhaseOffset(temp * mods_[0]);
+  waves_[1]->addPhaseOffset(temp * mods_[1]);
+  waves_[2]->addPhaseOffset(temp * mods_[2]);
+  waves_[3]->addPhaseOffset( twozero_.lastOut() );
+  twozero_.tick( temp );
+  temp =  gains_[0] * tilt_[0] * adsr_[0]->tick() * waves_[0]->tick();
+  temp += gains_[1] * tilt_[1] * adsr_[1]->tick() * waves_[1]->tick();
+  temp += gains_[2] * tilt_[2] * adsr_[2]->tick() * waves_[2]->tick();
+
+  lastFrame_[0] = temp * 0.33;
+  return lastFrame_[0];
+}
+
+inline StkFrames& FMVoices :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "FMVoices::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/FileLoop.h

@@ -0,0 +1,164 @@
+#ifndef STK_FILELOOP_H
+#define STK_FILELOOP_H
+
+#include "FileWvIn.h"
+
+namespace stk {
+
+/***************************************************/
+/*! \class FileLoop
+    \brief STK file looping / oscillator class.
+
+    This class provides audio file looping functionality.  Any audio
+    file that can be loaded by FileRead can be looped using this
+    class.
+
+    FileLoop 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.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
+
+class FileLoop : protected FileWvIn
+{
+ public:
+  //! Default constructor.
+  FileLoop( unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024 );
+
+  //! Class constructor that opens a specified file.
+  FileLoop( std::string fileName, bool raw = false, bool doNormalize = true,
+            unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024,
+            bool doInt2FloatScaling = true );
+
+  //! Class destructor.
+  ~FileLoop( 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 length
+    is less than the chunkThreshold limit and \e doNormalize is true,
+    the file data will be normalized with respect to the maximum absolute
+    value of the data. If the \e doInt2FloatScaling flag is true and the
+    input data is fixed-point, a scaling will be applied with respect to
+    the fixed-point limits.
+  */
+  void openFile( std::string fileName, bool raw = false, bool doNormalize = true, bool doInt2FloatScaling = true );
+
+  //! Close a file if one is open.
+  void closeFile( void ) { FileWvIn::closeFile(); };
+
+  //! Clear outputs and reset time (file) pointer to zero.
+  void reset( void ) { FileWvIn::reset(); };
+
+  //! Return the number of audio channels in the data or stream.
+  unsigned int channelsOut( void ) const { return data_.channels(); };
+
+  //! Normalize data to a maximum of +-1.0.
+  /*!
+    This function has no effect when data is incrementally loaded
+    from disk.
+  */
+  void normalize( void ) { FileWvIn::normalize( 1.0 ); };
+
+  //! Normalize data to a maximum of \e +-peak.
+  /*!
+    This function has no effect when data is incrementally loaded
+    from disk.
+  */
+  void normalize( StkFloat peak ) { FileWvIn::normalize( peak ); };
+
+  //! Return the file size in sample frames.
+  unsigned long getSize( void ) const { return data_.frames(); };
+
+  //! 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.
+  */
+  StkFloat getFileRate( void ) const { return data_.dataRate(); };
+
+  //! 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.
+  */
+  void setRate( StkFloat rate );
+
+  //! Set the data interpolation rate based on a looping frequency.
+  /*!
+    This function determines the interpolation rate based on the file
+    size and the current Stk::sampleRate.  The \e frequency value
+    corresponds to file cycles per second.  The frequency can be
+    negative, in which case the loop is read in reverse order.
+  */
+  void setFrequency( StkFloat frequency ) { this->setRate( fileSize_ * frequency / Stk::sampleRate() ); };
+
+  //! Increment the read pointer by \e time samples, modulo file size.
+  void addTime( StkFloat time );
+
+  //! Increment current read pointer by \e angle, relative to a looping frequency.
+  /*!
+    This function increments the read pointer based on the file
+    size and the current Stk::sampleRate.  The \e anAngle value
+    is a multiple of file size.
+  */
+  void addPhase( StkFloat angle );
+
+  //! Add a phase offset to the current read pointer.
+  /*!
+    This function determines a time offset based on the file
+    size and the current Stk::sampleRate.  The \e angle value
+    is a multiple of file size.
+  */
+  void addPhaseOffset( StkFloat angle );
+
+  //! Return the specified channel value of the last computed frame.
+  /*!
+    For multi-channel files, use the lastFrame() function to get
+    all values from the last 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.
+  */
+  StkFloat lastOut( unsigned int channel = 0 ) { return FileWvIn::lastOut( channel ); };
+
+  //! 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.
+  */
+  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 output 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:
+
+  StkFrames firstFrame_;
+  StkFloat phaseOffset_;
+
+};
+
+} // stk namespace
+
+#endif

include/FileRead.h

@@ -1,3 +1,10 @@
+#ifndef STK_FILEREAD_H
+#define STK_FILEREAD_H
+
+#include "Stk.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class FileRead
     \brief STK audio file input class.
@@ -13,51 +20,52 @@
     FileRead currently supports uncompressed WAV,
     AIFF/AIFC, SND (AU), MAT-file (Matlab), and
     STK RAW file formats.  Signed integer (8-,
-    16-, and 32-bit) and floating-point (32- and
+    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 is assumed to be 44100 Hz.
+    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 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FILEREAD_H
-#define STK_FILEREAD_H
-
-#include "Stk.h"
-
 class FileRead : public Stk
 {
 public:
   //! Default constructor.
-  FileRead();
+  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.
+    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 );
+  FileRead( std::string fileName, bool typeRaw = false, unsigned int nChannels = 1,
+            StkFormat format = STK_SINT16, StkFloat rate = 22050.0 );
 
   //! Class destructor.
-  ~FileRead();
+  ~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.  An optional parameter is
-    provided to specify whether the input file is of type STK RAW
-    (default = false).
+    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 );
+  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 );
@@ -71,6 +79,9 @@ public:
   //! 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
@@ -97,7 +108,8 @@ public:
 protected:
 
   // Get STK RAW file information.
-  bool getRawInfo( const char *fileName );
+  bool getRawInfo( const char *fileName, unsigned int nChannels,
+                   StkFormat format, StkFloat rate );
 
   // Get WAV file header information.
   bool getWavInfo( const char *fileName );
@@ -111,6 +123,9 @@ protected:
   // 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_;
@@ -121,4 +136,6 @@ protected:
   StkFloat fileRate_;
 };
 
+} // stk namespace
+
 #endif

include/FileWrite.h

@@ -1,3 +1,10 @@
+#ifndef STK_FILEWRITE_H
+#define STK_FILEWRITE_H
+
+#include "Stk.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class FileWrite
     \brief STK audio file output class.
@@ -10,22 +17,17 @@
 
     FileWrite currently supports uncompressed WAV, AIFF, AIFC, SND
     (AU), MAT-file (Matlab), and STK RAW file formats.  Signed integer
-    (8-, 16-, and 32-bit) and floating- point (32- and 64-bit) data
-    types are supported.  STK RAW files use 16-bit integers by
+    (8-, 16-, 24-, and 32-bit) and floating- point (32- and 64-bit)
+    data types are supported.  STK RAW files use 16-bit integers by
     definition.  MAT-files will always be written as 64-bit floats.
     If a data type specification does not match the specified file
     type, the data type will automatically be modified.  Compressed
     data types are not supported.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FILEWRITE_H
-#define STK_FILEWRITE_H
-
-#include "Stk.h"
-
 class FileWrite : public Stk
 {
  public:
@@ -39,7 +41,7 @@ class FileWrite : public Stk
   static const FILE_TYPE FILE_MAT; /*!< Matlab MAT-file type. */
 
   //! Default constructor.
-  FileWrite();
+  FileWrite( void );
 
   //! Overloaded constructor used to specify a file name, type, and data format with this object.
   /*!
@@ -74,28 +76,28 @@ class FileWrite : public Stk
  protected:
 
   // Write STK RAW file header.
-  bool setRawFile( const char *fileName );
+  bool setRawFile( std::string fileName );
 
   // Write WAV file header.
-  bool setWavFile( const char *fileName );
+  bool setWavFile( std::string fileName );
 
   // Close WAV file, updating the header.
   void closeWavFile( void );
 
   // Write SND (AU) file header.
-  bool setSndFile( const char *fileName );
+  bool setSndFile( std::string fileName );
 
   // Close SND file, updating the header.
   void closeSndFile( void );
 
   // Write AIFF file header.
-  bool setAifFile( const char *fileName );
+  bool setAifFile( std::string fileName );
 
   // Close AIFF file, updating the header.
   void closeAifFile( void );
 
   // Write MAT-file header.
-  bool setMatFile( const char *fileName );
+  bool setMatFile( std::string fileName );
 
   // Close MAT-file, updating the header.
   void closeMatFile( void );
@@ -109,4 +111,6 @@ class FileWrite : public Stk
 
 };
 
+} // stk namespace
+
 #endif

include/FileWvIn.h

@@ -1,17 +1,26 @@
+#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".
+    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() methods, which return samples produced by averaging
-    across sample frames, from the tickFrame() methods, which return
-    references to multi-channel sample frames.
+    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.
@@ -20,23 +29,26 @@
     chunkThreshold (in sample frames) will be read incrementally in
     chunks of \e chunkSize each (also in sample frames).
 
+    For file data read completely into local memory, the \e doNormalize
+    flag can be used to normalize all values with respect to the maximum
+    absolute value of the data.
+
+    If the file data format is fixed point, the flag \e doInt2FloatScaling
+    can be used to control whether the values are scaled with respect to
+    the corresponding fixed-point maximum. For example, if reading 16-bit
+    signed integers, the input values will be scaled by 1 / 32768.0. This
+    scaling will not happen for floating-point file data formats.
+
     When the file end is reached, subsequent calls to the tick()
-    functions return zero-valued data and isFinished() returns \e
-    true.
+    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 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FILEWVIN_H
-#define STK_FILEWVIN_H
-
-#include "WvIn.h"
-#include "FileRead.h"
-
 class FileWvIn : public WvIn
 {
 public:
@@ -49,45 +61,47 @@ public:
     unknown, or a read error occurs.
   */
   FileWvIn( std::string fileName, bool raw = false, bool doNormalize = true,
-            unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024 );
+            unsigned long chunkThreshold = 1000000, unsigned long chunkSize = 1024,
+            bool doInt2FloatScaling = true );
 
   //! Class destructor.
-  virtual ~FileWvIn();
+  ~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.
+    its format is unknown, or a read error occurs.  If the file length
+    is less than the chunkThreshold limit and \e doNormalize is true,
+    the file data will be normalized with respect to the maximum absolute
+    value of the data. If the \e doInt2FloatScaling flag is true and the
+    input data is fixed-point, a scaling will be applied with respect to
+    the fixed-point limits.
   */
-  void openFile( std::string fileName, bool raw = false, bool doNormalize = true );
+  virtual void openFile( std::string fileName, bool raw = false, bool doNormalize = true, bool doInt2FloatScaling = true );
 
   //! Close a file if one is open.
-  void closeFile( void );
+  virtual void closeFile( void );
 
   //! Clear outputs and reset time (file) pointer to zero.
-  void reset( void );
+  virtual void reset( void );
 
   //! Normalize data to a maximum of +-1.0.
   /*!
     This function has no effect when data is incrementally loaded
     from disk.
   */
-  void normalize( void );
+  virtual void normalize( void );
 
   //! Normalize data to a maximum of \e +-peak.
   /*!
     This function has no effect when data is incrementally loaded
     from disk.
   */
-  void normalize( StkFloat peak );
+  virtual void normalize( StkFloat peak );
 
   //! Return the file size in sample frames.
-  unsigned long getSize( void ) const { return data_.frames(); };
+  virtual unsigned long getSize( void ) const { return fileSize_; };
 
   //! Return the input file sample rate in Hz (not the data read rate).
   /*!
@@ -95,7 +109,10 @@ public:
     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.
   */
-  StkFloat getFileRate( void ) const { return data_.dataRate(); };
+  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_; };
@@ -104,7 +121,7 @@ public:
   /*!
     If the rate value is negative, the data is read in reverse order.
   */
-  void setRate( StkFloat rate );
+  virtual void setRate( StkFloat rate );
 
   //! Increment the read pointer by \e time samples.
   /*!
@@ -121,23 +138,71 @@ public:
   */
   void setInterpolate( bool doInterpolate ) { interpolate_ = doInterpolate; };
 
-  StkFloat lastOut( void ) const;
+  //! 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:
 
-  virtual void computeFrame( void );
+  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
   FileRead file_;
   bool finished_;
   bool interpolate_;
-  bool normalizing_;
+  bool int2floatscaling_;
   bool chunking_;
   StkFloat time_;
   StkFloat rate_;
+  unsigned long fileSize_;
   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

include/FileWvOut.h

@@ -1,3 +1,11 @@
+#ifndef STK_FILEWVOUT_H
+#define STK_FILEWVOUT_H
+
+#include "WvOut.h"
+#include "FileWrite.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class FileWvOut
     \brief STK audio file output class.
@@ -7,9 +15,9 @@
 
     FileWvOut writes samples to an audio file and supports
     multi-channel data.  It is important to distinguish the tick()
-    methods, which output single samples to all channels in a sample
-    frame, from the tickFrame() methods, which take a pointer or
-    reference to multi-channel sample frame data.
+    method that outputs a single sample to all channels in a sample
+    frame from the overloaded one that takes a reference to an
+    StkFrames object for multi-channel and/or multi-frame data.
 
     See the FileWrite class for a description of the supported audio
     file formats.
@@ -17,16 +25,10 @@
     Currently, FileWvOut is non-interpolating and the output rate is
     always Stk::sampleRate().
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FILEWVOUT_H
-#define STK_FILEWVOUT_H
-
-#include "WvOut.h"
-#include "FileWrite.h"
-
 class FileWvOut : public WvOut
 {
  public:
@@ -69,12 +71,23 @@ class FileWvOut : public WvOut
   */
   void closeFile( void );
 
+  //! Output a single sample to all channels in a sample frame.
+  /*!
+    An StkError is thrown if an output error occurs.
+  */
+  void tick( const StkFloat sample );
+
+  //! Output the StkFrames data.
+  /*!
+    An StkError will be thrown if an output error occurs.  An
+    StkError will also be thrown if _STK_DEBUG_ is defined during
+    compilation and there is an incompatability between the number of
+    channels in the FileWvOut object and that in the StkFrames object.
+  */
+  void tick( const StkFrames& frames );
+
  protected:
 
-  void computeSample( const StkFloat sample );
-
-  void computeFrames( const StkFrames& frames );
-
   void incrementFrame( void );
 
   FileWrite file_;
@@ -84,4 +97,6 @@ class FileWvOut : public WvOut
 
 };
 
+} // stk namespace
+
 #endif

include/Filter.h

@@ -1,122 +1,124 @@
-/***************************************************/
-/*! \class Filter
-    \brief STK filter class.
-
-    This class implements a generic structure that
-    can be used to create a wide range of filters.
-    It can function independently or be subclassed
-    to provide more specific controls based on a
-    particular filter type.
-
-    In particular, this class implements the standard
-    difference equation:
-
-    a[0]*y[n] = b[0]*x[n] + ... + b[nb]*x[n-nb] -
-                a[1]*y[n-1] - ... - a[na]*y[n-na]
-
-    If a[0] is not equal to 1, the filter coeffcients
-    are normalized by a[0].
-
-    The \e gain parameter is applied at the filter
-    input and does not affect the coefficient values.
-    The default gain value is 1.0.  This structure
-    results in one extra multiply per computed sample,
-    but allows easy control of the overall filter gain.
-
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
-*/
-/***************************************************/
-
 #ifndef STK_FILTER_H
 #define STK_FILTER_H
 
 #include "Stk.h"
 #include <vector>
+#include <cmath>
+
+namespace stk {
+
+/***************************************************/
+/*! \class Filter
+    \brief STK abstract filter class.
+
+    This class provides limited common functionality for STK digital
+    filter subclasses.  It is general enough to support both
+    monophonic and polyphonic input/output classes.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
 
 class Filter : public Stk
 {
 public:
-  //! Default constructor creates a zero-order pass-through "filter".
-  Filter(void);
+  //! Class constructor.
+  Filter( void ) { gain_ = 1.0; channelsIn_ = 1; lastFrame_.resize( 1, 1, 0.0 ); };
 
-  //! Overloaded constructor which takes filter coefficients.
-  /*!
-    An StkError can be thrown if either of the coefficient vector
-    sizes is zero, or if the a[0] coefficient is equal to zero.
-  */
-  Filter( std::vector<StkFloat> &bCoefficients, std::vector<StkFloat> &aCoefficients );
+  //! Return the number of input channels for the class.
+  unsigned int channelsIn( void ) const { return channelsIn_; };
 
-  //! Class destructor.
-  virtual ~Filter(void);
+  //! Return the number of output channels for the class.
+  unsigned int channelsOut( void ) const { return lastFrame_.channels(); };
 
-  //! Sets all internal states of the filter to zero.
-  void clear(void);
-
-  //! Set filter coefficients.
-  /*!
-    An StkError can be thrown if either of the coefficient vector
-    sizes is zero, or if the a[0] coefficient is equal to zero.  If
-    a[0] is not equal to 1, the filter coeffcients are normalized by
-    a[0].  The internal state of the filter is not cleared unless the
-    \e clearState flag is \c true.
-  */
-  void setCoefficients( std::vector<StkFloat> &bCoefficients, std::vector<StkFloat> &aCoefficients, bool clearState = false );
-
-  //! Set numerator coefficients.
-  /*!
-    An StkError can be thrown if coefficient vector is empty.  Any
-    previously set denominator coefficients are left unaffected.  Note
-    that the default constructor sets the single denominator
-    coefficient a[0] to 1.0.  The internal state of the filter is not
-    cleared unless the \e clearState flag is \c true.
-  */
-  void setNumerator( std::vector<StkFloat> &bCoefficients, bool clearState = false );
-
-  //! Set denominator coefficients.
-  /*!
-    An StkError can be thrown if the coefficient vector is empty or
-    if the a[0] coefficient is equal to zero.  Previously set
-    numerator coefficients are unaffected unless a[0] is not equal to
-    1, in which case all coeffcients are normalized by a[0].  Note
-    that the default constructor sets the single numerator coefficient
-    b[0] to 1.0.  The internal state of the filter is not cleared
-    unless the \e clearState flag is \c true.
-  */
-  void setDenominator( std::vector<StkFloat> &aCoefficients, bool clearState = false );
+  //! Clears all internal states of the filter.
+  virtual void clear( void );
 
   //! Set the filter gain.
   /*!
     The gain is applied at the filter input and does not affect the
     coefficient values.  The default gain value is 1.0.
    */
-  virtual void setGain(StkFloat gain);
+  void setGain( StkFloat gain ) { gain_ = gain; };
 
   //! Return the current filter gain.
-  virtual StkFloat getGain(void) const;
+  StkFloat getGain( void ) const { return gain_; };
 
-  //! Return the last computed output value.
-  virtual StkFloat lastOut(void) const;
+  //! Return the filter phase delay at the specified frequency.
+  /*!
+    Note that the phase delay calculation accounts for the filter
+    gain.  The frequency value should be greater than 0.0 and less
+    than or equal to one-half the sample rate.
+   */
+  StkFloat phaseDelay( StkFloat frequency );
 
-  //! Input one sample to the filter and return one output.
-  virtual StkFloat tick( StkFloat input );
+  //! Return an StkFrames reference to the last output sample frame.
+  const StkFrames& lastFrame( void ) const { return lastFrame_; };
 
   //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
   /*!
-    The \c channel argument should be zero or greater (the first
-    channel is specified by 0).  An StkError will be thrown if the \c
-    channel argument is equal to or greater than the number of
-    channels in the StkFrames object.
+    The StkFrames argument reference is returned.  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.
   */
-  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0;
 
 protected:
 
   StkFloat gain_;
+  unsigned int channelsIn_;
+  StkFrames lastFrame_;
+
   std::vector<StkFloat> b_;
   std::vector<StkFloat> a_;
-  std::vector<StkFloat> outputs_;
-  std::vector<StkFloat> inputs_;
+  StkFrames outputs_;
+  StkFrames inputs_;
 
 };
 
+inline void Filter :: clear( void )
+{
+  unsigned int i;
+  for ( i=0; i<inputs_.size(); i++ )
+    inputs_[i] = 0.0;
+  for ( i=0; i<outputs_.size(); i++ )
+    outputs_[i] = 0.0;
+  for ( i=0; i<lastFrame_.size(); i++ )
+    lastFrame_[i] = 0.0;  
+}
+
+inline StkFloat Filter :: phaseDelay( StkFloat frequency )
+{
+  if ( frequency <= 0.0 || frequency > 0.5 * Stk::sampleRate() ) {
+    oStream_ << "Filter::phaseDelay: argument (" << frequency << ") is out of range!";
+    handleError( StkError::WARNING ); return 0.0;
+  }
+
+  StkFloat omegaT = 2 * PI * frequency / Stk::sampleRate();
+  StkFloat real = 0.0, imag = 0.0;
+  for ( unsigned int i=0; i<b_.size(); i++ ) {
+    real += b_[i] * std::cos( i * omegaT );
+    imag -= b_[i] * std::sin( i * omegaT );
+  }
+  real *= gain_;
+  imag *= gain_;
+
+  StkFloat phase = atan2( imag, real );
+
+  real = 0.0, imag = 0.0;
+  for ( unsigned int i=0; i<a_.size(); i++ ) {
+    real += a_[i] * std::cos( i * omegaT );
+    imag -= a_[i] * std::sin( i * omegaT );
+  }
+
+  phase -= std::atan2( imag, real );
+  phase = std::fmod( -phase, 2 * PI );
+  return phase / omegaT;
+}
+
+} // stk namespace
+
 #endif

include/Fir.h

@@ -0,0 +1,155 @@
+#ifndef STK_FIR_H
+#define STK_FIR_H
+
+#include "Filter.h"
+
+namespace stk {
+
+/***************************************************/
+/*! \class Fir
+    \brief STK general finite impulse response filter class.
+
+    This class provides a generic digital filter structure that can be
+    used to implement FIR filters.  For filters with feedback terms,
+    the Iir class should be used.
+
+    In particular, this class implements the standard difference
+    equation:
+
+    y[n] = b[0]*x[n] + ... + b[nb]*x[n-nb]
+
+    The \e gain parameter is applied at the filter input and does not
+    affect the coefficient values.  The default gain value is 1.0.
+    This structure results in one extra multiply per computed sample,
+    but allows easy control of the overall filter gain.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
+
+class Fir : public Filter
+{
+public:
+  //! Default constructor creates a zero-order pass-through "filter".
+  Fir( void );
+
+  //! Overloaded constructor which takes filter coefficients.
+  /*!
+    An StkError can be thrown if the coefficient vector size is
+    zero.
+  */
+  Fir( std::vector<StkFloat> &coefficients );
+
+  //! Class destructor.
+  ~Fir( void );
+
+  //! Set filter coefficients.
+  /*!
+    An StkError can be thrown if the coefficient vector size is
+    zero.  The internal state of the filter is not cleared unless the
+    \e clearState flag is \c true.
+  */
+  void setCoefficients( std::vector<StkFloat> &coefficients, bool clearState = false );
+
+  //! Return the last computed output value.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
+
+  //! Input one sample to the filter and return one output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
+
+protected:
+
+};
+
+inline StkFloat Fir :: tick( StkFloat input )
+{
+  lastFrame_[0] = 0.0;
+  inputs_[0] = gain_ * input;
+
+  for ( unsigned int i=(unsigned int)(b_.size())-1; i>0; i-- ) {
+    lastFrame_[0] += b_[i] * inputs_[i];
+    inputs_[i] = inputs_[i-1];
+  }
+  lastFrame_[0] += b_[0] * inputs_[0];
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& Fir :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "Fir::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int i, hop = frames.channels();
+  for ( unsigned int j=0; j<frames.frames(); j++, samples += hop ) {
+    inputs_[0] = gain_ * *samples;
+    *samples = 0.0;
+
+    for ( i=(unsigned int)b_.size()-1; i>0; i-- ) {
+      *samples += b_[i] * inputs_[i];
+      inputs_[i] = inputs_[i-1];
+    }
+    *samples += b_[0] * inputs_[0];
+  }
+
+  lastFrame_[0] = *(samples-hop);
+  return frames;
+}
+
+inline StkFrames& Fir :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "Fir::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int i, iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int j=0; j<iFrames.frames(); j++, iSamples += iHop, oSamples += oHop ) {
+    inputs_[0] = gain_ * *iSamples;
+    *oSamples = 0.0;
+
+    for ( i=(unsigned int)b_.size()-1; i>0; i-- ) {
+      *oSamples += b_[i] * inputs_[i];
+      inputs_[i] = inputs_[i-1];
+    }
+    *oSamples += b_[0] * inputs_[0];
+  }
+
+  lastFrame_[0] = *(oSamples-oHop);
+  return iFrames;
+}
+
+} // stk namespace
+
+#endif

include/Flute.h

@@ -1,3 +1,17 @@
+#ifndef STK_FLUTE_H
+#define STK_FLUTE_H
+
+#include "Instrmnt.h"
+#include "JetTable.h"
+#include "DelayL.h"
+#include "OnePole.h"
+#include "PoleZero.h"
+#include "Noise.h"
+#include "ADSR.h"
+#include "SineWave.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Flute
     \brief STK flute physical model class.
@@ -18,22 +32,10 @@
        - Vibrato Gain = 1
        - Breath Pressure = 128
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FLUTE_H
-#define STK_FLUTE_H
-
-#include "Instrmnt.h"
-#include "JetTable.h"
-#include "DelayL.h"
-#include "OnePole.h"
-#include "PoleZero.h"
-#include "Noise.h"
-#include "ADSR.h"
-#include "SineWave.h"
-
 class Flute : public Instrmnt
 {
  public:
@@ -41,45 +43,56 @@ class Flute : public Instrmnt
   /*!
     An StkError will be thrown if the rawwave path is incorrectly set.
   */
-  Flute(StkFloat lowestFrequency);
+  Flute( StkFloat lowestFrequency );
 
   //! Class destructor.
-  ~Flute();
+  ~Flute( void );
 
   //! Reset and clear all internal state.
-  void clear();
+  void clear( void );
 
   //! Set instrument parameters for a particular frequency.
-  void setFrequency(StkFloat frequency);
+  void setFrequency( StkFloat frequency );
 
   //! Set the reflection coefficient for the jet delay (-1.0 - 1.0).
-  void setJetReflection(StkFloat coefficient);
+  void setJetReflection( StkFloat coefficient ) { jetReflection_ = coefficient; };
 
   //! Set the reflection coefficient for the air column delay (-1.0 - 1.0).
-  void setEndReflection(StkFloat coefficient);
+  void setEndReflection( StkFloat coefficient ) { endReflection_ = coefficient; };
 
   //! Set the length of the jet delay in terms of a ratio of jet delay to air column delay lengths.
-  void setJetDelay(StkFloat aRatio);
+  void setJetDelay( StkFloat aRatio );
 
   //! Apply breath velocity to instrument with given amplitude and rate of increase.
-  void startBlowing(StkFloat amplitude, StkFloat rate);
+  void startBlowing( StkFloat amplitude, StkFloat rate );
 
   //! Decrease breath velocity with given rate of decrease.
-  void stopBlowing(StkFloat rate);
+  void stopBlowing( StkFloat rate );
 
   //! Start a note with the given frequency and amplitude.
-  void noteOn(StkFloat frequency, StkFloat amplitude);
+  void noteOn( StkFloat frequency, StkFloat amplitude );
 
   //! Stop a note with the given amplitude (speed of decay).
-  void noteOff(StkFloat amplitude);
+  void noteOff( StkFloat amplitude );
 
   //! Perform the control change specified by \e number and \e value (0.0 - 128.0).
-  void controlChange(int number, StkFloat value);
+  void controlChange( int number, StkFloat value );
+
+  //! Compute and return one output sample.
+  StkFloat tick( unsigned int channel = 0 );
+
+  //! 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:
 
-  StkFloat computeSample( void );
-
   DelayL   jetDelay_;
   DelayL   boreDelay_;
   JetTable jetTable_;
@@ -88,7 +101,7 @@ class Flute : public Instrmnt
   Noise    noise_;
   ADSR     adsr_;
   SineWave vibrato_;
-  unsigned long length_;
+
   StkFloat lastFrequency_;
   StkFloat maxPressure_;
   StkFloat jetReflection_;
@@ -100,4 +113,54 @@ class Flute : public Instrmnt
 
 };
 
+inline StkFloat Flute :: tick( unsigned int )
+{
+  StkFloat pressureDiff;
+  StkFloat breathPressure;
+
+  // Calculate the breath pressure (envelope + noise + vibrato)
+  breathPressure = maxPressure_ * adsr_.tick();
+  breathPressure += breathPressure * ( noiseGain_ * noise_.tick() + vibratoGain_ * vibrato_.tick() );
+
+  StkFloat temp = -filter_.tick( boreDelay_.lastOut() );
+  temp = dcBlock_.tick( temp ); // Block DC on reflection.
+
+  pressureDiff = breathPressure - (jetReflection_ * temp);
+  pressureDiff = jetDelay_.tick( pressureDiff );
+  pressureDiff = jetTable_.tick( pressureDiff ) + (endReflection_ * temp);
+  lastFrame_[0] = (StkFloat) 0.3 * boreDelay_.tick( pressureDiff );
+
+  lastFrame_[0] *= outputGain_;
+  return lastFrame_[0];
+}
+
+inline StkFrames& Flute :: tick( StkFrames& frames, unsigned int channel )
+{
+  unsigned int nChannels = lastFrame_.channels();
+#if defined(_STK_DEBUG_)
+  if ( channel > frames.channels() - nChannels ) {
+    oStream_ << "Flute::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *samples = &frames[channel];
+  unsigned int j, hop = frames.channels() - nChannels;
+  if ( nChannels == 1 ) {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
+      *samples++ = tick();
+  }
+  else {
+    for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
+      *samples++ = tick();
+      for ( j=1; j<nChannels; j++ )
+        *samples++ = lastFrame_[j];
+    }
+  }
+
+  return frames;
+}
+
+} // stk namespace
+
 #endif

include/FormSwep.h

@@ -1,51 +1,56 @@
+#ifndef STK_FORMSWEP_H
+#define STK_FORMSWEP_H
+
+#include "Filter.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class FormSwep
     \brief STK sweepable formant filter class.
 
-    This public BiQuad filter subclass implements
-    a formant (resonance) which can be "swept"
-    over time from one frequency setting to another.
-    It provides methods for controlling the sweep
-    rate and target frequency.
+    This class implements a formant (resonance) which can be "swept"
+    over time from one frequency setting to another.  It provides
+    methods for controlling the sweep rate and target frequency.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#ifndef STK_FORMSWEP_H
-#define STK_FORMSWEP_H
-
-#include "BiQuad.h"
-
-class FormSwep : public BiQuad
+class FormSwep : public Filter
 {
  public:
 
   //! Default constructor creates a second-order pass-through filter.
-  FormSwep();
+  FormSwep( void );
 
   //! Class destructor.
   ~FormSwep();
 
+  //! A function to enable/disable the automatic updating of class data when the STK sample rate changes.
+  void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; };
+
   //! Sets the filter coefficients for a resonance at \e frequency (in Hz).
   /*!
     This method determines the filter coefficients corresponding to
     two complex-conjugate poles with the given \e frequency (in Hz)
     and \e radius from the z-plane origin.  The filter zeros are
-    placed at z = 1, z = -1, and the coefficients are then normalized to
-    produce a constant unity gain (independent of the filter \e gain
-    parameter).  The resulting filter frequency response has a
+    placed at z = 1, z = -1, and the coefficients are then normalized
+    to produce a constant unity gain (independent of the filter \e
+    gain parameter).  The resulting filter frequency response has a
     resonance at the given \e frequency.  The closer the poles are to
     the unit-circle (\e radius close to one), the narrower the
-    resulting resonance width.
+    resulting resonance width.  An unstable filter will result for \e
+    radius >= 1.0.  The \e frequency value should be between zero and
+    half the sample rate.
   */
-  void setResonance(StkFloat frequency, StkFloat radius);
+  void setResonance( StkFloat frequency, StkFloat radius );
 
   //! Set both the current and target resonance parameters.
-  void setStates(StkFloat frequency, StkFloat radius, StkFloat gain = 1.0);
+  void setStates( StkFloat frequency, StkFloat radius, StkFloat gain = 1.0 );
 
   //! Set target resonance parameters.
-  void setTargets(StkFloat frequency, StkFloat radius, StkFloat gain = 1.0);
+  void setTargets( StkFloat frequency, StkFloat radius, StkFloat gain = 1.0 );
 
   //! Set the sweep rate (between 0.0 - 1.0).
   /*!
@@ -56,7 +61,7 @@ class FormSwep : public BiQuad
     target values.  A sweep rate of 0.0 will produce no
     change in resonance parameters.  
   */
-  void setSweepRate(StkFloat rate);
+  void setSweepRate( StkFloat rate );
 
   //! Set the sweep rate in terms of a time value in seconds.
   /*!
@@ -64,11 +69,39 @@ class FormSwep : public BiQuad
     given time for the formant parameters to reach
     their target values.
   */
-  void setSweepTime(StkFloat time);
+  void setSweepTime( StkFloat time );
+
+  //! Return the last computed output value.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
+
+  //! Input one sample to the filter and return a reference to one output.
+  StkFloat tick( StkFloat input );
+
+  //! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
+  /*!
+    The StkFrames argument reference is returned.  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 );
+
+  //! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  Each channel
+    argument must be less than the number of channels in the
+    corresponding 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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
  protected:
 
-  StkFloat computeSample( StkFloat input );
+  virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
   bool dirty_;
   StkFloat frequency_;
@@ -87,4 +120,71 @@ class FormSwep : public BiQuad
 
 };
 
+inline StkFloat FormSwep :: tick( StkFloat input )
+{                                     
+  if ( dirty_ )  {
+    sweepState_ += sweepRate_;
+    if ( sweepState_ >= 1.0 )   {
+      sweepState_ = 1.0;
+      dirty_ = false;
+      radius_ = targetRadius_;
+      frequency_ = targetFrequency_;
+      gain_ = targetGain_;
+    }
+    else {
+      radius_ = startRadius_ + (deltaRadius_ * sweepState_);
+      frequency_ = startFrequency_ + (deltaFrequency_ * sweepState_);
+      gain_ = startGain_ + (deltaGain_ * sweepState_);
+    }
+    this->setResonance( frequency_, radius_ );
+  }
+
+  inputs_[0] = gain_ * input;
+  lastFrame_[0] = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
+  lastFrame_[0] -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
+  inputs_[2] = inputs_[1];
+  inputs_[1] = inputs_[0];
+  outputs_[2] = outputs_[1];
+  outputs_[1] = lastFrame_[0];
+
+  return lastFrame_[0];
+}
+
+inline StkFrames& FormSwep :: tick( StkFrames& frames, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel >= frames.channels() ) {
+    oStream_ << "FormSwep::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 = tick( *samples );
+
+  return frames;
+}
+
+inline StkFrames& FormSwep :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
+{
+#if defined(_STK_DEBUG_)
+  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
+    oStream_ << "FormSwep::tick(): channel and StkFrames arguments are incompatible!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  StkFloat *iSamples = &iFrames[iChannel];
+  StkFloat *oSamples = &oFrames[oChannel];
+  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
+  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop )
+    *oSamples = tick( *iSamples );
+
+  return iFrames;
+}
+
+} // stk namespace
+
 #endif

include/FreeVerb.h

@@ -0,0 +1,251 @@
+#ifndef STK_FREEVERB_H
+#define STK_FREEVERB_H
+
+#include "Effect.h"
+#include "Delay.h"
+#include "OnePole.h"
+
+namespace stk {
+
+/***********************************************************************/
+/*! \class FreeVerb
+    \brief Jezar at Dreampoint's FreeVerb, implemented in STK.
+
+    Freeverb is a free and open-source Schroeder reverberator
+    originally implemented in C++. The parameters of the reverberation
+    model are exceptionally well tuned. FreeVerb uses 8
+    lowpass-feedback-comb-filters in parallel, followed by 4 Schroeder
+    allpass filters in series.  The input signal can be either mono or
+    stereo, and the output signal is stereo.  The delay lengths are
+    optimized for a sample rate of 44100 Hz.
+
+    Ported to STK by Gregory Burlet, 2012.
+*/
+/***********************************************************************/
+
+class FreeVerb : public Effect
+{   
+ public:
+  //! FreeVerb Constructor
+  /*!
+    Initializes the effect with default parameters. Note that these defaults
+    are slightly different than those in the original implementation of
+    FreeVerb [Effect Mix: 0.75; Room Size: 0.75; Damping: 0.25; Width: 1.0;
+    Mode: freeze mode off].
+  */
+  FreeVerb();
+
+  //! Destructor
+  ~FreeVerb();
+
+  //! Set the effect mix [0 = mostly dry, 1 = mostly wet].
+  void setEffectMix( StkFloat mix );
+
+  //! Set the room size (comb filter feedback gain) parameter [0,1].
+  void setRoomSize( StkFloat value );
+
+  //! Get the room size (comb filter feedback gain) parameter.
+  StkFloat getRoomSize( void );
+
+  //! Set the damping parameter [0=low damping, 1=higher damping].
+  void setDamping( StkFloat value );
+
+  //! Get the damping parameter.
+  StkFloat getDamping( void );
+
+  //! Set the width (left-right mixing) parameter [0,1].
+  void setWidth( StkFloat value );
+
+  //! Get the width (left-right mixing) parameter.
+  StkFloat getWidth( void );
+
+  //! Set the mode [frozen = 1, unfrozen = 0].
+  void setMode( bool isFrozen );
+
+  //! Get the current freeze mode [frozen = 1, unfrozen = 0].
+  StkFloat getMode( void );
+
+  //! Clears delay lines, etc.
+  void clear( void );
+
+  //! Return the specified channel value of the last computed stereo frame.
+  /*!
+    Use the lastFrame() function to get both values of the last
+    computed stereo frame.  The \c channel argument must be 0 or 1
+    (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.
+  */
+  StkFloat lastOut( unsigned int channel = 0 );
+
+  //! Input one or two samples to the effect and return the specified \c channel value of the computed stereo frame.
+  /*!
+    Use the lastFrame() function to get both values of the computed
+    stereo output frame. The \c channel argument must be 0 or 1 (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.
+  */
+  StkFloat tick( StkFloat inputL, StkFloat inputR = 0.0, unsigned int channel = 0 );
+
+  //! Take two channels of the StkFrames object as inputs to the effect and replace with stereo outputs.
+  /*!
+    The StkFrames argument reference is returned.  The stereo
+    inputs are taken from (and written back to) the StkFrames argument
+    starting at the specified \c channel.  Therefore, the \c channel
+    argument must be less than ( channels() - 1 ) of 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 );
+
+  //! Take one or two channels of the \c iFrames object as inputs to the effect and write stereo outputs to the \c oFrames object.
+  /*!
+    The \c iFrames object reference is returned.  The \c iChannel
+    argument must be less than the number of channels in the \c
+    iFrames argument (the first channel is specified by 0).  If more
+    than one channel of data exists in \c iFrames starting from \c
+    iChannel, stereo data is input to the effect.  The \c oChannel
+    argument must be less than ( channels() - 1 ) of the \c oFrames
+    argument.  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& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
+
+ protected:
+  //! Update interdependent parameters.
+  void update( void );
+
+  // Clamp very small floats to zero, version from
+  // http://music.columbia.edu/pipermail/linux-audio-user/2004-July/013489.html .
+  // However, this is for 32-bit floats only.
+  //static inline StkFloat undenormalize( volatile StkFloat s ) { 
+  //  s += 9.8607615E-32f; 
+  //  return s - 9.8607615E-32f; 
+  //}
+    
+  static const int nCombs = 8;
+  static const int nAllpasses = 4;
+  static const int stereoSpread = 23;
+  static const StkFloat fixedGain;
+  static const StkFloat scaleWet;
+  static const StkFloat scaleDry;
+  static const StkFloat scaleDamp;
+  static const StkFloat scaleRoom;
+  static const StkFloat offsetRoom;
+
+  // Delay line lengths for 44100Hz sampling rate.
+  static int cDelayLengths[nCombs];
+  static int aDelayLengths[nAllpasses];
+
+  StkFloat g_;        // allpass coefficient
+  StkFloat gain_;
+  StkFloat roomSizeMem_, roomSize_;
+  StkFloat dampMem_, damp_;
+  StkFloat wet1_, wet2_;
+  StkFloat dry_;
+  StkFloat width_;
+  bool frozenMode_;
+
+  // LBFC: Lowpass Feedback Comb Filters
+  Delay combDelayL_[nCombs];
+  Delay combDelayR_[nCombs];
+  OnePole combLPL_[nCombs];
+  OnePole combLPR_[nCombs];
+        
+  // AP: Allpass Filters
+  Delay allPassDelayL_[nAllpasses];
+  Delay allPassDelayR_[nAllpasses];
+};
+
+inline StkFloat FreeVerb :: lastOut( unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel > 1 ) {
+    oStream_ << "FreeVerb::lastOut(): channel argument must be less than 2!";
+    handleError( StkError::FUNCTION_ARGUMENT );
+  }
+#endif
+
+  return lastFrame_[channel];
+}
+
+inline StkFloat FreeVerb::tick( StkFloat inputL, StkFloat inputR, unsigned int channel )
+{
+#if defined(_STK_DEBUG_)
+  if ( channel > 1 ) {
+    oStream_ << "FreeVerb::tick(): channel argument must be less than 2!";
+    handleError(StkError::FUNCTION_ARGUMENT);
+  }
+#endif
+
+  StkFloat fInput = (inputL + inputR) * gain_;
+  StkFloat outL = 0.0;
+  StkFloat outR = 0.0;
+
+  // Parallel LBCF filters
+  for ( int i = 0; i < nCombs; i++ ) {
+    // Left channel
+    //StkFloat yn = fInput + (roomSize_ * FreeVerb::undenormalize(combLPL_[i].tick(FreeVerb::undenormalize(combDelayL_[i].nextOut()))));
+    StkFloat yn = fInput + (roomSize_ * combLPL_[i].tick( combDelayL_[i].nextOut() ) );
+    combDelayL_[i].tick(yn);
+    outL += yn;
+
+    // Right channel
+    //yn = fInput + (roomSize_ * FreeVerb::undenormalize(combLPR_[i].tick(FreeVerb::undenormalize(combDelayR_[i].nextOut()))));
+    yn = fInput + (roomSize_ * combLPR_[i].tick( combDelayR_[i].nextOut() ) );
+    combDelayR_[i].tick(yn);
+    outR += yn;
+  }
+
+  // Series allpass filters
+  for ( int i = 0; i < nAllpasses; i++ ) {
+    // Left channel
+    //StkFloat vn_m = FreeVerb::undenormalize(allPassDelayL_[i].nextOut());
+    StkFloat vn_m = allPassDelayL_[i].nextOut();
+    StkFloat vn = outL + (g_ * vn_m);
+    allPassDelayL_[i].tick(vn);
+        
+    // calculate output
+    outL = -vn + (1.0 + g_)*vn_m;
+
+    // Right channel
+    //vn_m = FreeVerb::undenormalize(allPassDelayR_[i].nextOut());
+    vn_m = allPassDelayR_[i].nextOut();
+    vn = outR + (g_ * vn_m);
+    allPassDelayR_[i].tick(vn);
+
+    // calculate output
+    outR = -vn + (1.0 + g_)*vn_m;
+  }
+
+  // Mix output
+  lastFrame_[0] = outL*wet1_ + outR*wet2_ + inputL*dry_;
+  lastFrame_[1] = outR*wet1_ + outL*wet2_ + inputR*dry_;
+
+  /*
+  // Hard limiter ... there's not much else we can do at this point
+  if ( lastFrame_[0] >= 1.0 ) {
+    lastFrame_[0] = 0.9999;
+  }
+  if ( lastFrame_[0] <= -1.0 ) {
+    lastFrame_[0] = -0.9999;
+  }
+  if ( lastFrame_[1] >= 1.0 ) {
+    lastFrame_[1] = 0.9999;
+  }
+  if ( lastFrame_[1] <= -1.0 ) {
+    lastFrame_[1] = -0.9999;
+  }
+  */
+
+  return lastFrame_[channel];
+}
+
+}
+
+#endif

include/Function.h

@@ -1,54 +1,41 @@
+#ifndef STK_FUNCTION_H
+#define STK_FUNCTION_H
+
+#include "Stk.h"
+
+namespace stk {
+
 /***************************************************/
 /*! \class Function
     \brief STK abstract function parent class.
 
-    This class provides common functionality for STK classes which
+    This class provides common functionality for STK classes that
     implement tables or other types of input to output function
     mappings.
 
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
 */
 /***************************************************/
 
-#include "Stk.h"
-
-#ifndef STK_FUNCTION_H
-#define STK_FUNCTION_H
-
 class Function : public Stk
 {
  public:
   //! Class constructor.
-  Function();
+  Function( void ) { lastFrame_.resize( 1, 1, 0.0 ); };
 
-  //! Class destructor.
-  virtual ~Function();
-
-  //! Return the last output value.
-  virtual StkFloat lastOut() const { return lastOutput_; };
+  //! Return the last computed output sample.
+  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
   //! Take one sample input and compute one sample of output.
-  StkFloat tick( StkFloat input );
-
-  //! Take a channel of the StkFrames object as inputs to the function and replace with corresponding outputs.
-  /*!
-    The \c channel argument should be zero or greater (the first
-    channel is specified by 0).  An StkError will be thrown if the \c
-    channel argument is equal to or greater than the number of
-    channels in the StkFrames object.
-  */
-  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+  virtual StkFloat tick( StkFloat input ) = 0;
 
  protected:
 
-  // This abstract function must be implemented in all subclasses.
-  // It is used to get around a C++ problem with overloaded virtual
-  // functions.
-  virtual StkFloat computeSample( StkFloat input ) = 0;
-
-  StkFloat lastOutput_;
+  StkFrames lastFrame_;
 
 };
 
+} // stk namespace
+
 #endif
 

include/Generator.h

@@ -1,53 +1,50 @@
-/***************************************************/
-/*! \class Generator
-    \brief STK abstract unit generator parent class.
-
-    This class provides common functionality for
-    STK unit generator sample-source subclasses.
-
-    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
-*/
-/***************************************************/
-
 #ifndef STK_GENERATOR_H
 #define STK_GENERATOR_H
 
 #include "Stk.h"
 
+namespace stk {
+
+/***************************************************/
+/*! \class Generator
+    \brief STK abstract unit generator parent class.
+
+    This class provides limited common functionality for STK unit
+    generator sample-source subclasses.  It is general enough to
+    support both monophonic and polyphonic output classes.
+
+    by Perry R. Cook and Gary P. Scavone, 1995--2016.
+*/
+/***************************************************/
+
 class Generator : public Stk
 {
  public:
+
   //! Class constructor.
-  Generator( void );
+  Generator( void ) { lastFrame_.resize( 1, 1, 0.0 ); };
 
-  //! Class destructor.
-  virtual ~Generator( void );
+  //! Return the number of output channels for the class.
+  unsigned int channelsOut( void ) const { return lastFrame_.channels(); };
 
-  //! Return the last output value.
-  virtual StkFloat lastOut( void ) const { return lastOutput_; };
+  //! Return an StkFrames reference to the last output sample frame.
+  const StkFrames& lastFrame( void ) const { return lastFrame_; };
 
-  //! Compute one sample and output.
-  StkFloat tick( void );
-
-  //! Fill a channel of the StkFrames object with computed outputs.
+  //! Fill the StkFrames object with computed sample frames, starting at the specified channel.
   /*!
-    The \c channel argument should be zero or greater (the first
-    channel is specified by 0).  An StkError will be thrown if the \c
-    channel argument is equal to or greater than the number of
-    channels in the StkFrames object.
+    The \c channel argument plus the number of output 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.
   */
-  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
+  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0;
 
- protected:
-
-  // This abstract function must be implemented in all subclasses.
-  // It is used to get around a C++ problem with overloaded virtual
-  // functions.
-  virtual StkFloat computeSample( void ) = 0;
-
-  StkFloat lastOutput_;
+  protected:
 
+  StkFrames lastFrame_;
 };
 
-#endif
+} // stk namespace
 
+#endif