  _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 |
