Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

►Ncsl	AdditiveInstrument.h – Sum-of-sines synthesis instrument class
CAbst_FFT_W	Abstract FFT class can do forward/reverse real/complex I/O FFTs
CAbst_SoundFile	Here's the abstract sound file reader/writer class, a sample player UGen. The concrete subclasses represent sound file APIs, not individual formats
CAccessor	Has public data members
CAdditiveInstrument	AdditiveInstrument
CAddOp	AddOp – A BinaryOp that adds two UnitGenerators or fixed constants together
CADSR	ADSR = 4-segment attack/decay/sustain/release envelope class
CAirAbsorptionCue	Simulates the frequency dependent air absorption using a one pole/zero lowpass filter
CAllpass	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
CAmbisonicDecoder
CAmbisonicEncoder
CAmbisonicMixer
CAmbisonicOrder	Ambisonic order structure (separate definition for horizontal and vertical order):
CAmbisonicPanner	Ambisonic Panner Wraps around the different ambisonic classes, providing a single interface for encoding, manipulating and decoding (i.e. panning) multiple UnitGenerators
CAmbisonicRotator
CAmbisonicUnitGenerator	Ambisonic Abstract Base Class
CAR	AR = 3-segment attack/release envelope class
CAUIO	General-purpose AudioUnit IO class
CAuralizer
CBinaryOp	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
CBinauralPanner	Forward declaration
CBinauralSourceCache	BinauralSourceCache: used for caching previous state of spatial sources. This has the history of input FFTs and the last output sample block for OLA
CBiquad	General-purpose Biquad IIR (2nd order recursive) filter. This is simplified and optimized, but doesn't support dynamic or scalable controls. It uses inst vars rather than arrays for the coefficients. NB: peak gain (dB) is used only for the peak and shelf types)
CBlackmanHarrisWindow	BlackmanHarrisWindow
CBlackmanWindow	BlackmanWindow
CBlockResizer	Regularizes the amount of data called for. This is useful for time-frequency transformations that only work with certain buffer sizes
CBuffer	Buffer – the multi-channel sample buffer class (passed around between generators and IO guys)
CBufferCMap	BufferCMap is a Sample buffer with channel map and count
CBufferStream	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
CButter	Butterworth IIR (2nd order recursive) filter
CCacheable	Cacheable – a mix-in for caching streams
CCAIO	CoreAudio IO class
CCASoundFile	CoreAudio sound file
CCException	Base class of CSL exceptions (written upper-case). Has a string message
CCGestalt	The CSL system defaults class
CClipper	Clipper class
CCMIDIMessage	CMIDIMessage class (mapped to juce::MidiMessage)
CComb	Comb filter class
CCompOrCacheOscillator	CompOrCacheOscillator – Abstract oscillator class for those who can compute of cache their wavetables
CControllable	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
CConvolver	The Convolver is a CSL Effect
CConvolver2	The Convolver2 is a CSL Effect
CCPoint
CCSL_MIDIMessage	CSL_MIDIMessage
CCSL_RS_MSG
CCThread	The PThreads CSL Thread class
CCVariable	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
CDBError	DB Error
CDelayLine
CDistanceCue	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
CDistanceSimulator	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
CDLine
CDomainError	Numerical data of wrong type
CDynamicVariable	Changing variable that can perform an operation (e.g., scaling) on another unit generator
CEffect	Effect – mix-in for classes that have unit generators as inputs (like filters)
CEnvelope	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
CFAllpass	All-pass filter class
CFancyFMInstrument	FancyFMInstrument - FM with vibrato (with AR-envelope), attack chiff (filtered noise with AR-envelope), and random freq. drift and ampl. swell envelopes
CFanOut	A fan-out generator for DSP graphs with loops
CFFT	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
CFileIO	FileIO.h – IO using a sound file for storing output sample data
CFilter	Filter: the canonical-form n-pole/m-zero filter class
CFilterSpecification	Forward declaration
CFIR	Examples
CFMInstrument	FMInstrument
CFormant	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
CFreeverb	CSL port of the public domain Freeverb reverberator
CFrequencyAmount	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
CFSine	FSine – (uses a ringing filter for the sine calc)
CGrain	Grain data structure This implementation uses a linked list data structure. You might want to add a few more members to this for flexibility
CGrainCloud	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
CGrainPlayer	GrainPlayer – low-level granular synthesis generator, uses a list of current grains
CHammingWindow	HammingWindow: Belongs to the familly of cosine window functions
CHannWindow	HannWindow
CHeadphoneSpeakerLayout	"Headphone Layout", where two phones are positioned 90¼ left, 90¼ right and no elevation (0¼)
CHRTF	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)
CHRTFDatabase	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
CIFFT	Inverse FFT
CImpulse	Impulse – oscillator class (this create a single impulse delayed by 'delay' samples)
CInOut	InOut class copies the IO port's input buffer to the output buffer, possibly with channel remap and scaling
CInstrument	Instrument class (abstract)
CIntensityAttenuationCue	Sound attenuation due to increasing distance. This "Base" Class uses the inverse square law. Subclass for other methods
CInterleaver	Interleaver handles copying interleaved sample buffers (like sound files and inter-process sockets) to/from non-interleaved CSL-style Buffer objects
CIO	IO – the abstract I/O scheduling class; subclasses interface to specific I/O APIs
CIODevice	IO Device class – a holder for a sound interface with name, id, # IO channels, etc
CIOError	IO Error
CiPhoneIO	CoreAudio IO class for the iPhone
CJackIO	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
CJoiner	Joiner class – a multiplexer for multi-channel signals
CJSoundFile	JUCE sound file
CJUCEIO	JUCEIO is an IO that runs as a JUCE
CKarplusString	KarplusString – string model class
CLineSegment	A linearly interpolated segment – this has start and end values, and a duration (in seconds)
CLogicError	Impossible operation
CLorenz	Lorenz chaotic oscillator = this plays one variable of the Lorenz Strange Attractor between +1 and -1
CLSoundFile	Here's the sound file reader/writer class; it assumes libSndFile and interleaved sample buffers
CMemoryError	Malloc failure subclass
CMicrophone	Microphone – copies the input buffer (from the sound driver) to its output
CMIDIIn	MIDIIn class is-a MidiInputCallback too, and an "input-ready" flag
CMIDIIO	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
CMIDIOut	MIDIOut class write msgs out to a device (or file)
CMIDIPlayer	MIDI stream/file player
CMixer	Mixer – The n-input m-channel mixer class
CModel	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")
CMoog	Moog-style resonant VCF class
CMulOp	MulOp – A BinaryOp that multiplies two UnitGenerators or fixed constants together, sample-by-sample
CNoise	Abstract Noise class - inherits from UnitGenerator & Scalable, and provides constructors and basic pseudo-raondom methods
CNotch	Notch Filter with poles at +-z and complex conjugate zeros at +-omega
CNtoMPanner
CNullIO	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
CObserver	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
COscillator	Oscillator – Abstract oscillator class; inherits from UnitGenerator, Phased, and Scalable and provides convenience constructors (freq, ampl, offset, phase)
COutOfRangeError	Data out of range
CPAIO	The PortAudio IO class
CPanner	The CSL mono-to-stereo L/R panner class
CPartial	Struct for partial overtones
CPhased	Phased – a mix-in for objects with phase accumulators (local float) and frequency controls (an input port)
CPinkNoise	Pink noise – equal power per octave
CPort	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)
CProcessingError	Processing Error
CRandEnvelope	RandEnvelope envelope class – makes random control signals using a single line segment
CRectangularWindow	RectangularWindow:A rectangular window has all values set to the Gain value, or by default to 1
CRemoteIO	RemoteIO class
CRemoteStream	RemoteStream class
CRingBuffer	RingBuffer is the storage + a default reader
CRingBufferTap	RingBufferTap is a reader that loops over a buffer
CRunTimeError	Illegal operation at run time
CSampleBankInstrument	Sample bank player instrument
CSawtooth	Sawtooth oscillator class (non-band-limited)
CScalable	Scalable – mix-in class with scale and offset control inputs (may be constants or generators)
CSeekable	Seekable – a mix-in for positionable streams
CSHARCInstrument	SHARC instrument class
CSHARCLibrary	SHARC library class
CSHARCSpectrum	SHARC spectrum class
CShoeBox
CSimplePanner	Simple Panner
CSimpleSine	SimpleSine – The simplest CSL sine oscillator class
CSine	Sine – oscillator class (this computes the sine fcn on the fly)
CSineAsPhased	SineAsPhased – A sine oscillator that uses the Phased mix-in class, meaning that we inherit mFrequency and mPhase and macros for dynamic control
CSineAsScaled	SineAsScaled – A sine oscillator that also has scale and offset as dynamic controls (from Scalable) (Note the tripple inheritance)
CSndFileInstrument	Sound file player instrument
CSoundCue	SoundCue – a pointer to a segment of a sound file
CSoundFileMetadata	Class SndFileMetadata holds the ID3 tags of a sound file
CSpatializer	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
CSpatialPanner	Base class for all panners. Handles source management and holds a speaker layout
CSpatialSource	Temp Spatial Sound Source
CSpeaker	Represents a speaker as a position relative to the center of a space
CSpeakerLayout
CSpeakerLayoutExpert
CSpeakerSet	Groups two or three loudspeakers, and their inverse. Used for VBAP computations
CSpeakerSetLayout
CSplitter	Splitter class – a de-multiplexer for multi-channel signals
CSquare	Square oscillator class (non-band-limited)
CSquareBL	Band-limited square, impulse, and triangle waveform oscillators
CStaticVariable	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)
CStdIO	StdIO reads/write the UNIX Standard IO pipes
CStereoPanner	Simple Stereo Panner
CStereoSpeakerLayout	Standard "Stereo Speaker Layout", where two speakers are positioned 30¼ left, 30¼ right and no elevation (0¼)
CStereoverb
CStereoWidth	Stereo width processor – can mix stereo channels or subtract the sum from each to widen
CSumOfSines
CSurroundPanner	Generic Panner for most surround formats. It accepts any number of speakers around the horizontal plane, and a subwoofer (.1 or not)
CSynch	Sync is a cross-thread synchronization object
CSynchPthread	PThread version of Sync
CtestStruct	Struct used for the JUCE pop-up menu of tests (see the test files)
CThreadPthread	PThread version of Thread
CTimingError	Time-out
CTriangle	Triangle envelope class – equal attack/release times
CTriangularWindow	TriangularWindow:A triangularWindow window
CUnitGenerator	Forward declaration
CVAdditiveInstrument	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);
CValueError	Wrong kind of operand error
CVBAP	Vector Base Amplitude Panning
CVBAPSourceCache
CVSTIO	VSTIO is an IO that answers the VST processReplacing() call by calling its CSL graph
CWaveShaper	WaveShaper – Wave-shaping oscillator class
CWavetableOscillator	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?)
CWelchWindow	WelchWindow: This is basically an equal-power curve
CWhiteNoise	White noise – equal power per frequency
CWindow	Window; The superclass of all other window function classes in CSL. Subclasses need only to implement the fillWindow(); and the Constructors
CWriteable	Writeable – a mix-in for buffers and streams that one can write to
►Nmath
►Cmatrix
Cbase_mat
Cmatrix_error
CAudioSpectrumDisplay
CAudioWaveformDisplay
CCommunicatingSocket
CConnection
CController
Ccontroller_str
CCSLAbstComponent
CCSLComponent
CCSLMIDIComponent
CCSLServerComponent
CCSLSignalComponent
CCSLWindow
►CFFTReal
CBitReversedLUT
CTrigoLUT
CGThread	GThread takes a CSL test function and runs it
CInst_Context
CJUCECSLApplication
CLThread
COrbit
CPME
CPMESource
CSAFliter
CSocket
CSocketException
CTCPServerSocket
CTCPSocket
CUDPSocket
CVUMeter