Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
  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 |
