CSL 5.2

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1 2 3]

cram |
csl | AdditiveInstrument.h – Sum-of-sines synthesis instrument class
CSLService |
Accessor | Has public data members
AdditiveInstrument | AdditiveInstrument
VAdditiveInstrument | VAdditiveInstrument = vector-additive - cross-fade between 2 SOS spectra Envelope mXEnv(dur, pause, xfade, 0.0f) float paus = fRandV(0.5) * dur; float fade = fRandV(dur - paus); AR(float t, float i, float a, float r);
FMInstrument | FMInstrument
FancyFMInstrument | FancyFMInstrument - FM with vibrato (with AR-envelope), attack chiff (filtered noise with AR-envelope), and random freq. drift and ampl. swell envelopes
Instrument | Instrument class (abstract)
WhiteNoiseInstrument |
SndFileInstrument | Sound file player instrument
SampleBankInstrument | Sample bank player instrument
AUIO | General-purpose AudioUnit IO class
CAIO | CoreAudio IO class
FileIO | FileIO.h – IO using a sound file for storing output sample data
iPhoneIO | CoreAudio IO class for the iPhone
JackIO | JackIO is an IO that uses a thread and a timer to call its graph's nextBuffer(); it doesn't do anything with the resulting buffer, but assumes that other objects (observers of the graph) will handle some actual IO
JUCEIO | JUCEIO is an IO that runs as a JUCE
Microphone | Microphone – copies the input buffer (from the sound driver) to its output
CMIDIMessage | CMIDIMessage class (mapped to juce::MidiMessage)
MIDIIO | MIDIIO class: superclass of in and out; has a message buffer and current messages It's a model so you can observe it. Uses mMsg.CMIDIMessageType as a status flag
MIDIIn | MIDIIn class is-a MidiInputCallback too, and an "input-ready" flag
MIDIOut | MIDIOut class write msgs out to a device (or file)
MIDIPlayer | MIDI stream/file player
CSL_MIDIMessage | CSL_MIDIMessage
NullIO | NullIO is an IO that uses a thread and a timer to call its graph's nextBuffer(); it doesn't do anything with the resulting buffer, but assumes that other objects (observers of the graph) will handle some actual IO
StdIO | StdIO reads/write the UNIX Standard IO pipes
PAIO | The PortAudio IO class
RemoteIO | RemoteIO class
CSL_RS_MSG |
RemoteStream | RemoteStream class
SoundFileMetadata | Class SndFileMetadata holds the ID3 tags of a sound file
Abst_SoundFile | Here's the abstract sound file reader/writer class, a sample player UGen. The concrete subclasses represent sound file APIs, not individual formats
SoundCue | SoundCue – a pointer to a segment of a sound file
CASoundFile | CoreAudio sound file
JSoundFile | JUCE sound file
LSoundFile | Here's the sound file reader/writer class; it assumes libSndFile and interleaved sample buffers
DecodedFile | DecodedFile - abstract class for MP3/4/AAC - read-only decoded files Provides a BufferVector for reading files of unknown size
MP3File | MP3File - decodes MP3s into a buffer upon openForRead()
VSTIO | VSTIO is an IO that answers the VST processReplacing() call by calling its CSL graph
CGestalt | The CSL system defaults class
Model | The Model/Observable/Subject class; instances of its subclasses should send themselves, this->changed(some_data); on "relevant" state changes; the code they inherit (from Model) manages updating the list of observer/dependent objects in that they each receive update(some_data); and can access the model-passed data (the model might pass "this")
Observer | CSL Observer/Dependent/Monitor class – instances receive update() messages from "models" and handle some argument, which may be the model's "this" pointer, or any other data
Buffer | Buffer – the multi-channel sample buffer class (passed around between generators and IO guys)
BufferCMap | BufferCMap is a Sample buffer with channel map and count. The map is so that one can have (e.g.,) a buffer that stands for 3 channels within an 8-channel space
UnitGenerator | Forward declaration
Port | Port – used to represent constant, control-rate or signal inputs and outputs in named maps; holds a UnitGenerator and its buffer, OR a single floating-point value (in which case the UGen pointer is set to NULL and mPtrIncrement = 0). The nextValue() message is used to get the dynamic or static value
Controllable | Controllable – superclass of the mix-ins that add control or signal inputs. This holds onto a map of port objects that represent the inputs, and manages the naming and processing flow for dynamic inputs
Scalable | Scalable – mix-in class with scale and offset control inputs (may be constants or generators). This uses the mInput map keys CSL_SCALE and CSL_OFFSET. Most actual unit generators inherit this as well as UnitGenerator. We use Controllable as a virtual superclass so that we can mix it in twice (in classes that are also Phased)
Effect | Effect – mix-in for classes that have unit generators as inputs (like filters). Note that this always uses a separate buffer for the input
Phased | Phased – a mix-in for objects with phase accumulators (local float) and frequency controls (an input port). This puts an item named CSL_FREQUENCY in the Controllable parent mInputs map. We use Controllable as a virtual superclass so that we can mix it in twice (in classes that are also Scalable)
Writeable | Writeable – a mix-in for buffers and streams that one can write to
Seekable | Seekable – a mix-in for positionable streams
Cacheable | Cacheable – a mix-in for caching streams
FanOut | A fan-out generator for DSP graphs with loops This takes a single input, and provides mNumFanOuts outputs; it only calls its input every mNumFanOuts frames. This behavior is now standard on UnitGenerators, using their mOutputs UGenVector (see UnitGenerators::nextBuffer)
Splitter | Splitter class – a de-multiplexer for multi-channel signals
Joiner | Joiner class – a multiplexer for multi-channel signals
Interleaver | Interleaver handles copying interleaved sample buffers (like sound files and inter-process sockets) to/from non-interleaved CSL-style Buffer objects
IO | IO – the abstract I/O scheduling class; subclasses interface to specific I/O APIs. An IO object has a graph (a ptr to a UGen), and it registers itself with some call-back API (like PortAudio, CoreAudio, Jack, VST, JUCE), setting up a callback function that in turn calls the nextBuffer() method of its graph root. One creates an IO with the desired rate, block size (optional) I/O device keys, and the number of in and out channels; you then set its root to be your DSP graph and send it start/stop messages
IODevice | IO Device class – a holder for a sound interface with name, id, # IO channels, etc
CException | Base class of CSL exceptions (written upper-case). Has a string message
MemoryError | Malloc failure subclass
ValueError | Wrong kind of operand error
TimingError | Time-out
RunTimeError | Illegal operation at run time
LogicError | Impossible operation
DomainError | Numerical data of wrong type
OutOfRangeError | Data out of range
IOError | IO Error
DBError | DB Error
ProcessingError | Processing Error
testStruct |
BinaryOp | BinaryOp – An Effect that takes two input sources (UnitGenerators or scalars) and gives a single UnitGenerator as its output. BinaryOp is an abstract class who's nextBuffer method is to be implemented by subclasses
AddOp | AddOp – A BinaryOp that adds two UnitGenerators or fixed constants together
MulOp | MulOp – A BinaryOp that multiplies two UnitGenerators or fixed constants together, sample-by-sample
Clipper | Clipper class
FrequencyAmount | FrequencyAmount – mix-in class with frequency and amount (BW) control inputs (may be constants or generators). amount (probably 0..1) is a generalised placeholder for bandwidth, resonance or radius, according to filter type or could equally be used as a kind of x,y location in the frequency domain
Filter | Filter: the canonical-form n-pole/m-zero filter class
Butter | Butterworth IIR (2nd order recursive) filter. This operates upon a buffer of frames of amplitude samples by applying the following equation y(n) = a0*x(n) + a1*x(n-1) + a2*x(n-2) - b1*y(n-1) - b2*y(n-2) where x is an amplitude sample. It has constructors that can calculate the coefficients from a given cutoff frequency
Formant | Formant Filter with zeros at +-z and complex conjugate poles at +-omega. setupCoeffs() looks at the member var called normalize; if normalize is true, the filter zeros are placed at z = 1, z = -1, and the coefficients are then normalized to produce a constant unity peak gain. The resulting filter frequency response has a resonance at the given frequency. The closer the poles are to the unit-circle (radius close to one), the narrower the resulting resonance width
Notch | Notch Filter with poles at +-z and complex conjugate zeros at +-omega
Allpass | Allpass Filter with a pole and a zero at equal frequency and straddling the unit circle. Allows all freqs to pass through but messes with phases. Note that the Amount parameter of FrequencyAmount is ignored
Moog | Moog VCF class
FilterSpecification | Forward declaration
FIR | FIR Filter class
Freeverb | CSL port of the public domain Freeverb reverberator
Comb | Comb filter class
FAllpass | All-pass filter class
Stereoverb |
InOut | InOut class copies the IO port's input buffer to the output buffer, possibly with channel remap and scaling
Mixer | Mixer – The n-input m-channel mixer class
Panner | The CSL mono-to-stereo L/R panner class
NtoMPanner |
StereoWidth | Stereo width processor – can mix stereo channels or subtract the sum from each to widen
CslRtpSession |
RtpReceiver |
RtpSender |
LineSegment | A linearly interpolated segment – this has start and end values, and a duration (in seconds)
Envelope | Envelope: a collection of LineSegments; may have an input (scale) and act like a processor, or have no input and act like a control UGen. I inherit Scalable setScale, setOffset for inputs
ADSR | ADSR = 4-segment attack/decay/sustain/release envelope class
AR | AR = 3-segment attack/release envelope class
Triangle | Triangle envelope class – equal attack/release times
RandEnvelope | RandEnvelope envelope class – makes random control signals using a single line segment
Grain | Grain data structure This implementation uses a linked list data structure. You might want to add a few more members to this for flexibility
GrainCloud | GrainCloud – routine for playing clouds under GUI control. This could be called a cloud or a stream. You could also add a few more variables to make more flexible clouds
GrainPlayer | GrainPlayer – low-level granular synthesis generator, uses a list of current grains
KarplusString | KarplusString – string model class
Lorenz | Lorenz chaotic oscillator = this plays one variable of the Lorenz Strange Attractor between +1 and -1
Noise | Abstract Noise class - inherits from UnitGenerator & Scalable, and provides constructors and basic pseudo-raondom methods
WhiteNoise | White noise – equal power per frequency
PinkNoise | Pink noise – equal power per octave
WaveShaper | WaveShaper – Wave-shaping oscillator class
Oscillator | Oscillator – Abstract oscillator class; inherits from UnitGenerator, Phased, and Scalable and provides convenience constructors (freq, ampl, offset, phase)
WavetableOscillator | WavetableOscillator – Oscillator with a stored wave table that does table look-up. The default wave table is an 8192-sample sine. (perhaps accept a vector of freqs and a multichannel buffer?)
CompOrCacheOscillator | CompOrCacheOscillator – Abstract oscillator class for those who can compute of cache their wavetables
Sine | Sine – oscillator class (this computes the sine fcn on the fly)
FSine | FSine – (uses a ringing filter for the sine calc)
Sawtooth | Sawtooth oscillator class (non-band-limited)
Square | Square oscillator class (non-band-limited)
Impulse | Impulse – oscillator class (this create a single impulse delayed by 'delay' samples)
Partial | Struct for partial overtones
SumOfSines |
SquareBL | Band-limited square, impulse, and triangle waveform oscillators
SHARCSpectrum | SHARC spectrum class
SHARCInstrument | SHARC instrument class
SHARCLibrary | SHARC library class
SimpleSine | SimpleSine – The simplest CSL sine oscillator class
SineAsPhased | SineAsPhased – A sine oscillator that uses the Phased mix-in class, meaning that we inherit mFrequency and mPhase and macros for dynamic control
SineAsScaled | SineAsScaled – A sine oscillator that also has scale and offset as dynamic controls (from Scalable) (Note the tripple inheritance)
FFT | Forward FFT unit generator is an Effect because it handles an input It puts spectral frames in the output buffer and then broadcasts a change message, so clients are expected to observe it
IFFT | Inverse FFT
Window | Window; The superclass of all other window function classes in CSL. Subclasses need only to implement the fillWindow(); and the Constructors
RectangularWindow | RectangularWindow:A rectangular window has all values set to the Gain value, or by default to 1
TriangularWindow | TriangularWindow:A triangularWindow window
HammingWindow | HammingWindow: Belongs to the familly of cosine window functions
HannWindow | HannWindow
BlackmanWindow | BlackmanWindow
BlackmanHarrisWindow | BlackmanHarrisWindow
WelchWindow | WelchWindow: This is basically an equal-power curve
AmbisonicOrder | Ambisonic order structure (separate definition for horizontal and vertical order):
AmbisonicUnitGenerator | Ambisonic Abstract Base Class
AmbisonicEncoder |
AmbisonicDecoder |
AmbisonicPanner | Ambisonic Panner Wraps around the different ambisonic classes, providing a single interface for encoding, manipulating and decoding (i.e. panning) multiple UnitGenerators
AmbisonicMixer |
AmbisonicRotator |
BinauralPanner | Forward declaration
BinauralSourceCache | BinauralSourceCache: used for caching previous state of spatial sources. This has the history of input FFTs and the last output sample block for OLA
HRTF | HRTF: holds the data that corresponds to an HRTF for a single position. It has a list of complex buffers for the FFTs of the HRIR, typically 16 blocks of 512 each for an 8k HRTF. This version knows how to parse the IRCAM hrtfs sets Subclasses could load different HRTF sets (e.g., CIPIC)
HRTFDatabase | HRTFDatabase: has a vector of HRTFs and can access them by position – hrtfAt(CPoint) – or by index – hrtfAt(unsigned). Implemented as a Singleton because it's large (typ 188 HRTFs, 25 MB). Create it with a folder/resource name, it reads "files.txt" for a list of HRIR files to load. This has a number of file/folder/DB IO methods for load/store of bulk HRTF data sets in IRCAM format and CSL's pre-processed HRTF.dat files
DistanceSimulator | Only handles single sound sources because objects have different positions. Two objects can't ocuppy the same position, and usually distance cues go before the panning, so handling multiple sources by one Distance simulator, would producde a multi-channel object, where the positions aren't dynamic anymore
DistanceCue | Pure Abstract Base Class for all distance cues. A DistanceCue subclass is just an algorithm that modifies a signal based on the distance from the listener. Distance Cues should hold their state, so when "process" is called they can modify the signal buffer given. When "compute" is called is usually due to a change in distance, so if anything has to be re-calculated, it's done
IntensityAttenuationCue | Sound attenuation due to increasing distance. This "Base" Class uses the inverse square law. Subclass for other methods
AirAbsorptionCue | Simulates the frequency dependent air absorption using a one pole/zero lowpass filter
ShoeBox |
SimplePanner | Simple Panner
Spatializer | Container class that simplifies the spatial audio interface. This layer hides most of the inner-working of audio spatialization, providing a simple interface for sound placement in a space
Auralizer |
SpeakerLayoutExpert |
SpatialPanner | Base class for all panners. Handles source management and holds a speaker layout
SpatialSource | Temp Spatial Sound Source
SpeakerLayout |
StereoSpeakerLayout | Standard "Stereo Speaker Layout", where two speakers are positioned 30¼ left, 30¼ right and no elevation (0¼)
HeadphoneSpeakerLayout | "Headphone Layout", where two phones are positioned 90¼ left, 90¼ right and no elevation (0¼)
Speaker | Represents a speaker as a position relative to the center of a space
DelayLine |
DLine |
VBAP | Vector Base Amplitude Panning
StereoPanner | Simple Stereo Panner
SurroundPanner | Generic Panner for most surround formats. It accepts any number of speakers around the horizontal plane, and a subwoofer (.1 or not)
VBAPSourceCache |
SpeakerSet | Groups two or three loudspeakers, and their inverse. Used for VBAP computations
SpeakerSetLayout |
BlockResizer | Regularizes the amount of data called for. This is useful for time-frequency transformations that only work with certain buffer sizes
CPoint |
Abst_FFT_W | Abstract FFT class can do forward/reverse real/complex I/O FFTs
RingBufferTap | RingBufferTap is a reader that loops over a buffer
RingBuffer | RingBuffer is the storage + a default reader
BufferStream | Class to simplify writing into and playing back buffers. Think of this as a simple buffer that has a seek, read and write calls built-in
CThread | The abstract CSL Thread class
Synch | Sync is a cross-thread synchronization object
SynchPthread | PThread version of Sync
ThreadPthread | PThread version of Thread
CVariable | CVariable is the the abstract external variable (plug or port) class. This is the abstract class for static and dynamic variables; it's a sample stream. Clients of Variable (oscillators, dsp units, etc) first ask whether its values are fixed over the length of the buffer or not. If the value is fixed, the client calls next_sample() to get the next sample and use it the DSP loop. If the value is not fixed, the client calls next_buffer() to get the next buffer of values
StaticVariable | StaticVariable – he static external variable (plug) class. This is a kind of variable that holds onto floating-point value that is fixed each control rate period (e.g., changes at most once per control rate)
DynamicVariable | Changing variable that can perform an operation (e.g., scaling) on another unit generator
math |
matrix_error |
matrix |
base_mat |
std |
_lo_address |
_lo_blob |
_lo_bundle |
_lo_message |
_lo_method |
_lo_server |
_lo_server_thread |
_lo_strlist |
CommunicatingSocket |
Connection |
Controller |
controller_str |
end_test32 |
end_test64 |
FFTReal |
BitReversedLUT |
TrigoLUT |
Inst_Context |
lo_arg | Union used to read values from incoming messages
lo_cs |
lo_pcast32 |
lo_pcast64 |
lo_split64 |
lo_timetag | A structure to store OSC TimeTag values
Orbit |
PME |
PMESource |
queued_msg_list |
SAFliter |
Socket |
SocketException |
TCPServerSocket |
TCPSocket |
UDPSocket |
vbuffer |