CSL 5.2

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

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

Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1 2 3 4 5 6 7 8]

_lo_address |
_lo_blob |
_lo_bundle |
_lo_message |
_lo_method |
_lo_server |
_lo_server_thread |
_lo_strlist |
csl::Abst_FFT_W | Abstract FFT class can do forward/reverse real/complex I/O FFTs
csl::Accessor | Has public data members
csl::AmbisonicOrder | Ambisonic order structure (separate definition for horizontal and vertical order):
math::matrix::base_mat |
csl::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
FFTReal::BitReversedLUT |
csl::Buffer | Buffer – the multi-channel sample buffer class (passed around between generators and IO guys)
csl::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
csl::Cacheable | Cacheable – a mix-in for caching streams
csl::CompOrCacheOscillator | CompOrCacheOscillator – Abstract oscillator class for those who can compute of cache their wavetables
csl::SumOfSines |
csl::SquareBL | Band-limited square, impulse, and triangle waveform oscillators
csl::CException | Base class of CSL exceptions (written upper-case). Has a string message
csl::LogicError | Impossible operation
csl::DBError | DB Error
csl::MemoryError | Malloc failure subclass
csl::RunTimeError | Illegal operation at run time
csl::TimingError | Time-out
csl::ValueError | Wrong kind of operand error
csl::DomainError | Numerical data of wrong type
csl::IOError | IO Error
csl::OutOfRangeError | Data out of range
csl::ProcessingError | Processing Error
csl::CGestalt | The CSL system defaults class
csl::CMIDIMessage | CMIDIMessage class (mapped to juce::MidiMessage)
csl::Comb | Comb filter class
Connection |
csl::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
csl::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
csl::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
csl::AddOp | AddOp – A BinaryOp that adds two UnitGenerators or fixed constants together
csl::MulOp | MulOp – A BinaryOp that multiplies two UnitGenerators or fixed constants together, sample-by-sample
csl::Clipper | Clipper class
csl::DelayLine |
csl::DynamicVariable | Changing variable that can perform an operation (e.g., scaling) on another unit generator
csl::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)
csl::Splitter | Splitter class – a de-multiplexer for multi-channel signals
csl::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
csl::Filter | Filter: the canonical-form n-pole/m-zero filter class
csl::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
csl::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
csl::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
csl::Moog | Moog VCF class
csl::Notch | Notch Filter with poles at +-z and complex conjugate zeros at +-omega
csl::FIR | FIR Filter class
csl::Freeverb | CSL port of the public domain Freeverb reverberator
csl::InOut | InOut class copies the IO port's input buffer to the output buffer, possibly with channel remap and scaling
csl::Joiner | Joiner class – a multiplexer for multi-channel signals
csl::Panner | The CSL mono-to-stereo L/R panner class
csl::NtoMPanner |
csl::RingBuffer | RingBuffer is the storage + a default reader
csl::RtpSender |
csl::Stereoverb |
csl::StereoWidth | Stereo width processor – can mix stereo channels or subtract the sum from each to widen
SAFliter |
csl::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
csl::Filter | Filter: the canonical-form n-pole/m-zero filter class
csl::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)
csl::KarplusString | KarplusString – string model class
csl::Oscillator | Oscillator – Abstract oscillator class; inherits from UnitGenerator, Phased, and Scalable and provides convenience constructors (freq, ampl, offset, phase)
csl::FSine | FSine – (uses a ringing filter for the sine calc)
csl::Impulse | Impulse – oscillator class (this create a single impulse delayed by 'delay' samples)
csl::Sawtooth | Sawtooth oscillator class (non-band-limited)
csl::Sine | Sine – oscillator class (this computes the sine fcn on the fly)
csl::WaveShaper | WaveShaper – Wave-shaping oscillator class
csl::WaveShaper | WaveShaper – Wave-shaping oscillator class
csl::Square | Square oscillator class (non-band-limited)
csl::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?)
csl::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
csl::CASoundFile | CoreAudio sound file
csl::JSoundFile | JUCE sound file
csl::LSoundFile | Here's the sound file reader/writer class; it assumes libSndFile and interleaved sample buffers
csl::DecodedFile | DecodedFile - abstract class for MP3/4/AAC - read-only decoded files Provides a BufferVector for reading files of unknown size
csl::MP3File | MP3File - decodes MP3s into a buffer upon openForRead()
csl::CompOrCacheOscillator | CompOrCacheOscillator – Abstract oscillator class for those who can compute of cache their wavetables
csl::SineAsPhased | SineAsPhased – A sine oscillator that uses the Phased mix-in class, meaning that we inherit mFrequency and mPhase and macros for dynamic control
csl::SineAsScaled | SineAsScaled – A sine oscillator that also has scale and offset as dynamic controls (from Scalable) (Note the tripple inheritance)
csl::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)
csl::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
csl::ADSR | ADSR = 4-segment attack/decay/sustain/release envelope class
csl::AR | AR = 3-segment attack/release envelope class
csl::RandEnvelope | RandEnvelope envelope class – makes random control signals using a single line segment
csl::Triangle | Triangle envelope class – equal attack/release times
csl::Filter | Filter: the canonical-form n-pole/m-zero filter class
csl::Freeverb | CSL port of the public domain Freeverb reverberator
csl::KarplusString | KarplusString – string model class
csl::Mixer | Mixer – The n-input m-channel mixer class
csl::Noise | Abstract Noise class - inherits from UnitGenerator & Scalable, and provides constructors and basic pseudo-raondom methods
csl::PinkNoise | Pink noise – equal power per octave
csl::WhiteNoise | White noise – equal power per frequency
csl::Oscillator | Oscillator – Abstract oscillator class; inherits from UnitGenerator, Phased, and Scalable and provides convenience constructors (freq, ampl, offset, phase)
csl::Panner | The CSL mono-to-stereo L/R panner class
csl::RingBuffer | RingBuffer is the storage + a default reader
csl::RingBufferTap | RingBufferTap is a reader that loops over a buffer
csl::SineAsScaled | SineAsScaled – A sine oscillator that also has scale and offset as dynamic controls (from Scalable) (Note the tripple inheritance)
csl::SpatialSource | Temp Spatial Sound Source
csl::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
Controller |
controller_str |
csl::CPoint |
csl::CSL_MIDIMessage | CSL_MIDIMessage
csl::CSL_RS_MSG |
csl::CslRtpSession |
csl::RtpReceiver |
csl::RtpSender |
csl::CSLService |
csl::CThread | The abstract CSL Thread class
csl::ThreadPthread | PThread version of Thread
csl::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
csl::StdIO | StdIO reads/write the UNIX Standard IO pipes
csl::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
csl::DynamicVariable | Changing variable that can perform an operation (e.g., scaling) on another unit generator
csl::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)
csl::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
csl::AirAbsorptionCue | Simulates the frequency dependent air absorption using a one pole/zero lowpass filter
csl::IntensityAttenuationCue | Sound attenuation due to increasing distance. This "Base" Class uses the inverse square law. Subclass for other methods
csl::DLine |
end_test32 |
end_test64 |
csl::FAllpass | All-pass filter class
FFTReal |
csl::FilterSpecification | Forward declaration
csl::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
csl::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
csl::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)
csl::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
Inst_Context |
csl::Interleaver | Interleaver handles copying interleaved sample buffers (like sound files and inter-process sockets) to/from non-interleaved CSL-style Buffer objects
csl::IODevice | IO Device class – a holder for a sound interface with name, id, # IO channels, etc
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
math::matrix |
math::matrix_error |
csl::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")
csl::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
csl::AUIO | General-purpose AudioUnit IO class
csl::CAIO | CoreAudio IO class
csl::iPhoneIO | CoreAudio IO class for the iPhone
csl::AUIO | General-purpose AudioUnit IO class
csl::FileIO | FileIO.h – IO using a sound file for storing output sample data
csl::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
csl::JUCEIO | JUCEIO is an IO that runs as a JUCE
csl::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
csl::PAIO | The PortAudio IO class
csl::RemoteIO | RemoteIO class
csl::VSTIO | VSTIO is an IO that answers the VST processReplacing() call by calling its CSL graph
csl::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
csl::MIDIIn | MIDIIn class is-a MidiInputCallback too, and an "input-ready" flag
csl::MIDIIn | MIDIIn class is-a MidiInputCallback too, and an "input-ready" flag
csl::MIDIOut | MIDIOut class write msgs out to a device (or file)
csl::MIDIOut | MIDIOut class write msgs out to a device (or file)
csl::MIDIPlayer | MIDI stream/file player
csl::SpeakerLayout |
csl::HeadphoneSpeakerLayout | "Headphone Layout", where two phones are positioned 90¼ left, 90¼ right and no elevation (0¼)
csl::StereoSpeakerLayout | Standard "Stereo Speaker Layout", where two speakers are positioned 30¼ left, 30¼ right and no elevation (0¼)
csl::UnitGenerator | Forward declaration
csl::AmbisonicUnitGenerator | Ambisonic Abstract Base Class
csl::AmbisonicDecoder |
csl::AmbisonicEncoder |
csl::AmbisonicMixer |
csl::AmbisonicRotator |
csl::BlockResizer | Regularizes the amount of data called for. This is useful for time-frequency transformations that only work with certain buffer sizes
csl::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
csl::DelayLine |
csl::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
csl::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
csl::GrainPlayer | GrainPlayer – low-level granular synthesis generator, uses a list of current grains
csl::IFFT | Inverse FFT
csl::Instrument | Instrument class (abstract)
csl::AdditiveInstrument | AdditiveInstrument
csl::FMInstrument | FMInstrument
csl::FancyFMInstrument | FancyFMInstrument - FM with vibrato (with AR-envelope), attack chiff (filtered noise with AR-envelope), and random freq. drift and ampl. swell envelopes
csl::SndFileInstrument | Sound file player instrument
csl::SampleBankInstrument | Sample bank player instrument
csl::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);
csl::WhiteNoiseInstrument |
csl::KarplusString | KarplusString – string model class
csl::LineSegment | A linearly interpolated segment – this has start and end values, and a duration (in seconds)
csl::Lorenz | Lorenz chaotic oscillator = this plays one variable of the Lorenz Strange Attractor between +1 and -1
csl::Microphone | Microphone – copies the input buffer (from the sound driver) to its output
csl::Mixer | Mixer – The n-input m-channel mixer class
csl::Noise | Abstract Noise class - inherits from UnitGenerator & Scalable, and provides constructors and basic pseudo-raondom methods
csl::Oscillator | Oscillator – Abstract oscillator class; inherits from UnitGenerator, Phased, and Scalable and provides convenience constructors (freq, ampl, offset, phase)
csl::RemoteStream | RemoteStream class
csl::RingBufferTap | RingBufferTap is a reader that loops over a buffer
csl::RtpReceiver |
csl::SimpleSine | SimpleSine – The simplest CSL sine oscillator class
csl::SineAsPhased | SineAsPhased – A sine oscillator that uses the Phased mix-in class, meaning that we inherit mFrequency and mPhase and macros for dynamic control
csl::SineAsScaled | SineAsScaled – A sine oscillator that also has scale and offset as dynamic controls (from Scalable) (Note the tripple inheritance)
csl::SoundCue | SoundCue – a pointer to a segment of a sound file
csl::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
csl::Auralizer |
csl::SpatialPanner | Base class for all panners. Handles source management and holds a speaker layout
csl::AmbisonicPanner | Ambisonic Panner Wraps around the different ambisonic classes, providing a single interface for encoding, manipulating and decoding (i.e. panning) multiple UnitGenerators
csl::BinauralPanner | Forward declaration
csl::SimplePanner | Simple Panner
csl::SimplePanner | Simple Panner
csl::VBAP | Vector Base Amplitude Panning
csl::StereoPanner | Simple Stereo Panner
csl::SurroundPanner | Generic Panner for most surround formats. It accepts any number of speakers around the horizontal plane, and a subwoofer (.1 or not)
csl::SpatialSource | Temp Spatial Sound Source
csl::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)
csl::Window | Window; The superclass of all other window function classes in CSL. Subclasses need only to implement the fillWindow(); and the Constructors
csl::BlackmanHarrisWindow | BlackmanHarrisWindow
csl::BlackmanWindow | BlackmanWindow
csl::HammingWindow | HammingWindow: Belongs to the familly of cosine window functions
csl::HannWindow | HannWindow
csl::RectangularWindow | RectangularWindow:A rectangular window has all values set to the Gain value, or by default to 1
csl::TriangularWindow | TriangularWindow:A triangularWindow window
csl::WelchWindow | WelchWindow: This is basically an equal-power curve
csl::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
csl::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
csl::SpatialPanner | Base class for all panners. Handles source management and holds a speaker layout
Orbit |
csl::Partial | Struct for partial overtones
PME |
PMESource |
csl::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
queued_msg_list |
csl::Seekable | Seekable – a mix-in for positionable streams
csl::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
csl::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
csl::RingBufferTap | RingBufferTap is a reader that loops over a buffer
csl::SHARCInstrument | SHARC instrument class
csl::SHARCLibrary | SHARC library class
csl::SHARCSpectrum | SHARC spectrum class
csl::ShoeBox |
Socket |
CommunicatingSocket |
TCPSocket |
UDPSocket |
TCPServerSocket |
SocketException |
csl::SoundFileMetadata | Class SndFileMetadata holds the ID3 tags of a sound file
csl::Speaker | Represents a speaker as a position relative to the center of a space
csl::SpeakerLayoutExpert |
csl::SpeakerSet | Groups two or three loudspeakers, and their inverse. Used for VBAP computations
csl::SpeakerSetLayout |
csl::Synch | Sync is a cross-thread synchronization object
csl::SynchPthread | PThread version of Sync
csl::testStruct |
FFTReal::TrigoLUT |
csl::VBAPSourceCache |
vbuffer |
csl::Writeable | Writeable – a mix-in for buffers and streams that one can write to
csl::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
csl::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
csl::RingBuffer | RingBuffer is the storage + a default reader