| CLAM::AbstractAttribute | Defines the interface for an Attribute definition in a DescriptionScheme |
| CLAM::Add< DataType > | |
| CLAM::ADSR | |
| CLAM::ADSRConfig | |
| CLAM::Application | |
| CLAM::Array< T > | |
| CLAM::Attribute< AttributeType > | This class is the concrete implementation for AbstractAttribute for a given type of attributes |
| CLAM::AttributePool | A container for the values for a single attribute along the scope |
| CLAM::DynamicType::AttributePositionBase< NAttrib > | |
| CLAM::Audio | Audio class with the Data Buffer, information about it (SampleRate, BeginTime), and methods to insert and get Audio chunks |
| CLAM::AudioAmplifier | Time-domain audio gain |
| CLAM::AudioAmplifierConfig | AudioAmplifier configuration object |
| CLAM::AudioApplication | |
| CLAM::AudioBufferAmplifier | Time-domain audio gain |
| CLAM::AudioBufferMixer | |
| CLAM::AudioBufferSink | |
| CLAM::AudioBufferSource | |
| CLAM::AudioBuffPortMonitor | |
| CLAM::AudioDescriptors | |
| CLAM::AudioDevice | This is the abstract base class for an audio device |
| CLAM::AudioDeviceList | This abstract class allows you to retrieve a list of all available devices (strings) for a certain architecture |
| CLAM::AudioFile | |
| CLAM::AudioFileHeader | |
| CLAM::AudioFileMemoryLoader | |
| CLAM::AudioFileSource | |
| CLAM::AudioFileTarget | |
| CLAM::AudioIn | This class is the interface to an input of an AudioDevice |
| CLAM::AudioInFilename | |
| CLAM::AudioInPort | |
| CLAM::AudioInPortPublisher | |
| CLAM::AudioIOConfig | Configuration of the AudioIn and AudioOut classes |
| CLAM::AudioManager | This class takes care of all the creation of the registration of AudioIn and AudioOut objects, and the creation of AudioDevice objects required |
| CLAM::AudioMixer | |
| CLAM::AudioMixerConfig | |
| CLAM::AudioOut | This class is the interface to an output of an AudioDevice |
| CLAM::AudioOutFilename | |
| CLAM::AudioOutPort | |
| CLAM::AudioOutPortPublisher | |
| CLAM::AudioPlayer | |
| CLAM::AudioPortMonitor | |
| CLAM::AudioSink | |
| CLAM::AudioSource | |
| CLAM::AudioTextDescriptors | |
| CLAM::AudioWindowing | Processing class for performing a STFT |
| CLAM::AudioWindowingConfig | |
| CLAM::AutoPanner | |
| CLAM::AutoPannerConfig | |
| CLAM::BaseAudioApplication | |
| CLAM::BaseMemOp | Class used as base for all operators with memory, useful to define array of operators |
| CLAM::BasicCTypeInfo | C native types TypeInfo base class |
| CLAM::BasicFlowControl | |
| CLAM::BasicXMLable | Abstract class that defines some common implementation issues for many XMLables that contains as member variables the XML name and whether is an XML element or not |
| CLAM::BiasedPower< s, abs, T, U > | Binary Operator for use with std::accumulate, for computing Sum((x(i)-k)^n) |
| CLAM::BiasedPoweredSum< s, abs, T, U > | Class Function that computes Sum((x(i)-mean)^n) using std::accumulate and BiasedPower<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
| CLAM::BinaryAudioOp< BinOp > | |
| CLAM::BinaryAudioOpConfig | |
| CLAM::BinaryControlOp< BinOp > | |
| CLAM::BinaryControlOpConfig | |
| CLAM::BPFTmpl< TX, TY > | |
| CLAM::BufferedSDIFFileReader | BufferedSDIFFileReader is an SDIFFileReader that preloads some SDIF frames into an internal buffer so that real-time audio applications won't stall while waiting for disk reading operations |
| CALLBACK_INFO | |
| CLAM::CenterOfGravity< o, abs, T, U > | Class Function that computes 'oth' order Center of Gravity using WeightedPoweredSum Class Function |
| CLAM::CentralMoment< o, abs, T, U > | Class Function that computes 'oth' order CentralMoment using BiasedPoweredSum Class Function |
| CLAM::CentroidTmpl< abs, T, U > | Centroid is 1st order center of gravity |
| CLAM::CepstralTransform | This class performs the cepstral transform on a set of filterbank coefficients in order to obtain the corresponding Mel Frequency Cepstral Coefficients (MFCC) |
| CLAM::CepstralTransformConfig | |
| Simac::ChordCorrelator | Correlates PCP's with different ideal chord PCP's |
| Simac::ChordExtractor | |
| Simac::ChordCorrelator::ChordModePatterns | |
| Simac::ChordCorrelator::ChordPattern | |
| Simac::ChordSegmentator | ChordSegmentator divides the analysed audio data into segments characterized by different chords |
| MIDI::ChunkType | |
| Simac::CircularPeakPicking | This processing takes a vector of scalars magnitudes and returns a list of peaks found considering that the first and last bins are neighbors |
| Simac::CircularPeaksToPCP | This processing constructs a PCP doing the weighted histogram of the energy of a set of circular chromatic peaks |
| Simac::CircularPeakTunner | This processing takes an array of circular peaks with position at pitch units [0,12) and corrects them to be tunned given a tunning center and a reference tune |
| CLAM::CircularShift | This Processing class takes an input audio buffer and shifts it to get zero-phase conditions in the STFT |
| CLAM::CircularShiftConfig | |
| CLAM_FFT_IMPLEMENTATION | |
| CLAM::CleanTracks | |
| CLAM::CleanTracksConfig | Config class for the CleanTracks Processing |
| CLAM::AudioCodecs::Codec | A codec implements a file audio format support |
| SDIF::Collection | A special Storage to store Frames in a linked list |
| CLAM::Complex | |
| CLAM::ComplexMax< abs, T > | Binary Operator for use with std::accumulate, for computing Max(x(i)) |
| CLAM::ComplexMaxElement< abs, T > | Class Function that computes Max(x(i)) using std::accumulate and ComplexMax<T> BinaryOp It also has associated memory so operation is not performed more than necessary |
| CLAM::ComplexMin< abs, T > | Binary Operator for use with std::accumulate, for computing Min(x(i)) |
| CLAM::ComplexMinElement< abs, T > | Class Function that computes Min(x(i)) using std::accumulate and ComplexMin<T> BinaryOp It also has associated memory so operation is not performed more than necessary |
| CLAM::ComplexToPolarCnv | |
| CLAM::Component | Abstract class for objects that can have subitems to be stored on a storage |
| CLAM::FactoryRegistrator< TheFactoryType, ConcreteProductType >::ConcreteCreator | |
| SDIF::ConcreteMatrix< T > | |
| CLAM::Condition | |
| CLAM::RecursiveMutex::ConditionVar | |
| CLAM::ConfigurationGetter< Configuration, Builder > | A DynamicType attribute visitor that builds a widget for each attribute using a user interface builder |
| CLAM::ConfigurationSetter< Configuration, Builder > | A DynamicType attribute visitor that takes the attribute values from an a 'Builder' which implements the RetrieveValue |
| CLAM::ConfigurationVisitor | |
| SigSlot::Connection | Class that model connections between signals and slots |
| CLAM::ConnectionDefinitionAdapter | |
| SigSlot::ConnectionHandler< SignalType > | Handler for a given Signal connections |
| Simac::ConstantQFolder | The ConstantQFolder takes a ConstantQ transform and folds its bins into a single Octave to create a Chromagram |
| Simac::ConstantQTransform | ConstantQTransform extract a ConstantQ spectrum using Blankertz's paper algorithm |
| CLAM::ContainerTypeInfo | |
| CLAM::ContiguousSegmentation | |
| CLAM::Control2Data | This processing object is mainly an aggregate of input control data It works by asynchronously receiving messages, keeping them enqueued and synchronously converting them to a Processing Data, at Do() time |
| CLAM::Control2DataConfig | Configuration for the Control2Data PO |
| CLAM::ControlArray< ControlT > | This class wrapps a vector (array) of Controls and gives its Controls automatic names at construction |
| CLAM::ControlComparison | |
| CLAM::ControlComparisonConfig | |
| CLAM::ControlConfig | |
| CLAM::ControlFade | |
| CLAM::ControlFadeConfig | |
| CLAM::ControlIntervalMapper | |
| CLAM::ControlIntervalMapperConfig | |
| CLAM::Controller | This processing object is mainly an aggregate of out controls, that can be connected with other POs in controls, as usual |
| CLAM::ControllerConfig | Configuration for the Controller PO |
| CLAM::ControlMapper | |
| CLAM::ControlMapperConfig | |
| CLAM::ControlPiano | |
| CLAM::ControlPrinter | |
| CLAM::ControlPrinterConfig | |
| CLAM::ControlPrinterTyped | |
| CLAM::ControlPrinterTypedConfig | |
| CLAM::ControlScaler | |
| CLAM::ControlScalerConfig | |
| CLAM::ControlSelector | |
| CLAM::ControlSelectorConfig | |
| CLAM::ControlSink | |
| CLAM::ControlSinkConfig | |
| CLAM::ControlSource | |
| CLAM::ControlSourceConfig | |
| CLAM::ControlSum | |
| CLAM::ControlSumConfig | |
| CLAM::ControlTraceData | |
| CLAM::ControlTraceEvent | |
| CLAM::ControlTraceInFilename | |
| CLAM::ControlTraceOutFilename | |
| CLAM::ControlTraceReader | |
| CLAM::ControlTraceReaderConfig | |
| CLAM::ControlTraceWriter | |
| CLAM::ControlTraceWriterConfig | |
| Creator | |
| CLAM::Factory< AbstractProductType >::Creator | Abstract class for Creator objects which are stored in the Factory::Registry |
| CLAM::CrossCenterOfGravity< o, abs, T, U > | Special CenterOfGravity using 2ond sequence as indexing sequence |
| CLAM::CrossWeightedPoweredSum< s, abs, T > | Class Function that computes Sum(x(i)^n * y(i)) using std::accumulate and WeightedPower<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
| CLAM::CubedSumTmpl< abs, T > | Class Function that computes Sum(x(i)^3) using std::accumulate and Cube<T> BinaryOp |
| CLAM::CubeTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^3) |
| SDIF::DataFrameHeader | An extension of FrameHeader, that is used for data frames |
| CLAM::DataUtil | This class simply holds a few miscellaneous utility methods that are used by multiple classes, but don't fit very well in any class |
| CLAM::Deesser | |
| CLAM::DefaultTypeInfo | |
| CLAM::DescriptionDataPool | Contains the extracted data for a given description process |
| CLAM::DescriptionScheme | The description scheme defines the set of attributes (Attribute) to be used for feature extraction systems |
| CLAM::DescriptionScope | |
| CLAM::DescriptorComputation | This Processing class only calls the Compute operation of Descriptor passed to the Do |
| CLAM::DescriptorComputationConfig | |
| CLAM::DescriptorTmpl< abs > | Abstract class for all descriptors |
| CLAM::DirectoryName | This class is a base class for configuration fields representing file names |
| CLAM::DiscontinuousSegmentation | |
| CLAM::Dispatcher | |
| CLAM::DispatcherConfig | |
| CLAM::DomDocumentHandler | This class subclasses from the proper DomDocumentHandler depending on the build time configuration 'xmlbackend' option |
| CLAM::DynamicType | This class implements a type that is dynamic |
| CLAM::EAudioFileCodec | |
| CLAM::EAudioFileEncoding | |
| CLAM::EAudioFileEndianess | |
| CLAM::EAudioFileFormat | |
| CLAM::OutControlSenderConfig::EControlRepresentation | |
| CLAM::EFDFilterGenControls | |
| CLAM::EFDFilterType | Simple filter types, more to be added |
| CLAM::EInterpolation | Interpolation Enumeration to use for specifying the type of interpolation used |
| CLAM::ELoopPointUnits | PhaseGeneration Enumeration to use for specifying the type of phase generation used |
| CLAM::OutControlSenderConfig::EMapping | |
| CLAM::EnergyTmpl< T > | Energy is just the squared sum |
| CLAM::Enum | Instances of this class represents objects that can adquire a symbolic value from a limited set of symbolic values |
| CLAM::EnumTypedTypes | |
| CLAM::Envelope | Envelope class |
| CLAM::EnvelopeConfig | Configuration class for Envelope data objects |
| CLAM::EnvelopeDescriptors | |
| CLAM::EnvelopeExtractor | |
| CLAM::EnvelopeGenerator | |
| CLAM::EnvelopeGeneratorConfig | |
| CLAM::EnvelopeModulator | |
| CLAM::EnvExtractorConfig | |
| CLAM::EnvModulatorConfig | |
| CLAM::EOscillatorControls | |
| CLAM::EPhaseGeneration | PhaseGeneration Enumeration to use for specifying the type of phase generation used |
| CLAM::EPitch | |
| CLAM::ERB_SpaceGen | |
| CLAM::ERB_SpaceGenConfig | |
| CLAM::Err | Base class for the exception handling classes |
| CLAM::ErrAssertionFailed | The exception thrown when an assertion fails |
| CLAM::ErrDynamicType | Derived class of the Err base class Handles DynamicType errors |
| CLAM::ErrFactory | Error type thrown by Factory classes (Factory, FactoryRegistry) |
| CLAM::ErrFormat | Derived class of the Err base class Handles format errors |
| CLAM::ErrNotFound | |
| CLAM::ErrOpenFile | Derived class of the Err base class Handles errors in files openings |
| MIDI::Reader::Error | |
| CLAM::ErrOutOfMemory | Derived class of the Err base class Handles memories errors |
| CLAM::ErrProcessingObj | Derived class of the Err base class Handles errors in Processing Object Routines |
| CLAM::ErrSoundFileIO | |
| CLAM::EScale | Interpolation Enumeration to use for specifying the type of scale used (linear or log) |
| MIDI::Event | |
| CLAM::EWaveType | |
| CLAM::WaveGenerator::EWaveType_eSine | |
| CLAM::EWindowNormalize | |
| CLAM::EWindowType | |
| CLAM::Factory< AbstractProductType > | Factory usage example |
| CLAM::FactoryRegistrator< TheFactoryType, ConcreteProductType > | This class provides a convenient way to add items (creators) into a factory |
| CLAM::FDCombFilter | Basic Frequency domain Comb Filter |
| CLAM::FDFilterGen | Frequency Domain Filter Generator |
| CLAM::FDFilterGenConfig | Configuration class for SpectralFilterGen class |
| CLAM::FFT | |
| CLAM::FFT_base | Abstract base class for FFT classes |
| CLAM::FFT_fftw3 | Implementation of the FFT using the Fastest Fourier Transform of the West version 3 |
| CLAM::FFT_numrec | Implementation of the FFT using the algorithm in Numerical Recipies in C |
| CLAM::FFT_ooura | Implementation of the FFT using the algorithm from Takuya OOURA in C |
| CLAM::FFTConfig | Configuration class for FFT classes |
| SDIF::File | |
| CLAM::Filename | This class is a base class for configuration fields representing file names |
| CLAM::FileSystem | |
| CLAM::Filename::Filter | Item of a Filename filter definition |
| CLAM::FlagControl | |
| CLAM::FlagControlConfig | |
| CLAM::Flags< N > | Instances of this class represents objects containing a set of booleans values (flags) that can be accessed by their symbolic name |
| CLAM::FlagsBase | Abstract class from which any Flag<N> instantiation is derived |
| CLAM::FlowControl | |
| FourierTransform | |
| SDIF::Frame | SDIF data is stored in frames, that contain number of matrices |
| CLAM::Frame | Processing Data class to encapsulate a frame and all its related information |
| CLAM::FrameAdder | This class performs the interpolation of two Frame processing data objects |
| CLAM::FrameAdderConfig | |
| CLAM::FrameDescriptors | |
| SDIF::FrameHeader | Base header for all frames |
| CLAM::FrameInterpConfig | |
| CLAM::FrameInterpolator | This class performs the interpolation of two Frame processing data objects |
| CLAM::FrameTransformation | |
| CLAM::FrameTransformationConfig | |
| CLAM::FrameTransformationTmpl< T > | |
| CLAM::FreqShift | |
| CLAM::Fund2MIDI | Converts fundamental to a MIDI note value |
| CLAM::Fundamental | Class Fundamental, used to manage the bins candidates to be fundamental frequencies, and their errors |
| CLAM::Fundamental2Control | |
| CLAM::Fundamental2ControlConfig | |
| CLAM::FundamentalPortMonitor | |
| CLAM::FundFreqDetect | This class estimates a fundamental frequency value in the spectral domain for one single spectral Frame |
| CLAM::FundFreqDetectConfig | Config class for FundFreqDetect Processing |
| CLAM::FundTrackPortMonitor | |
| CLAM::GeometricMeanTmpl< T, U > | Class Function that computes Geometric Mean using InnerProduct class function |
| CLAM::Network::Geometry | |
| SDIF::GetType< T > | |
| SDIF::GetType< CLAM::TByte > | |
| SDIF::GetType< CLAM::TFloat32 > | |
| SDIF::GetType< CLAM::TFloat64 > | |
| SDIF::GetType< CLAM::TInt32 > | |
| SDIF::GetType< CLAM::TInt64 > | |
| SDIF::GetType< TUTF8byte > | |
| CLAM::GreaterThan< x, y > | |
| HandlerBase | |
| CLAM::Hook< AttributeType > | |
| CLAM::HumRemover | |
| CLAM::IFFT | |
| CLAM::IFFT_base | Abstract base class for IFFT classes |
| CLAM::IFFT_fftw3 | Implementation of the IFFT using the Fastest Fourier in the West version 3 |
| CLAM::IFFT_ooura | Implementation of the IFFT using the algorithm from Takuya OOURA in C |
| CLAM::IFFTConfig | Config class for the IFFT Processing |
| CLAM::IllegalValue | |
| CLAM::InControl< ControlDataType > | An InControl receives values of the template type in an asyncronous pace |
| CLAM::InControlBase | Base class for an inwards control connector |
| CLAM::InControlPublisher | |
| CLAM::InControlRegistry | |
| CLAM::IndexArray | |
| CLAM::InFilename | Input file name configuration field |
| CLAM::InformationText | |
| CLAM::InformationTextAdapter | |
| CLAM::InnerProductTmpl< T > | Class Function for computing product of all data in vector |
| CLAM::InPort< Token > | |
| CLAM::InPortBase | |
| CLAM::InPortPublisher< Token > | |
| CLAM::InPortRegistry | |
| CLAM::InSDIFFilename | |
| CLAM::ContiguousSegmentation::InsertedOutOfBounds | |
| CLAM::DiscontinuousSegmentation::InsertedOutOfBounds | |
| CLAM::Segmentation::InsertedOutOfBounds | |
| CLAM::UnsizedSegmentation::InsertedOutOfBounds | |
| Simac::InstantTunningEstimator | This processing estimates the most probable tunning of a set of chromatic peaks |
| CLAM::Instrument | |
| CLAM::IntervalAmplitudeAverages | Internal class |
| CLAM::JACKNetworkPlayer | |
| CLAM::KurtosisTmpl< abs, T, U > | Class Function that computes Kurtosis Excess using Variance and 4th order central moment |
| CLAM::LadspaLibrary | A LadspaLibrary represents a pool of ladspa plugins descriptors |
| CLAM::LadspaNetworkExporter | |
| CLAM::LadspaProcessingExporter< ProcessingType > | |
| CLAM::LadspaWrapper | |
| CLAM::LadspaWrapperBuffer | |
| CLAM::LadspaWrapperBufferCreator | |
| CLAM::LadspaWrapperCreator | |
| CLAM::LibXmlDomDocumentHandler | XML implementation backend for the libxml++ library |
| CLAM::LibXmlDomReader | Controls the libxml++ DOM parser |
| CLAM::LibXmlDomReadingContext | Keeps the booking when loading one LibXml DOM single element into CLAM data |
| CLAM::LibXmlDomWriter | Controls the libxml++ DOM serializer |
| CLAM::LibXmlDomWritingContext | Keeps the booking when mapping CLAM data into a single libxml++ DOM element |
| CLAM::LinearMapping | |
| CLAM::LinearMappingFactory | |
| CLAM::List< T > | |
| CLAM::LockError | |
| CLAM::Hidden::LockOps< MutexType > | |
| CLAM::LogPlusTmpl< T > | Binary Operator for use with std::accumulate, for computing Product(x(i)) |
| CLAM::LogSumTmpl< T > | Class Function for computing logarithmic sum of all data in vector using |
| CLAM::LoopingSDIFFileReader | This class extends the length of an SDIFFile indefinitely by looping between its frames |
| CLAM::LPC_AutoCorrelation | |
| CLAM::LPCConfig | |
| CLAM::LPModel | |
| CLAM::Mapping | |
| CLAM::MappingFactory | |
| SDIF::Matrix | Contains frame data for an SDIF frame |
| SDIF::MatrixHeader | The header for each Matrix |
| CLAM::MatrixTmpl< T > | |
| CLAM::MeanTmpl< abs, T, U > | Mean is 1st order Moment |
| CLAM::MediaTime | Media Time type definition * This type propose a flexible way of defining * the temporal location of an audio segment * Types: {begin, end}, {begin, duration} * This type is thought to be used to define * some kind of probability when defining segment* boundaries * |
| CLAM::MelCepstrum | |
| CLAM::MelFilterBank | This class performs filterbank analysis for Mel Frequency Cepstrum Coefficients (MFCC) computation |
| CLAM::MelFilterBankConfig | |
| CLAM::Melody | Class Melody, used to store the melodic description of an AudioSegment @see SegmentDescriptors @see FFHDescriptors @see DistributionDescriptors @see Key |
| CLAM::MelSpectrum | |
| MIDI::Message | |
| CLAM::MIDI::MessageInfo | |
| MIDI::MetaEvent | |
| CLAM::MIDI | |
| CLAM::MIDI2Melody | This processing is a particular control-to-data converter that takes in MIDI control events and converts them into a MIDIMelody processing data |
| CLAM::MIDIClocker | This class is the interface to an input of an MIDIDevice |
| CLAM::MIDIClockerConfig | Configuration of the MIDIClocker class |
| CLAM::MIDIDevice | This is the abstract base class for an midi device |
| CLAM::MIDIDeviceList | This abstract class allows you to retrieve a list of all available devices (strings) for a certain architecture |
| CLAM::MIDIDispatcher | |
| CLAM::MIDIDispatcherConfig | |
| CLAM::MIDIEvent | |
| CLAM::MIDIFileIOConfig | |
| CLAM::MIDIFileReader | |
| CLAM::MIDIFileWriter | |
| CLAM::MIDIIn | This class is the interface to an input of an MIDIDevice |
| CLAM::MIDIInControl | |
| CLAM::MIDIIOConfig | Configuration of the MIDIIn and MIDIOut classes |
| CLAM::MIDIKeyboard | |
| CLAM::MIDIKeyboardConfig | |
| CLAM::MIDIManager | This class takes care of all the creation of the registration of MIDIIn and MIDIOut objects, and the creation of MIDIDevice objects required |
| CLAM::MIDIMelody | Class Melody, used to store the melodic description of a MIDI stream/file @see SegmentDescriptors |
| CLAM::MIDINote | Used to store note information coming from a MIDI stream/file |
| CLAM::MIDIOut | This class is the interface to an input of an MIDIDevice |
| CLAM::MIDIOutControl | |
| CLAM::MIDISong | |
| CLAM::MIDITrack | |
| CLAM::DiscontinuousSegmentation::MissplacedOffset | |
| CLAM::DiscontinuousSegmentation::MissplacedOnset | |
| CLAM::Moment< o, abs, T, U > | Class Function that computes 'oth' order Moment using PoweredSum Class Function |
| CLAM::MonoAudioFileReader | |
| CLAM::MonoAudioFileReaderConfig | Configuration class for the CLAM::MonoAudioFileReader processing object |
| CLAM::MonoAudioFileWriter | |
| CLAM::MonoAudioFileWriterConfig | Configuration class for the CLAM::MonoAudioFileWriter processing object |
| CLAM::MonoOfflineNetworkPlayer | |
| CLAM::MorphologicalFrameDescriptors | |
| CLAM::MorphologicalSegmentDescriptors | |
| CLAM::AudioCodecs::MpegAudioStream | |
| CLAM::AudioCodecs::MpegBitstream | |
| CLAM::AudioCodecs::MpegCodec | |
| CLAM::MultiChannelAudioFileReader | |
| CLAM::MultiChannelAudioFileReaderConfig | |
| CLAM::MultiChannelAudioFileWriter | |
| CLAM::MultiChannelAudioFileWriterConfig | Configuration class for the CLAM::MultiChannelAudioFileWriter processing object |
| CLAM::Multiply< DataType > | |
| CLAM::Mutex | From the www.boost.org docs: A mutex (short for mutual-exclusion) object is used to serializes access to a resource shared between multiple threads |
| CLAM::NaiveFlowControl | |
| CLAM::Network | |
| CLAM::NetworkPlayer | A NetworkPlayer is an object that controls the playback of a Network providing a high level transport like interface |
| CLAM::NoPowerTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^1) |
| CLAM::Normalization | |
| CLAM::NormalizationConfig | Normalization is a CLAM implementation of 3 normalization's algorithms |
| CLAM::NoSpectralTransformation | |
| CLAM::Note | Used to store note information |
| CLAM::NoteToFreqMapping | |
| CLAM::NoteToFreqMappingFactory | |
| CLAM::NullDomDocumentHandler | Dummy implementation of a DomDocumentHandler when XML is disabled |
| CLAM::NullDomReadingContext | Dummy implementation of a DomDocumentReadingContext when XML is disabled |
| CLAM::NullDomWritingContext | Dummy implementation of a DomDocumentWritingContext when XML is disabled |
| CLAM::NullProcessingConfig | |
| CLAM::O< order > | Auxiliary class to define the order of a moment at compile time |
| CLAM::OfflineNetworkPlayer | |
| CLAM::DiscontinuousSegmentation::OffsetMissing | |
| CLAM::AudioCodecs::OggVorbisAudioStream | |
| CLAM::AudioCodecs::OggVorbisCodec | Codec inplementation for the Ogg Vorbis audio file format |
| SDIF::OpeningsFrame | A special kind of frame at the beginning of each SDIF file |
| OriginalFunction | |
| CLAM::OscillatingSpectralNotch | |
| CLAM::Oscillator | |
| CLAM::OscillatorConfig | |
| CLAM::OutControl< ControlDataType > | Processing typed out control template class |
| CLAM::OutControlBase | Base class for an outwards control connector |
| CLAM::OutControlPublisher | |
| CLAM::OutControlRegistry | |
| CLAM::OutControlSender | |
| CLAM::OutControlSenderConfig | |
| CLAM::OutFilename | Output file name configuration field |
| CLAM::OutPort< Token > | |
| CLAM::OutPortBase | |
| CLAM::OutPortPublisher< Token > | |
| CLAM::OutPortRegistry | |
| CLAM::OverlapAdd | Configuration class for Overlapp Add Processing |
| CLAM::OverlapAddConfig | Config class for the OverlapAdd Processing |
| CLAM::PANetworkPlayer | |
| CLAM::Partializer | |
| CLAM::AudioCodecs::PCMAudioStream | |
| CLAM::AudioCodecs::PCMCodec | |
| Simac::PCPSmother | |
| CLAM::Peakalizer | |
| CLAM::PeaksAdConfig | |
| CLAM::PeaksInterpConfig | |
| CLAM::PeaksPortMonitor | |
| CLAM::PeriodogramPeak | |
| CLAM::PhantomBuffer< T > | |
| CLAM::PhaseManagement | The PhaseManagement Class takes care about either |
| CLAM::PhaseManagementConfig | Config class for the PhaseManagement Processing |
| CLAM::PitchNote | Pitch note type definition = pitch + octave |
| CLAM::PointTmpl< TX, TY > | |
| CLAM::Polar | |
| CLAM::Polymorphic< FactoryType > | This class is an utility class to hold polymorphic pointers as attributes on DynamicTypes and simplify the problem of the XML Loading of abstract XML Schema types |
| CLAM::PooledThread | |
| CLAM::AudioSource::Port | |
| CLAM::AudioBufferSink::Port | |
| CLAM::AudioBufferSource::Port | |
| CLAM::AudioSink::Port | |
| CLAM::PortMonitor< TheDataType, ThePortType > | A processing that allows other (GUI) thread to monitor a port in a thread safe way |
| CLAM::Pow< o > | |
| CLAM::Pow< 0 > | |
| CLAM::Pow< 1 > | |
| CLAM::Power< s, abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^n) |
| CLAM::PoweredProduct< s, T > | Binary Operator for use with std::inner_product |
| CLAM::PoweredSum< s, abs, T > | Class Function that computes Sum(x(i)^n) using std::accumulate and Power<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
| CLAM::Processing | The base class for all the CLAM processing object classes |
| CLAM::Hidden::ProcessingClass2LadspaBase | |
| CLAM::ProcessingComposite | Abstract class for processing object agregates |
| CLAM::ProcessingConfig | This is an abstract class which serves as interface for configuration classes used as processing object construction arguments, which must derive from it |
| CLAM::ProcessingData | Interface classe for every concrete processing data (data that flows through the processing objs |
| CLAM::ProcessingDataConfig | Base class of ProcessingData settings, all the configurations of ProcessingData objects will be derived of this |
| CLAM::ProcessingDataPlugin | |
| CLAM::ProcessingDefinitionAdapter | |
| CLAM::ProcessingFactory | |
| CLAM::ProcessingKernel | |
| CLAM::ProductTmpl< T > | Binary Operator for use with std::accumulate, for computing Product(x(i)) |
| CLAM::PushFlowControl | |
| CLAM::RandomPhase | |
| CLAM::RangeView | |
| MIDI::Reader | |
| CLAM::ReadHook< AttributeType > | |
| CLAM::ReadingRegion< WritingRegion > | |
| CLAM::ReadRangedHook< AttributeType > | |
| CLAM::RecursiveMutex | |
| CLAM::RecursiveTimedMutex | |
| CLAM::RecursiveTryMutex | |
| CLAM::Region | |
| CLAM::ProcessingDataPlugin::Registrator< DataType > | |
| CLAM::Factory< AbstractProductType >::Registry | This class is an implementation class of the Factory |
| CLAM::RMSTmpl< T, U > | RMS is the square root of the Energy |
| CLAM::Robotization | |
| CLAM::RtAAudioDevice | |
| CLAM::RtAAudioDeviceList | |
| RtAudio | Realtime audio i/o C++ class |
| RtAudio::RTAUDIO_DEVICE | The public device information structure for passing queried values |
| RtError | Exception handling class for RtAudio |
| CLAM::RulerTicks | |
| RunTimeFaustLibraryLoader | |
| RunTimeLadspaLibraryLoader | |
| RunTimeLibraryLoader | |
| CLAM::SampleAndHold | |
| CLAM::SampleMetadata | This class should be used to hold meta information about a sound sample |
| CLAM::SchemaError | A description scope defines a set of attributes which have the same ocurrences |
| CLAM::Hidden::ScopedLock< MutexType > | |
| CLAM::Hidden::ScopedTimedLock< TimedMutexType > | |
| CLAM::Hidden::ScopedTryLock< TryMutexType > | |
| CLAM::ScopePool | A container for the attributes values along the differents contexts of a single scope |
| CLAM::SDIFFileReader | |
| CLAM::SDIFIn | |
| CLAM::SDIFInConfig | |
| CLAM::SDIFInStreaming | |
| CLAM::SDIFOut | |
| CLAM::SDIFOutConfig | |
| CLAM::Search< U, T > | |
| CLAM::SearchArray< T > | |
| CLAM::Segment | Processing Data class to encapsulate a CLAM segment |
| CLAM::Segmentation | |
| CLAM::Segmentator | |
| CLAM::SegmentatorConfig | Config class for the Segmentator Processing |
| CLAM::SegmentDescriptors | |
| CLAM::SegmentSMSHarmonizer | |
| CLAM::SegmentSMSMorph | |
| CLAM::SegmentSMSMorphConfig | |
| CLAM::SegmentSMSTimeStretch | |
| CLAM::SegmentSMSTimeStretchConfig | |
| CLAM::SegmentTransformation | |
| CLAM::SegmentTransformationConfig | Configuration class for all SegmentTransformations |
| Simac::SemitoneCenterFinder | |
| CLAM::SGuide | Config class for the SinTracking Processing |
| SigSlot::Signal | Abstract 'Event Dispatcher' |
| SigSlot::Signalv0 | |
| SigSlot::Signalv1< ParmType1 > | |
| SigSlot::Signalv2< ParmType1, ParmType2 > | |
| SigSlot::Signalv3< ParmType1, ParmType2, ParmType3 > | |
| SigSlot::Signalv4< ParmType1, ParmType2, ParmType3, ParmType4 > | |
| CLAM::SimpleLoopMetadata | This object represents the start and end points of a loop |
| CLAM::SimpleOscillator | |
| CLAM::SimpleOscillatorConfig | |
| CLAM::SinTracking | Processing which does sinusoidal peak tracking (or continuation) |
| CLAM::SinTrackingConfig | Config class for the SinTracking Processing |
| CLAM::SinTracksPortMonitor | |
| CLAM::SinusoidalSynthesis | This is a processing object class that performs a sinusoidal resynthesis given a set of spectral peaks |
| CLAM::SkewTmpl< abs, T, U > | Class Function that computes Skewness using Standard Deviation and 3rd order central moment |
| SigSlot::Slot | The receiver of a Signal |
| SigSlot::Slotv0 | |
| SigSlot::Slotv1< ParmType1 > | |
| SigSlot::Slotv2< ParmType1, ParmType2 > | |
| SigSlot::Slotv3< ParmType1, ParmType2, ParmType3 > | |
| SigSlot::Slotv4< ParmType1, ParmType2, ParmType3, ParmType4 > | |
| CLAM::SMSAnalysis | Class that encapsulates all the building blocks of the SegmentAnalysis example |
| CLAM::SMSAnalysisConfig | |
| CLAM::SMSAnalysisCore | Class that encapsulates all the building blocks of the SegmentAnalysis example |
| CLAM::SMSDeesser | |
| CLAM::SMSFreqShift | |
| CLAM::SMSGenderChange | |
| CLAM::SMSHarmonizer | Many voices harmonizer using the SMS model |
| CLAM::SMSHarmonizerConfig | The Harmonizer configuration object |
| CLAM::SMSMorph | Morph using the SMS model |
| CLAM::SMSMorphConfig | |
| CLAM::SMSOddEvenHarmonicRatio | |
| CLAM::SMSPitchDiscretization | |
| CLAM::SMSPitchShift | Pitch shift with timbre preservation using the SMS model |
| CLAM::SMSResidualGain | |
| CLAM::SMSSineFilter | |
| CLAM::SMSSinusoidalGain | |
| CLAM::SMSSpectralShapeShift | Pitch shift with timbre preservation using the SMS model |
| CLAM::SMSSynthesis | This is the processing object class we are using to group several other processing objects |
| CLAM::SMSSynthesisConfig | |
| CLAM::SMSTimeStretch | Time Stretch using the SMS model |
| CLAM::SMSTimeStretchConfig | |
| CLAM::SMSTransformationChain | Using Segment as the type for * input and output ports |
| CLAM::SMSTransformationChainConfig | Configuration for a SMSTransformationChain |
| CLAM::SMSTransformationChaineeConfig | Special Processing config that can be used inside a SMSTransformationChainConfig |
| CLAM::SMSTransformationChainIO | Pitch shift with timbre preservation using the SMS model |
| CLAM::SMSTranspose | |
| SndPcm | |
| SndPcmError | |
| MIDI::Song | |
| MIDI::SongPlayer | |
| CLAM::SpecAdder2Config | |
| CLAM::SpecAdderConfig | |
| CLAM::SpecgramPortMonitor | |
| CLAM::SpecInterpConfig | |
| CLAM::SpecSubstracter2Config | |
| CLAM::SpectralAmplitudeModulation | |
| CLAM::SpectralAnalysis | Processing class for performing a STFT |
| CLAM::SpectralAnalysisConfig | Configuration class for Spectral Analysis class It includes specific parameters: HopSize, ZeroPadding, Sampling Rate and FFTSize |
| CLAM::SpectralAverage | |
| CLAM::SpectralCombDelta | |
| CLAM::SpectralCombTriang | |
| CLAM::SpectralDelay | |
| CLAM::SpectralDescriptors | |
| CLAM::SpectralEnvelopeApply | Applies an existing spectral envelope to incoming spectral peaks or spectrum |
| CLAM::SpectralEnvelopeApplyConfig | Configuration class for SpectralEnvelopeApply objects |
| CLAM::SpectralEnvelopeExtract | Configuration class for SpectralEnvelopeExtract objects |
| CLAM::SpectralEnvelopeExtractConfig | Config class for the SpectralEnvelopeExtract Processing |
| CLAM::SpectralExciter | |
| CLAM::SpectralFocus | Pitch shift with timbre preservation using the SMS model |
| CLAM::SpectralGate | |
| CLAM::SpectralLimiter | |
| CLAM::SpectralNotch | |
| CLAM::SpectralPeak | Class SpectralPeak is a basic spectral domain Processing Data class |
| CLAM::SpectralPeakArray | This processing data class offers an interface for storing an array of spectral peaks while maintaining efficient data access |
| CLAM::SpectralPeakArrayAdder | This class performs the interpolation of two SpectralPeakArray processing data objects |
| CLAM::SpectralPeakArrayInterpolator | This class performs the interpolation of two SpectralPeakArray processing data objects |
| CLAM::SpectralPeakDescriptors | |
| CLAM::SpectralPeakDetect | This class is dedicated to find magnitude SpectralPeaks in a given spectral frame |
| CLAM::SpectralPeakDetectConfig | Configuration class for SpectralPeakDetect objects |
| CLAM::SpectralPhaseModulation | |
| CLAM::SpectralReject | |
| CLAM::SpectralReverse | |
| CLAM::SpectralRingModulation | |
| CLAM::SpectralShapeShift | Pitch shift with timbre preservation using the SMS model |
| CLAM::SpectralSpread | Pitch shift with timbre preservation using the SMS model |
| CLAM::SpectralSynthesis | This is the processing object class we are using to group several other processing objects |
| CLAM::SpectralSynthesisConfig | Config class for the SpectralSynthesis Processing |
| CLAM::Spectrum | Spectrum is a ProcessingData class that allows the following representations: Mag/Phase, Complex, Polar and Break Point Function (BPF) |
| CLAM::SpectrumAdder | This class performs the sum of N Spectrum processing data objects |
| CLAM::SpectrumAdder2 | This calss performs the sum of two Spectrum processing data objects |
| CLAM::SpectrumConfig | The Spectrum configuration object |
| CLAM::SpectrumInterpolator | This calss performs the interpolation of two Spectrum processing data objects |
| CLAM::SpectrumPortMonitor | |
| CLAM::SpectrumProduct | This class performs the product of two Spectrum processing data objects |
| CLAM::SpectrumSubstracter2 | This calss performs the substraction of two Spectrum processing data objects |
| CLAM::SpecTypeFlags | This class tells which formats are instantiated in a Spectrum |
| CLAM::SquaredSumTmpl< abs, T > | Class Function that computes Sum(x(i)^2) using std::accumulate and Square<T> BinaryOp |
| CLAM::SquareTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^2) |
| CLAM::StandardDeviationTmpl< abs, T, U > | Class Function to compute StandardDeviation |
| StaticBool< b > | |
| CLAM::StaticCycleBranch | |
| CLAM::StaticFlowControl | |
| CLAM::StatMemory< T > | An StatMemory may hold a T value and remembers whether it has been set or is not initialized |
| CLAM::StatsTmpl< abs, T, U, initOrder > | Class to hold basic statistics related to an array of arbitrary data |
| CLAM::StdList< T > | This declaration is necessary for VC7 compatibility |
| CLAM::StdVector< T > | |
| CLAM::Storable | Interface for objects to be stored on a Storage |
| CLAM::Storage | The abstract class for storages |
| SDIF::Storage | Storage is an abstract class, that is passed to File, used to handle every read frame |
| CLAM::STrajectory | |
| CLAM::AudioCodecs::Stream | Streams provide I/O to and from an audio file of a given format |
| SDIF::Stream | SDIF has a notion of streams: each frame contains a stream id |
| CLAM::StreamImpl< Token, DataStructure > | |
| CLAM::StreamImpl< Token, PhantomBuffer > | |
| CLAM::SumTmpl< abs, T > | Class Function that computes Sum(x(i)) using std::accumulate and NoPower<T> BinaryOp |
| CLAM::SynthSineSpectrum | Configuration class for the SynthSineSpectrum Processing |
| CLAM::SynthSineSpectrumConfig | Config class for the SynthSineSpectrum Processing |
| MIDI::SysExEvent | |
| CLAM::TabFunct< OriginalFunction > | Precalculated (tabulated) functor, for dealing with efficient version of expensive functions (with its associated cost in space and precision) |
| CLAM::DynamicType::TAttr | |
| SigSlot::Signalv0::tCallback | |
| SigSlot::Signalv3< ParmType1, ParmType2, ParmType3 >::tCallback | |
| SigSlot::ConnectionHandler< SignalType >::tCallback | Inner type for ConnectionHandler |
| SigSlot::Signalv4< ParmType1, ParmType2, ParmType3, ParmType4 >::tCallback | |
| SigSlot::Signalv2< ParmType1, ParmType2 >::tCallback | |
| SigSlot::Signalv1< ParmType1 >::tCallback | |
| CLAM::TDescriptorsParams | |
| CLAM::DynamicType::TDynInfo | |
| MIDI::Tempo | |
| CLAM::Enum::tEnumValue | |
| CLAM::Text | This class represents an string that can contain any kind of separators |
| CLAM::FlagsBase::tFlagValue | The type of the name table rows |
| CLAM::Thread | |
| CLAM::ThreadPool | This is a simple variety of thread pool |
| CLAM::ThreadResourceError | |
| CLAM::ThreeBandAM | |
| CLAM::ThreeBandCompressor | Limits the spectrum magnitude to different threshold for each of three bands |
| CLAM::ThreeBandFilter | Amplifies the spectrum magnitude to different gain for each of three bands |
| CLAM::ThreeBandGate | |
| CLAM::TimedMutex | |
| CLAM::AudioDevice::TInfo | This class is used to respond to device information request using the GetInfo method |
| CLAM::MIDIDevice::TInfo | This class is used to respond to device information request using the GetInfo method |
| CLAM::TokenDelay< T > | A Processing Object that delays a certain number of ProcessingDataObjects wherever the specific object it is |
| CLAM::TokenDelayConfig | Configuration of the TokenDelay processing object |
| CLAM::TonalAnalysis | |
| CLAM::TonalAnalysisConfig | |
| CLAM::TopLevelProcessing | Top level processing object composite |
| CLAM::TopLevelProcessingConfig | |
| MIDI::Track | |
| TraverseDirectory | |
| CLAM::TryMutex | |
| SDIF::TUTF8byte | |
| CLAM::TypedInControl< ControlDataType > | Transition class, use InControl instead |
| CLAM::TypedOutControl< ControlDataType > | |
| SDIF::TypeId | Used to store the Frame and Matrix types, a 4-byte identifier |
| CLAM::TypeInfo< T > | |
| CLAM::UnavailableSoundFile | |
| CLAM::UnsizedSegmentation | |
| CLAM::UnsupportedSoundFileFormat | |
| CLAM::UnsupportedSoundFileSampleEncoding | |
| CLAM::ValueToRatioMapping | |
| CLAM::ValueToRatioMappingFactory | |
| CLAM::Vocoder | |
| CLAM::WaveFunctor< WaveType > | |
| CLAM::WaveGenerator | |
| CLAM::WaveGeneratorConfig | |
| CLAM::WeightedCubedSumTmpl< abs, T > | Class Function that computes Sum(i*x(i)^3) using std::accumulate and WeightedCube<T> BinaryOp |
| CLAM::WeightedCubeTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^3) |
| CLAM::WeightedNoPowerTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^1) |
| CLAM::WeightedPower< s, abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^n) |
| CLAM::WeightedPoweredSum< s, abs, T > | Class Function that computes Sum(i*x(i)^n) using std::accumulate and WeightedPower<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
| CLAM::WeightedSquaredSumTmpl< abs, T > | Class Function that computes Sum(i*x(i)^2)using std::accumulate and WeightedSquare<T> BinaryOp |
| CLAM::WeightedSquareTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^2) |
| CLAM::WeightedSumTmpl< abs, T > | Class Function that computes Sum(i*x(i)) using std::accumulate and WeightedNoPower<T> BinaryOp |
| CLAM::Win32ConsoleApp | |
| CLAM::WindowGenerator | This class can be used for generating Windows and for zeropadding the windowed data |
| CLAM::WindowGeneratorConfig | |
| CLAM::WriteHook< AttributeType > | |
| MIDI::Writer | |
| CLAM::WritingRegion< Token, DataStructure > | |
| CLAM::XercesDomDocumentHandler | XML implementation backend for the Xerces-C library |
| CLAM::XercesDomReader | Controls the Xerces-C DOM parser |
| CLAM::XercesDomReadingContext | Keeps the booking when loading a single Xerces-C DOM element into CLAM data |
| CLAM::XercesDomWriter | Controls the Xerces-C DOM serializer |
| CLAM::XercesDomWritingContext | Keeps the booking when mapping CLAM data into a single Xerces-C DOM element |
| CLAM::XercesInitializer | Ensures that Xerces-C library initialization and termination occurs once and only when needed |
| CLAM::XercesLocal2Unicode | Converts local encoding char* into Xerces Unicode String |
| CLAM::XercesUnicode2Local | Converts Xerces Unicode String into local encoding char* |
| CLAM::XMLable | Interface for objects to be stored on a XMLStorage |
| CLAM::XMLAdapter< T > | This class adapts to the XMLable interface any basic object |
| CLAM::XMLArrayAdapter< T > | This class adapts to the XMLable interface any array of basic objects |
| CLAM::XmlAttribute | An scoped XML writer object that inserts on construction an XML atribute to the last open XML element |
| CLAM::XMLComponentAdapter | This class adapts to the XMLable interface any object that is a CLAM::Component |
| CLAM::XmlContent | An scoped XML writer object inserting plain content to the current XML level |
| CLAM::XmlElement | An scoped XML writer object that opens a new element on construction and closes it on destruction |
| CLAM::XmlFragment | This is the first scoped object you should create for a XML fragment |
| CLAM::XMLIterableAdapter< T > | This class adapts to the XMLable interface any STL like container of basic objects or CLAM::Component's |
| CLAM::XmlStorage | Provides XML format storage for CLAM Component's |
| CLAM::XmlStorageErr | |
| CLAM::XmlWriteContext | This class provides primitives to write an XML document to a target stream and to keep track of the writting state |
| CLAM::xtime | |
| CLAM::ZeroPadder | |
| CLAM::ZeroPadderConfig | |
