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::AudioCircularBuffer | Specialization of the CircularBuffer class for the case of Audio chunks |
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 | |
CLAM::CircularBuffer< T > | Generic container-like circular buffer class |
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::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::ComplexTmpl< T > | |
CLAM::ComplexToPolarCnv< T > | |
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::Network::Connection | |
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::PolarTmpl< T > | |
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::AudioSink::Port | |
CLAM::AudioBufferSource::Port | |
CLAM::AudioBufferSink::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::Network::ProcessingAndGeometry | |
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 |
SDIF::Storage | Storage is an abstract class, that is passed to File, used to handle every read frame |
CLAM::Storage | The abstract class for storages |
CLAM::STrajectory | |
SDIF::Stream | SDIF has a notion of streams: each frame contains a stream id |
CLAM::AudioCodecs::Stream | Streams provide I/O to and from an audio file of a given format |
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::Signalv2< ParmType1, ParmType2 >::tCallback | |
SigSlot::Signalv4< ParmType1, ParmType2, ParmType3, ParmType4 >::tCallback | |
SigSlot::ConnectionHandler< SignalType >::tCallback | Inner type for ConnectionHandler |
SigSlot::Signalv0::tCallback | |
SigSlot::Signalv1< ParmType1 >::tCallback | |
SigSlot::Signalv3< ParmType1, ParmType2, ParmType3 >::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::MIDIDevice::TInfo | This class is used to respond to device information request using the GetInfo method |
CLAM::AudioDevice::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 | |