Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123456]

CA2DPConfig	Configuration for A2DPStream
►CAbstractMetaData	Common Metadata methods
CMetaDataICY	Icecast/Shoutcast Metadata Handling. Metadata class which splits the data into audio and metadata. The result is provided via callback methods. see https://www.codeproject.com/Articles/11308/SHOUTcast-Stream-Ripper
CMetaDataID3	Simple ID3 Meta Data Parser which supports ID3 V1 and V2 and implements the Stream interface. You just need to set the callback(s) to receive the result and copy the audio data to this stream
►CAbstractParameter	Base class for all parameters
CADSR	Generates ADSR values between 0.0 and 1.0
CParameter	A constant value
CScaledParameter	Scales a dynamic parameter to the indicated range
►CAbstractSynthesizerChannel	Defines the sound generation for one channel. A channel is used to process an indivudual key so that we can generate multiple notes at the same time
CDefaultSynthesizerChannel	Default implementation for a Channel. You can provide the Sound Generator as parameter to the effects: e.g. DefaultSynthesizerChannel<AudioEffects<SineWaveGenerator<int16_t>>> *channel = new DefaultSynthesizerChannel<AudioEffects<SineWaveGenerator<int16_t>>>();
CAudioActions::Action
►CAdafruit_USBD_Interface
CUSBDeviceAudioAdafruit
CADTSParser
►CAllocator	Memory allocateator which uses malloc
CAllocatorExt	Memory allocateator which uses ps_malloc (on the ESP32) and if this fails it resorts to malloc
CAllocSize
►CAnalogDriverBase
CAnalogDriverArduino	Please use the AnalogAudioStream: Reading Analog Data using a timer and the Arduino analogRead() method and writing using analogWrite();
CAnalogDriverESP32	Please use AnalogAudioStream: A very fast ADC and DAC using the ESP32 I2S interface
CAnalogDriverESP32V1	AnalogAudioStream: A very fast DAC using DMA using the new dac_continuous API
CAnalogDriverESP32V1	AnalogAudioStream: A very fast DAC using DMA using the new dac_continuous API
CAnalogDriverMBED	Please use AnalogAudioStream: A ADC and DAC API for the Arduino Giga
CAppropriateSumType< T >	We reduce the number of samples in a datastream by summing (binning) or averaging. This will result in the same number of channels but binSize times less samples. If Average is true the sum is divided by binSize
CAppropriateSumType< int16_t >
CAppropriateSumType< int24_t >
CAppropriateSumType< int32_t >
CAppropriateSumType< int8_t >
CArray< T, LEN >
CArray< ffft::OscSinCos, TRIGO_OSC_ARR_SIZE >
Caudio_feedback_params_t
CAudioActions	A simple class to assign functions to gpio pins e.g. to implement a simple navigation control or volume control with buttons
CAudioClientRTSP	A simple RTSPClient using https://github.com/pschatzmann/arduino-live555
CUSBDeviceAudioAPI::audiod_function_t
►CAudioEffect	Abstract Base class for Sound Effects
CADSRGain	ADSR Envelope: Attack, Decay, Sustain and Release. Attack is the time taken for initial run-up oeffect_tf level from nil to peak, beginning when the key is pressed. Decay is the time taken for the subsequent run down from the attack level to the designated sustainLevel level. Sustain is the level during the main sequence of the sound's duration, until the key is released. Release is the time taken for the level to decay from the sustainLevel level to zero after the key is released.[4]
CBoost	Boost AudioEffect
CCompressor	Compressor inspired by https://github.com/YetAnotherElectronicsChannel/STM32_DSP_COMPRESSOR/blob/master/code/Src/main.c
CDelay	Delay/Echo AudioEffect. See https://wiki.analog.com/resources/tools-software/sharc-audio-module/baremetal/delay-effect-tutorial Howver the dry value and wet value were replace by the depth parameter
CDistortion	Distortion AudioEffect
►CEffectSuiteBase	Base Class for Effects
►CFilterEffectBase	A Base class for filter based effects including methods for simple high, low and band pass filtering
CEnvelopeFilter	EnvelopeFilter
CFilteredDelay	Delay effect that filters the repeat delay
►CSimpleLPF	SimpleLPF
CSimpleChorus	Simple Chorus effect with a single delay voice and mono output Chorus is effective between 15 and 20 miliseconds delay of original audio. Requires the sample rate when initialising
CSimpleDelay	Simple Delay effect consiting of a single tap delay with Effect Gain and feed back controls Constructor requires internal delay in samples
CSimpleFlanger	Simple Flanger Effect Consistig of a single voice flanger The flanger has an effective range between 0 and 15 miliseconds in this case dleay buffer should be set to sampleRate*3/200 Constructor requires internal delay in samples
CFuzz	Fuzz AudioEffect
CPitchShift	Shifts the pitch by the indicated step size: e.g. 2 doubles the pitch
CSTKChorus	Chorus Effect
CSTKChowningReverb	John Chowning's reverberator class
CSTKEcho	Echo Effect
CSTKEffect	Use any effect from the STK framework: e.g. Chorus, Echo, FreeVerb, JCRev, PitShift... https://github.com/pschatzmann/Arduino-STK
CSTKFreeVerb	Jezar at Dreampoint's FreeVerb, implemented in STK
CSTKLentPitShift	Pitch shifter effect class based on the Lent algorithm
CSTKNReverb	CCRMA's NRev reverberator class
CSTKPerryReverb	Perry's simple reverberator class
CSTKPitShift	Simple Pitch shifter effect class: This class implements a simple pitch shifter using a delay line
CTremolo	Tremolo AudioEffect
CAudioEffectCommon
CAudioFFTResult	Result of the FFT
►CAudioHeader	Common Header for all records
CAudioConfirmDataToReceive	Protocol Record for Request
CAudioDataBegin	Protocal Record To Start
CAudioDataEnd	Protocol Record for End
CAudioSendData	Protocol Record for Data
►CAudioInfo	Basic Audio information which drives e.g. I2S
CAnalogConfigESP32	ESP32 specific configuration for i2s input via adc. The default input pin is GPIO34. We always use int16_t values. The default output pins are GPIO25 and GPIO26!
CAnalogConfigESP32V1	ESP32 specific configuration for i2s input via adc using the adc_continuous API
CAnalogConfigStd	Generic ADC and DAC configuration
CAudioFFTConfig	Configuration for AudioFFT. If there are more then 1 channel the channel_used is defining which channel is used to perform the fft on
CAudioLoRaConfig	LoRa Audio Configuration with default values maximised for speed
CAudioMP34DT05Config	Config for MP34DT05 Microphone. Supported sample rates 16000, 41667, Supported bits_per_sample only 16
CAudioServerExConfig	Config information for AudioServerEx
CConfigEquilizer3Bands	Configuration for 3 Band Equilizer: Set channels,bits_per_sample,sample_rate. Set and update gain_low, gain_medium and gain_high to value between 0 and 1.0
CDACInfo	Config info for DeltaSigma DAC
►CI2SConfigESP32	Configuration for ESP32 legacy i2s
CAudioKitStreamConfig	Configuration for AudioKitStream: we use as subclass of I2SConfig
CI2SCodecConfig	Configuration for I2SCodecStream
CWM8960Config	Configuration for WM8960
CI2SConfigESP32V1	Configuration for ESP32 i2s for IDF > 5.0
CI2SConfigStd	Configuration for i2s
CLoRaConfig	LoRa Audio Configuration with default values maximised for speed using the LoRa library from sandeepmistry: https://github.com/sandeepmistry/arduino-LoRa
CMiniAudioConfig	Configuration for MiniAudio
CMozziConfig
►COpusSettings	Setting for Opus Decoder
COpusEncoderSettings	Setting for Opus Encoder where the following values are valid: -1 indicates that the default value should be used and that this codec is not setting the value
CPWMConfig	Configuration data for PWM audio output
CPitchShiftInfo	Configuration for PitchShiftOutput: set the pitch_shift to define the shift
CPortAudioConfig	PortAudio information
CProgressStreamInfo	Configuration for ProgressStream
CR2RConfig	R2R configuration
CResampleConfig	Optional Configuration object. The critical information is the channels and the step_size. All other information is not used
CSPDIFConfig	SPDIF configuration
CThrottleConfig	Configure Throttle setting
CTimerCallbackAudioStreamInfo	TimerCallbackAudioStream Configuration
CVBANConfig
CVS1053Config	Configuration for VS1053Stream
CVolumeStreamConfig	Config for VolumeStream
CWAVAudioInfo	Sound information which is available in the WAV header
CWavIMAAudioInfo	Sound information which is available in the WAV header - adjusted for IMA ADPCM
►CAudioInfo
CAudioInfoLAME	LAME parameters
►CAudioInfoSource	Supports the subscription to audio change notifications
►CAudioDecoder	Docoding of encoded audio into PCM data
CAACDecoderFAAD	AAC Decoder using faad: https://github.com/pschatzmann/arduino-libfaad This needs a stack of around 60000 and you need to make sure that memory is allocated on PSRAM. See https://www.pschatzmann.ch/home/2023/09/12/arduino-audio-tools-faat-aac-decoder/
CAACDecoderFDK	Audio Decoder which decodes AAC into a PCM stream This is basically just a wrapper using https://github.com/pschatzmann/arduino-fdk-aac which uses AudioInfo and provides the handlig of AudioInfo changes
CAACDecoderHelix	AAC Decoder using libhelix: https://github.com/pschatzmann/arduino-libhelix This is basically just a simple wrapper to provide AudioInfo and AudioInfoSupport
CADPCMDecoderXQ	Decoder for ADPCM-XQ. Depends on https://github.com/pschatzmann/arduino-adpcm-xq
CADTSDecoder	Audio Data Transport Stream (ADTS) is a format similar to Audio Data Interchange Format (ADIF), used by MPEG TS or Shoutcast to stream audio defined in MPEG-2 Part 7, usually AAC. This parser extracts all valid ADTS frames from the data stream ignoring other data
CAPTXDecoder	Decoder for OpenAptx. Depends on https://github.com/pschatzmann/libopenaptx
►CAudioDecoderExt
CADPCMDecoder	Decoder for ADPCM. Depends on https://github.com/pschatzmann/adpcm
CCodec2Decoder	Decoder for Codec2. Depends on https://github.com/pschatzmann/arduino-libcodec2
CCodecNOP	Dummy no implmentation Codec. This is used so that we can initialize some pointers to decoders and encoders to make sure that they do not point to null
►CContainerDecoder	Parent class for all container formats
CAVIDecoder	AVI Container Decoder which can be fed with small chunks of data. The minimum length must be bigger then the header size! The file structure is documented at https://learn.microsoft.com/en-us/windows/win32/directshow/avi-riff-file-reference
CBinaryContainerDecoder	Decodes the provided data from the DAT and CFG segments
CContainerMP4	Minimum flexible parser for MPEG4 data (which is based on the Quicktime format). Small atoms will be make available via a callback method. The big (audio) content is written to the Print object which was specified in the constructor. Depends on https://github.com/pschatzmann/arduino-libhelix!
►COggContainerDecoder	Decoder for Ogg Container. Decodes a packet from an Ogg container. The Ogg begin segment contains the AudioInfo structure. You can subclass and overwrite the beginOfSegment() method to implement your own headers Dependency: https://github.com/pschatzmann/arduino-libopus
COpusOggDecoder	Opus Decoder which uses the Ogg Container. See https://datatracker.ietf.org/doc/html/rfc7845. The audio data is transmitted in frames and the header information contains the sampler rate, channels and other critical info. Dependency: https://github.com/pschatzmann/arduino-libopus
CCopyDecoder	Dummy Decoder which just copies the provided data to the output. You can define if it is PCM data
CDecoderAdapter	Adapter class which allows the AudioDecoder API on a StreamingDecoder
CDecoderBase64	DecoderBase64 - Converts a Base64 encoded Stream into the original data stream. Decoding only gives a valid result if we start at a limit of 4 bytes. We therefore use by default a newline to determine a valid start boundary
CDecoderBasic	DecoderBasic - supports mime type audio/basic Requires https://github.com/pschatzmann/arduino-libg7xx The content of the "audio/basic" subtype is single channel audio encoded using 8bit ISDN mu-law [PCM] at a sample rate of 8000 Hz
CDecoderFloat	DecoderFloat - Converts Stream of floats into 2 byte integers
CDecoderHelix	MP3 and AAC Decoder using libhelix: https://github.com/pschatzmann/arduino-libhelix. We dynamically create a MP3 or AAC decoder dependent on the provided audio format
CDecoderL16	DecoderL16 - Converts an 16 Bit Stream into 16Bits network byte order
CDecoderL8	DecoderL8 - Converts an 8 Bit Stream into 16Bits Most microcontrollers can not output 8 bit data directly. 8 bit data however is very memory efficient and helps if you need to store audio on constrained resources. This decoder translates 8bit data into 16bit data. By default the encoded data is represented as uint8_t, so the values are from 0 to 255
CG722Decoder	Decoder for G.722. Depends on https://github.com/pschatzmann/arduino-libg722
►CG7xxDecoder	G723_24, g721, g723_40 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
►CG711Decoder	64 kbit/s g711 ULOW Decoder based on https://github.com/pschatzmann/arduino-libg7xx Supported decoder parameters: alaw2linear, ulaw2linear
CG711_ALAWDecoder	64 kbit/s g711 ALOW Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG711_ULAWDecoder	64 kbit/s g711 ULOW Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG721Decoder	32Kbps G721 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_24Decoder	24Kbps G723 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_40Decoder	40Kbps G723 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CGGWaveDecoder	GGWaveDecoder: Translates audio into text Codec using https://github.com/ggerganov/ggwave-arduino
CGSMDecoder	Decoder for GSM. Depends on https://github.com/pschatzmann/arduino-libgsm. Inspired by gsmdec.c
CILBCDecoder	Decoder for iLBC. Depends on https://github.com/pschatzmann/libilbc
CLC3Decoder	Decoder for LC3. Depends on https://github.com/pschatzmann/arduino-liblc3
CMP3DecoderHelix	MP3 Decoder using libhelix: https://github.com/pschatzmann/arduino-libhelix This is basically just a simple wrapper to provide AudioInfo and AudioInfoSupport
CMP3DecoderMAD	MP3 Decoder using https://github.com/pschatzmann/arduino-libmad
CMP3DecoderMini	MP3 Decoder using https://github.com/pschatzmann/minimp3. This decoder does not provide any good results and it is not suited to decode any audio above 32000 on an ESP32. So the sample rate is limited by the MINIMP3_MAX_SAMPLE_RATE variable
CMTSDecoder1	MPEG-TS (MTS) decoder. Extracts the AAC audio data from a MPEG-TS (MTS) data stream. You can define the relevant stream types via the API. The parsing logic was taken from: https://github.com/Yokohama-Miyazawa/M5HLSPlayer/blob/main/src/AudioGeneratorTS.cpp Status: experimental!
CMTSDecoder1	MPEG-TS (MTS) decoder. Extracts the AAC audio data from a MPEG-TS (MTS) data stream. You can define the relevant stream types via the API. The parsing logic was taken from: https://github.com/Yokohama-Miyazawa/M5HLSPlayer/blob/main/src/AudioGeneratorTS.cpp Status: experimental!
CMetaDataFilterDecoder
COpusAudioDecoder	OpusAudioDecoder: Depends on https://github.com/pschatzmann/arduino-libopus.git
CSBCDecoder	Decoder for SBC. Depends on https://github.com/pschatzmann/arduino-libsbc. Inspired by sbcdec.c
CWAVDecoder	A simple WAVDecoder: We parse the header data on the first record to determine the format. If no AudioDecoderExt is specified we just write the PCM data to the output that is defined by calling setOutput(). You can define a ADPCM decoder to decode WAV files that contain ADPCM data. Please note that you need to call begin() everytime you process a new file to let the decoder know that we start with a new header
CWavIMADecoder	Obsolete: WavIMADecoder - based on WAVDecoder - We parse the header data as we receive it and send the sound data to the stream which was indicated in the constructor. Only WAV files with WAVE_FORMAT_IMA_ADPCM are supported by this codec!
►CAudioOutput	Abstract Audio Ouptut class
CAudioESP32ULP	Outputs to ESP32 DAC through the ULP (Ultra> Low Power coprocessor), freeing I2S for other uses. Connect left channel on pin 25 Connect right channel on pin 26
►CAudioFFTBase	Executes FFT using audio data. The Driver which is passed in the constructor selects a specifc FFT implementation
CAudioCmsisFFT	AudioFFT for ARM processors that provided Cmsis DSP
CAudioESP32FFT	AudioFFT using RealFFT
CAudioEspressifFFT	AudioFFT using FFTReal. The only specific functionality is the access to the dataArray
CAudioKissFFT	AudioFFT using FFTReal. The only specific functionality is the access to the dataArray
CAudioRealFFT	AudioFFT using RealFFT
►CAudioOutputAdapter	Base class for Output Adpapters
CAdapterAudioStreamToAudioOutput	Wrapper which converts a AudioStream to a AudioOutput
CAdapterPrintToAudioOutput	Wrapper which converts a Print to a AudioOutput
CAudioWriterToAudioOutput	Adapter class which lets an AudioWriter behave like a Print
CAudioOutputWithCallback	ESP8266Audio AudioOutput class which stores the data in a temporary buffer. The buffer can be consumed e.g. by a callback function by calling read(); Dependencies: ESP8266Audio Library Dependencies: ESP32-A2DP Library
►CAudioServerEx	A powerfull Web server which is based on https://github.com/pschatzmann/TinyHttp. It supports multiple concurrent clients. You can e.g. use it to write mp3 data and make it available in multiple clients
CAudioWAVServerEx	A powerfull WAV Web server which is based on https://github.com/pschatzmann/TinyHttp. It supports multiple concurrent clients
CAudioSyncWriter	Audio Writer which is synchronizing the amount of data that can be processed with the AudioReceiver
CChannelSplitOutput	Simple functionality to extract mono streams from a multichannel (e.g. stereo) signal
CChannelsSelectOutput	Flexible functionality to extract one or more channels from a multichannel signal. Warning: the destinatios added with addOutput are not automatically notified about audio changes
CCsvOutput< T >	Stream Wrapper which can be used to print the values as readable ASCII to the screen to be analyzed in the Serial Plotter The frames are separated by a new line. The channels in one frame are separated by a ,
CHexDumpOutput	Creates a Hex Dump
CMemoryOutput	Writes to a preallocated memory
CMetaDataFilter	Class which filters out ID3v1 and ID3v2 Metadata and provides only the audio data to the decoder
CMetaDataOutput	ID3 and Icecast/Shoutcast metadata output support. Just write the audio data to an object of this class and receive the metadata via the callback
►CModifyingOutput	Abstract class: Objects can be put into a pipleline
CEncodedAudioOutput	A more natural Print class to process encoded data (aac, wav, mp3...). Just define the output and the decoder and write the encoded data
CMultiOutput	Replicates the output to multiple destinations
►COggContainerOutput	Output class for the OggContainerEncoder. Each write is ending up as container entry
COpusOggWriter
►COversamplingDAC	Abstract Software Implementation of an Oversampling DAC
►COversamplingDAC32	Software Implementation of a Simple DAC - We quantize a digital int16_t sample my mapping the value to the range of 0b0 to 0b11111111111111111111111111111111, where the intensity is represented by the number of ones. This gives an overall resultion of 5 bits and just uses one single timer
CSerialDAC	A SimpleDAC which uses the Serial UART to output values. This implementation is not using any timers and therefore should work on any microcontroller
CPWMDAC	Audio Output with PWM signal
CSimpleDAC	Software Implementation of a Simple DAC - We quantize a digital int16_t sample my mapping the value to the range of 0b0 to info.output_bits number of 1, where the intensity is represented by the number of ones. This is very similar to PWM!
CPWMAudioOutput	Common functionality for PWM output. We generate audio using PWM with a frequency that is above the hearing range. The sample rate is usually quite restricted, so we also automatically decimate the data. Further info see PWMConfig
CPitchShiftOutput< T, BufferT >	Pitch Shift: Shifts the frequency up or down w/o impacting the length! We reduce the channels to 1 to calculate the pitch shift and provides the pitch shifted result in the correct number of channels. The pitch shifting is done with the help of a buffer that can have potentially multiple implementations
CR2ROutput	Output to R-2R DAC. You need to define the used digital pins in the configuration. Any number of bits is supported on max 2 channels. For a 4 bit single channel, you need to define 4 digital pins. see https://www.electronics-tutorials.ws/combination/r-2r-dac.html The default driver implementation uses Arduino digitalWrite(). You can provide your own optimized driver
CRTSPOutput	We can write PCM data to the RTSPOutput. This is encoded by the indicated encoder (e.g. SBCEncoder) and can be consumed by a RTSPServer. You have to make sure that the codec supports the provided audio format: e.g. GSM support only 8000 samples per second with one channel. Depends on the https://github.com/pschatzmann/Micro-RTSP-Audio/ library
►CAudioStream	Base class for all Audio Streams. It support the boolean operator to test if the object is ready with data
►CGeneratedSoundStream< int16_t >
CSTKStream< StkCls >	STK Stream for Instrument or Voicer
CA2DPStream	Stream support for A2DP using https://github.com/pschatzmann/ESP32-A2DP: begin(TX_MODE) opens a a2dp_source and begin(RX_MODE) a a2dp_sink. The data is in int16_t with 2 channels at 44100 hertz. We support only one instance of the class! Please note that this is a conveniance class that supports the stream api, however this is rather inefficient, beause quite a big buffer needs to be allocated. It is recommended to use the API with the callbacks. Examples can be found in the a2dp examples directory starting with basic
►CAbstractURLStream	Abstract Base class for all URLStream implementations
CICYStream	Icecast/Shoutcast Audio Stream which splits the data into metadata and audio data. The Audio data is provided via the regular stream functions. The metadata is handled with the help of the MetaDataICY state machine and provided via a callback method
CICYStreamBuffered	ICYStream implementation for the ESP32 based on a FreeRTOS task This is a Icecast/Shoutcast Audio Stream which splits the data into metadata and audio data. The Audio data is provided via the regular stream functions. The metadata is handled with the help of the MetaDataICY state machine and provided via a callback method
CURLStream	Represents the content of a URL as Stream. We use the WiFi.h API
CURLStreamBuffered	URLStream implementation for the ESP32 based on a separate FreeRTOS task
CAdapterAudioOutputToAudioStream	Wrapper which converts a AudioStream to a AudioOutput
CAnalogAudioArduino	Analog Data IO using a timer and the Arduino analogRead() method and writing using analogWrite();
CAnalogAudioStream	ESP32: A very fast ADC and DAC using the ESP32 I2S interface. For all other architectures we support reading of audio only using analog input with a timer
CAnalogDriverESP32V1::IO16Bit
CAnalogDriverESP32V1::IO16Bit
►CAudioBLEStream	Transmit and receive data via BLE using a Serial API. The following additional experimental features are offered: setFramed(true) tries to keep the original write sizes; setAudioInfoActive(true) informs about changes in the audio info
CAudioBLEClient	A simple BLE client that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminology this is a Central
CAudioBLEClient	A simple BLE client that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminology this is a Central
CAudioBLEServer	A simple BLE server that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminologiy this is a Peripheral. This implementation uses the ArduinoBLE library! This is working only correctly if the client sets the max MTU to a value >= 256. Otherwise some of the transmitted information gets silently dropped
CAudioBLEServer	A simple BLE server that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminologiy this is a Peripheral. This implementation uses the ArduinoBLE library! This is working only correctly if the client sets the max MTU to a value >= 256. Otherwise some of the transmitted information gets silently dropped
CAudioKitStream	AudioKit Stream which uses the https://github.com/pschatzmann/arduino-audiokit library
CAudioLoRa	LoRa Audio Sending and Receiving
CAudioMP34DT05	MP34DT05 Microphone of Nano BLE Sense. We provide a proper Stream implementation. See https://github.com/arduino/ArduinoCore-nRF528x-mbedos
CAudioStreamWrapper	To be used to support implementations where the readBytes is not virtual
CAudioSyncReader	Receving Audio Data over the wire and requesting for more data when done to synchronize the processing with the sender. The audio data is processed by the EncodedAudioStream; If you have multiple readers, only one receiver should be used as confirmer!
CBufferedTaskStream	A FreeRTOS task is filling the buffer from the indicated stream. Only to be used on the ESP32
►CDecimationStreamExt< T >	Deciates an sample stream by the indicated factor: Decimation counts the number of set bits. Please note that the factor is specified as multiple of the bits_per_sample. It is also assumed that we have only one channel in the data stream
CBitBangDecimationStream< T >
CESP3288AudioOutput	Stream Adapter for ESP8288-Audio AudioOutput
CFaustStream< DSP >	Integration into Faust DSP see https://faust.grame.fr/ To generate code from faust, select src and cpp
CFrequncyAutoCorrelationStream	Determine Frequency using Audio Correlation. based on https://github.com/akellyirl/AutoCorr_Freq_detect
CFrequncyZeroCrossingStream	Determine Frequency using upward 0 crossings
CGeneratedSoundStream< T >	Source for reading generated tones. Please note
CHLSStream	HTTP Live Streaming using HLS: The result is a MPEG-TS data stream that must be decoded e.g. with a DecoderMTS
CI2SBitBang	I2S emulated with the help of the Arduion SPI api
►CI2SCodecStream	I2S Stream which also sets up a codec chip and i2s
CAudioBoardStream	New functionality which replaces the AudioKitStream that is based on the legacy AudioKit library. This functionality uses the new arduino-audio-driver library! It is the same as I2SCodecStream extended by some AudioActions and some method calls to determine defined pin values. See https://github.com/pschatzmann/arduino-audio-driver
CI2SStream	We support the Stream interface for the I2S access. In addition we allow a separate mute pin which might also be used to drive a LED..
CInputMerge< T >	Merges multiple input channels. The input must be mono! So if you provide 2 mono channels you get a stereo signal as result with the left channel from channel 0 and the right from channel 1
CInputMixer< T >	MixerStream is mixing the input from Multiple Input Streams. All streams must have the same audo format (sample rate, channels, bits per sample)
CJupyterAudioT< T >	Output to Jupyter. We write the data just to a file from where we can load the data again for different representations
CLoRaStream	LoRa: Sending and Receiving Audio
CMemoryStream	A simple Stream implementation which is backed by allocated memory
CMiniAudioStream	MiniAudio: https://miniaud.io/
►CModifyingStream	Abstract class: Objects can be put into a pipleline
CFilteredStream< T, float >
CAudioEffectStream	EffectsStream supporting variable bits_per_sample. This class is only available when __cplusplus >= 201703L. Otherwise AudioEffectStream results in using AudioEffectStream = AudioEffectStreamT<effect_t>;
CAudioEffectStreamT< T >	EffectsStreamT: the template class describes an input or output stream to which one or multiple effects are applied. The number of channels are used to merge the samples of one frame into one sample before outputting the result as a frame (by repeating the result sample for each channel). Currently only int16_t values are supported, so I recommend to use the AudioEffectStream class which is defined as using AudioEffectStream = AudioEffectStreamT<effect_t>;
►CBufferedStream	The Arduino Stream supports operations on single characters. This is usually not the best way to push audio information, but we will support it anyway - by using a buffer. On reads: if the buffer is empty it gets refilled
CAudioOutputWithCallback	ESP8266Audio AudioOutput class which stores the data in a temporary buffer. The buffer can be consumed e.g. by a callback function by calling read(); Dependencies: ESP8266Audio Library Dependencies: ESP32-A2DP Library
CTimerCallbackAudioStream	Callback driven Audio Source (rx_tx_mode==RX_MODE) or Audio Sink (rx_tx_mode==TX_MODE). This class allows to to integrate external libraries in order to consume or generate a data stream which is based on a timer
CCallbackStream	CallbackStream: A Stream that allows to register callback methods for accessing and providing data. The callbacks can be lambda expressions
CConverterStream< T >	Both the data of the read or write operations will be converted with the help of the indicated converter
CEquilizer3Bands	3 Band Equilizer inspired from https://www.musicdsp.org/en/latest/Filters/236-3-band-equaliser.html
CFadeStream	Stream which can be used to manage fade in and fade out. Before you read or write data you need to call setAudioInfo() to provide the bits_per_sample and channels
CFilteredStream< T, TF >	Stream to which we can apply Filters for each channel. The filter might change the result size!
CMeasuringStream	Class which measures the thruput
CPipeline::ModifyingStreamAdapter	Support for ModifyingOutput
CProgressStream	Generic calss to measure the the total bytes which were processed in order to calculate the progress as a percentage of the total size
►CReformatBaseStream	Base class for chained converting streams
CChannelFormatConverterStream	Channel converter which does not use a template
CChannelFormatConverterStreamT< T >	Converter for reducing or increasing the number of Channels
CEncodedAudioStream	A more natural Stream class to process encoded data (aac, wav, mp3...) which also supports the decoding by calling readBytes()
CFormatConverterStream	Converter which converts bits_per_sample, channels and the sample_rate. The conversion is supported both on the input and output side
CNumberFormatConverterStream	Converter which converts between bits_per_sample and 16 bits. The templated NumberFormatConverterStreamT class is used based on the information provided by the bits_per_sample in the configuration
CNumberFormatConverterStreamT< TFrom, TTo >	A more generic templated Converter which converts from a source type to a target type: You can use e.g. uint8_t, int8_t, int16_t, uint16_t, int24_t, uint32_t, int32_t, FloatAudio.AbstractMetaDat. This is quite handy because unsigned values and floating values are supported and you do not need to resort to use a Codec
CResampleStream	Dynamic Resampling. We can use a variable factor to speed up or slow down the playback
CThrottle	Throttle the sending or receiving of the audio data to limit it to the indicated sample rate
CTimedStream	AudioStream class that can define a start and (an optional) stop time Usually it is used to wrap an Audio Sink (e.g. I2SStream), but wrapping an Audio Source is supported as well. Only wrap classes which represent PCM data!
CVolumeMeter	A simple class to determine the volume. You can use it as final output or as output or input in your audio chain
CVolumeStream	Adjust the volume of the related input or output: To work properly the class needs to know the bits per sample and number of channels! AudioChanges are forwareded to the related Print or Stream class
CMozziStream	Stream that provides audio information that was generated using the Mozzi API using the updateControl() and updateAudio() methods
CPDMMonoStreamT< T >	Applies low pass filter to a decimated pdm signal to convert it to pcm
CPipeline	We can build a input or an output chain: an input chain starts with setInput(); followed by add() an output chain consinsts of add() and ends with setOutput();
CPortAudioStream	Arduino Audio Stream using PortAudio
CPureDataStream	Input and output of Pure Data PD using code generated by the hvcc compiler. The audio format is defined by the sample rate in the Heavy constructor, the number of channels in the ADC and DAC and the bits_per_sample of 16. Therefore the audio format can not be changed dynamically. I recommend to make sure that the input format and output format is consistent, otherwise you need to change the format in PD
CRingBufferStream	An AudioStream backed by a Ringbuffer. We can write to the end and read from the beginning of the stream
CSPDIFOutput	Output as 16 bit stereo SPDIF on the I2S data output pin
►CTfLiteAudioStreamBase	Astract TfLiteAudioStream to provide access to TfLiteAudioStream for Reader and Writers
CTfLiteAudioStream	TfLiteAudioStream which uses Tensorflow Light to analyze the data. If it is used as a generator (where we read audio data)
CVBANStream	VBAN Audio Source and Sink for the ESP32. For further details please see https://vb-audio.com/Voicemeeter/vban.htm . Inspired by https://github.com/rkinnett/ESP32-VBAN-Audio-Source/tree/master and https://github.com/rkinnett/ESP32-VBAN-Network-Audio-Player
CVS1053Stream	VS1053 Output Interface which processes PCM data by default. If you want to write encoded data set is_encoded_data = true in the configuration;
CWM8960Stream	Stream for reading and writing audio data using the WM8960 Codec Chip You need to install https://github.com/pschatzmann/arduino-wm8960
►CStreamingDecoder	A Streaming Decoder where we provide both the input and output as streams
CFLACDecoder	Decoder for FLAC. Depends on https://github.com/pschatzmann/arduino-libflac. We support an efficient streaming API and an very memory intensitiv standard interface. So you should prefer the streaming interface where you call setOutput() before the begin and copy() in the loop. Validated with http://www.2l.no/hires/
CStreamingDecoderAdapter	Converts any AudioDecoder to a StreamingDecoder
CVorbisDecoder	Vorbis Streaming Decoder using https://github.com/pschatzmann/arduino-libvorbis-tremor
►CAudioInfoSupport	Supports changes to the sampling rate, bits and channels
CAudioOutput	Abstract Audio Ouptut class
CAudioPlayer	Implements a simple audio player which supports the following commands:
CAudioStream	Base class for all Audio Streams. It support the boolean operator to test if the object is ready with data
►CAudioWriter	E.g. used by Encoders and Decoders
CAudioDecoder	Docoding of encoded audio into PCM data
►CAudioEncoder	Encoding of PCM data
CAACEncoderFDK	Encodes PCM data to the AAC format and writes the result to a stream This is basically just a wrapper using https://github.com/pschatzmann/arduino-fdk-aac
CADPCMEncoderXQ	Encoder for ADPCM-XQ - Depends on https://github.com/pschatzmann/arduino-adpcm-xq
CAPTXEncoder	Encoder for OpenAptx - Depends on https://github.com/pschatzmann/libopenaptx
►CAudioEncoderExt
CADPCMEncoder	Encoder for ADPCM - Depends on https://github.com/pschatzmann/adpcm
CBinaryContainerEncoder	Wraps the encoded data into Config, Data, and Meta segments so that we can recover the audio configuration and orignial segments if this is relevant. We assume that a full segment is written with each call of write(); The segments are separated with a new line character
CCodec2Encoder	Encoder for Codec2 - Depends on https://github.com/pschatzmann/arduino-libcodec2
CCodecNOP	Dummy no implmentation Codec. This is used so that we can initialize some pointers to decoders and encoders to make sure that they do not point to null
CCopyEncoder	Dummy Encoder which just copies the provided data to the output
CEncoderBase64	EncoderBase64s - Encodes the input data into a Base64 string. By default each audio frame is followed by a new line, so that we can easily resynchronize the reading of a data stream. The generation of the new line can be configured with the setNewLine() method
CEncoderBasic	EncoderBasic - supports mime type audio/basic. The content of the "audio/basic" subtype is single channel audio encoded using 8bit ISDN mu-law [PCM] at a sample rate of 8000 Hz. Requires https://github.com/pschatzmann/arduino-libg7xx
CEncoderFloat	EncoderFloats - Encodes 16 bit PCM data stream to floats data
CEncoderL16	EncoderL16s - Condenses 16 bit PCM data stream to 8 bits data. Most microcontrollers can not process 8 bit audio data directly. 8 bit data however is very memory efficient and helps if you need to store audio on constrained resources. This encoder translates 16bit data into 8bit data
CEncoderL8	EncoderL8s - Condenses 16 bit PCM data stream to 8 bits data. Most microcontrollers can not process 8 bit audio data directly. 8 bit data however is very memory efficient and helps if you need to store audio on constrained resources. This encoder translates 16bit data into 8bit data. By default the encoded data is represented as uint8_t, so the values are from 0 to 255
CFLACEncoder	FLACEncoder
CG722Encoder	Encoder for G.722 - Depends on https://github.com/pschatzmann/arduino-libg722. Inspired by g722enc.c
►CG7xxEncoder	G723_24, g721, g723_40 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
►CG711Encoder	64 kbit/s g711 ULOW Encoder based on https://github.com/pschatzmann/arduino-libg7xx Supported encoder parameters: linear2alaw2, linear2ulaw
CG711_ALAWEncoder	64 kbit/s g711 ALOW Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG711_ULAWEncoder	64 kbit/s g711 ULOW Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG721Encoder	32Kbps G721 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_24Encoder	24Kbps G723 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_40Encoder	40Kbps G723 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CGGWaveEncoder	GGWaveEncoder: Translates text into audio Codec using https://github.com/ggerganov/ggwave-arduino
CGSMEncoder	Encoder for GSM - Depends on https://github.com/pschatzmann/arduino-libgsm. Inspired by gsmenc.c
CILBCEncoder	Encoder for iLBC - Depends on https://github.com/pschatzmann/libopenilbc
CLC3Encoder	Encoder for LC3 - Depends on https://github.com/pschatzmann/arduino-liblc3
CMP3EncoderLAME	Encodes PCM data to the MP3 format and writes the result to a stream This is basically just a wrapper using https://github.com/pschatzmann/arduino-liblame
►COggContainerEncoder	Encoder for Ogg Container. Encodes a packet for an Ogg container. The Ogg begin segment contains the AudioInfo structure. You can subclass ond overwrite the writeHeader() method to implement your own header logic. When an optional encoder is specified in the constructor we package the encoded data. Dependency: https://github.com/pschatzmann/arduino-libopus
COpusOggEncoder	Opus Encoder which uses the Ogg Container: see https://datatracker.ietf.org/doc/html/rfc7845 Dependency: https://github.com/pschatzmann/arduino-libopus
COpusAudioEncoder	OpusAudioEncoder: Dependens on https://github.com/pschatzmann/arduino-libopus.git
CSBCEncoder	Encoder for SBC - Depends on https://github.com/pschatzmann/arduino-libsbc. Inspired by sbcenc.c
CWAVEncoder	A simple WAV file encoder. If no AudioEncoderExt is specified the WAV file contains PCM data, otherwise it is encoded as ADPCM. The WAV header is written with the first writing of audio data. Calling begin() is making sure that the header is written again
►CAudioServerT< Client, Server >	A simple Arduino Webserver which streams the result This class is based on the WiFiServer class. All you need to do is to provide the data with a callback method or from an Arduino Stream: in -copy> client
►CAudioEncoderServer	A simple Arduino Webserver which streams the audio using the indicated encoder.. This class is based on the WiFiServer class. All you need to do is to provide the data with a callback method or from a Stream
CAudioWAVServer	A simple Arduino Webserver which streams the audio as WAV data. This class is based on the AudioEncodedServer class. All you need to do is to provide the data with a callback method or from a Stream
►CAudioSource	Abstract Audio Data Source for the AudioPlayer which is used by the Audio Players
CAudioSourceCallback	Callback Audio Data Source which is used by the Audio Players
CAudioSourceIdxSDFAT	ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation For UTF8 Support change SdFatConfig.h #define USE_UTF8_LONG_NAMES 1
CAudioSourceIdxSDMMC	ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD_MMC implementation Connect the SD card to the following pins:
CAudioSourceLittleFS	ESP32 AudioSource for AudioPlayer using an the LittleFS file system
CAudioSourceSD	ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation Connect the SD card to the following pins:
CAudioSourceSDFAT	ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation Connect the SD card. For UTF8 Support change SdFatConfig.h #define USE_UTF8_LONG_NAMES 1
CAudioSourceSDFAT	ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation Connect the SD card. For UTF8 Support change SdFatConfig.h #define USE_UTF8_LONG_NAMES 1
CAudioSourceSDMMC	ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD_MMC implementation Connect the SD card to the following pins:
CAudioSourceSPIFFS	ESP32 AudioSource for AudioPlayer using an the SPIFFS file system
CAudioSourceSTD	AudioSource using the standard C++ api
►CAudioSourceURL	Audio Source which provides the data via the network from an URL
CAudioSourceDynamicURL	Audio Source which provides the data via the network from an URL. The URLs are stored in an Vector of dynamically allocated strings
CAudioTime	Tools for calculating timer values
CAVIMainHeader
CAVIStreamHeader
►CBaseBuffer< T >	Shared functionality of all buffers
CNBuffer< Frame >
CRingBuffer< int16_t >
CRingBuffer< Sample >
CRingBuffer< int32_t >
CRingBuffer< uint16_t >
CSingleBuffer< int16_t >
CVariableSpeedRingBuffer< int16_t >
CBufferRP2040T< T >	Buffer implementation which is based on a RP2040 queue. This class is intended to be used to exchange data between the 2 different cores. Multi-core and IRQ safe queue implementation!
CBufferRTOS< T >	Buffer implementation which is using a FreeRTOS StreamBuffer. The default allocator uses psram is available
►CNBuffer< T >	A lock free N buffer. If count=2 we create a DoubleBuffer, if count=3 a TripleBuffer etc
CSynchronizedNBufferRTOST< T >	NBuffer which uses some RTOS queues to manage the available and filled buffers
CRingBuffer< T >	Implements a typed Ringbuffer
CRingBufferFile< File, T >	An File backed Ring Buffer that we can use to receive streaming audio. We expect an open p_file as parameter
CSingleBuffer< T >	A simple Buffer implementation which just uses a (dynamically sized) array
CSynchronizedBuffer< T >	Wrapper class that can turn any Buffer into a thread save implementation
CVariableSpeedRingBuffer< T >	Optimized Buffer implementation for Pitch Shift. We try to interpolate the samples and restore the phase when the read pointer and write pointer overtake each other
CVariableSpeedRingBuffer180< T >	Varialbe speed ring buffer where we read with 0 and 180 degree and blend the result to prevent overrun artifacts. See https://github.com/YetAnotherElectronicsChannel/STM32_DSP_PitchShift
CVariableSpeedRingBufferSimple< T >	Very Simple Buffer implementation for Pitch Shift. We write in constant speed, but reading can be done in a variable speed. We will hear some noise when the buffer read and write pointers overrun each other
►CBaseBuffer< uint8_t >
CBufferRTOS< uint8_t >
CNBuffer< uint8_t >
CRingBuffer< uint8_t >
CSingleBuffer< uint8_t >
►CBaseConverter	Abstract Base class for Converters A converter is processing the data in the indicated array
CConverterNChannels< T, TF >
CBin	Provides reduced sampling rates through binning
CBinT< T >
CCallbackConverterT< T >	You can provide a lambda expression to conver the data
CChannelAvg
CChannelAvgT< T >	We average pairs of channels in a datastream. E.g. if we have 4 channels we end up with 2 channels. The channels will be (channel_1 + channel_2)/2 (channel_3 - channel_4)/2. This is equivalent of stereo to mono conversion but will also work for quadric, sexic or octic audio. This will not work if you provide single channel data!
CChannelBinDiff	Provides combination of binning and subtracting channels
CChannelBinDiffT< T >	We first bin the channels then we calculate the difference between pairs of channels in a datastream. E.g. For binning, if we bin 4 samples in each channel we will have 4 times less samples per channel E.g. For subtracting if we have 4 channels we end up with 2 channels. The channels will be channel_1 - channel_2 channel_3 - channel_4 This is the same as combining binning and subtracting channels. This will not work if you provide single channel data!
CChannelDiff
CChannelDiffT< T >	We calculate the difference between pairs of channels in a datastream. E.g. if we have 4 channels we end up with 2 channels. The channels will be channel_1 - channel_2 channel_3 - channel_4 This is similar to background subtraction between two channels but will also work for quadric, sexic or octic audio. This will not work if you provide single channel data!
CChannelReducer	We combine a datastream which consists of multiple channels into less channels. E.g. 2 to 1 The last target channel will contain the combined values of the exceeding source channels
CChannelReducerT< T >	We combine a datastream which consists of multiple channels into less channels. E.g. 2 to 1 The last target channel will contain the combined values of the exceeding source channels
CConverter1Channel< T >	Converter for 1 Channel which applies the indicated Filter
CConverterAutoCenter	Makes sure that the avg of the signal is set to 0
CConverterAutoCenterT< T >	Makes sure that the avg of the signal is set to 0
CConverterFillLeftAndRight< T >	Make sure that both channels contain any data
CConverterNChannels< T, FT >	Converter for n Channels which applies the indicated Filter
CConverterScaler< T >	Multiplies the values with the indicated factor adds the offset and clips at maxValue. To mute use a factor of 0.0!
CConverterSwitchLeftAndRight< T >	Switches the left and right channel
CConverterToInternalDACFormat< T >	Special case for internal DAC output, the incomming PCM buffer needs to be converted from signed 16bit to unsigned
CCopyChannels< T, Cn, Cx, S >	Copy channel Cx value of type T shifted by S bits to all Cn channels
CDecimate	Provides a reduced sampling rate by taking a sample at every factor location (ingoring factor-1 samples)
CDecimateT< T >	Provides reduced sampling rates
CFadeConverter< T >	Converter which does a fade out or fade in
CMultiConverter< T >	Combines multiple converters
CNOPConverter	Dummy converter which does nothing
CPoppingSoundRemover< T >	Big value gaps (at the beginning and the end of a recording) can lead to some popping sounds. We will try to set the values to 0 until the first transition thru 0 of the audio curve
CSilenceRemovalConverter< T >	Removes any silence from the buffer that is longer then n samples with a amplitude below the indicated threshhold. If you process multiple channels you need to multiply the channels with the number of samples to indicate n
CSmoothTransition< T >	Changes the samples at the beginning or at the end to slowly ramp up the volume
CBitmapInfoHeader
►CBLEAdvertisedDeviceCallbacks
CAudioBLEClient	A simple BLE client that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminology this is a Central
►CBLECharacteristicCallbacks
CAudioBLEServer	A simple BLE server that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminologiy this is a Peripheral. This implementation uses the ArduinoBLE library! This is working only correctly if the client sets the max MTU to a value >= 256. Otherwise some of the transmitted information gets silently dropped
►CBLEClientCallbacks
CAudioBLEClient	A simple BLE client that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminology this is a Central
►CBLEServerCallbacks
CAudioBLEServer	A simple BLE server that implements the serial protocol, so that it can be used to send and recevie audio. In BLE terminologiy this is a Peripheral. This implementation uses the ArduinoBLE library! This is working only correctly if the client sets the max MTU to a value >= 256. Otherwise some of the transmitted information gets silently dropped
CBufferedArray< T >	Class which is usfull ot provide incremental data access e.g. for EdgeImpulse which request data with an offset and length starting from 0 up to the buffer length, restarting at 0 again
CByteBuffer	A resizable buffer of bytes which manages the available bytes
CChannelConverter< T >	Increasing or decreasing the number of channels
CChannelEnhancer< T >	Increases the channel count
CChannelSplitOutput::ChannelSelectionOutputDef
CChannelsSelectOutput::ChannelSelectionOutputDef
CChartT< T >	Displays audio in a Jupyter as chart Just wrapps a stream to provide the chart data
►CChorus
CSTKChorus	Chorus Effect
CCommonHeader
►CContainerTarget	ContainerTarget: forwards requests to both the output and the encoder/decoder and sets up the output chain for Containers. We also manage the proper sequence of the output classes
CContainerTargetPrint
CDACOut	Output method for DeltaSigma DAC
CDataNode
CDebouncer	Helper class to debounce user input from a push button
►CDelayEffectBase	A Base class for delay based digital effects. Provides the basic methods that are shared amongst Flanger, Delay, Chorus and Phaser
CFilteredDelay	Delay effect that filters the repeat delay
CSimpleChorus	Simple Chorus effect with a single delay voice and mono output Chorus is effective between 15 and 20 miliseconds delay of original audio. Requires the sample rate when initialising
CSimpleDelay	Simple Delay effect consiting of a single tap delay with Effect Gain and feed back controls Constructor requires internal delay in samples
CSimpleFlanger	Simple Flanger Effect Consistig of a single voice flanger The flanger has an effective range between 0 and 15 miliseconds in this case dleay buffer should be set to sampleRate*3/200 Constructor requires internal delay in samples
►CI2SDriverESP32V1::DriverCommon
CI2SDriverESP32V1::DriverI2S
►CDriverPWMBase	Base Class for all PWM drivers
CPWMDriverAVR	Experimental: Audio output to PWM pins for the AVR. The AVR supports only up to 2 channels
CPWMDriverESP32	Audio output to PWM pins for the ESP32. The ESP32 supports up to 16 channels
CPWMDriverMBED	Audio output to PWM pins for MBED based Arduino implementations
CPWMDriverRenesas	Audio output to PWM pins for Renesas based Arduino implementations
CPWMDriverSTM32	Audio output to PWM pins for STM32. We use one timer to generate the sample rate and one timer for the PWM signal
Cdsp	Minimal dsp base class needed by Faust
Cdsp_memory_manager	Memory manager which uses psram when it is available
CDynArray< T >
CDynArray< DataType >
CDynArray< ffft::OscSinCos >
CDynArray< long >
►CEcho
CSTKEcho	Echo Effect
CEquilizer3Bands::EQSTATE
CESPNowStreamConfig	Configuration for ESP-NOW protocolö.W
CFade	Fade In and Fade out in order to prevent popping sound when the audio is started or stopped. The fade in/out is performed over the length of the buffer
CUSBDeviceAudioAPI::audiod_function_t::feedback
CFFTBin	And individual FFT Bin
CFFTDisplay
►CFFTDriver	Abstract Class which defines the basic FFT functionality
CFFTDriverCmsisFFT	Driver for Cmsis-FFT see https://arm-software.github.io/CMSIS_5/DSP
CFFTDriverESP32FFT	Driver for ESP32-FFT https://github.com/pschatzmann/esp32-fft
CFFTDriverEspressifFFT	Fft Driver for espressif dsp library: https://espressif-docs.readthedocs-hosted.com/projects/esp-dsp/en/latest/esp-dsp-apis.html
CFFTDriverKissFFT	Driver for RealFFT
CFFTDriverRealFFT	Driver for RealFFT
CFFTReal< DT >
CFFTReal< float >
CFFTRealFixLen< LL2 >
CFFTRealFixLenParam
CFFTRealPassDirect< PASS >
CFFTRealPassInverse< PASS >
CFFTRealSelect< P >
CFFTRealUseTrigo< ALGO >
CAnalogDriverESP32V1::FIFO< T >	Custom FIFO class
CAnalogDriverESP32V1::FIFO< ADC_DATA_TYPE >
►CFilter< T >	Abstract filter interface definition;
CFIR< float >
CBiQuadDF1< T >	Biquad DF1 Filter. converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
►CBiQuadDF2< T >	Biquad DF2 Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CBandPassFilter< T >	Biquad DF2 Band Pass Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CHighPassFilter< T >	Biquad DF2 High Pass Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CHighShelfFilter< T >	Biquad DF2 High Shelf Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CLowPassFilter< T >	Biquad DF2 Low Pass Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CLowShelfFilter< T >	Biquad DF2 Low Shelf Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CNotchFilter< T >	Biquad DF2 Notch Filter. When dealing with high-order IIR filters, they can get unstable. To prevent this, BiQuadratic filters (second order) are used. Converted from https://github.com/tttapa/Filters/blob/master/src/BiQuad.h Use float or double (and not a integer type) as type parameter
CFIR< T >	FIR Filter Converted from https://github.com/sebnil/FIR-filter-Arduino-Library/tree/master/src You can use https://www.arc.id.au/FilterDesign.html to design the filter
CFilterChain< T, N >	FilterChain - A Cascade of multiple filters
CIIR< T >	IIRFilter Converted from https://github.com/tttapa/Filters/blob/master/src/IIRFilter.h
CMedianFilter< T >	An embedded friendly, fast one-dimensional median filter algorithm implementation in C and C++ Useful for spike and noise removal from analog signals or other DSP Also known as "salt-and-pepper noise" or "impulse noise" filter
CNoFilter< T >	No change to the input
CSOSFilter< T, N >	Second Order Filter: Instead of manually cascading BiQuad filters, you can use a Second Order Sections filter (SOS). converted from https://github.com/tttapa/Filters/blob/master/src/SOSFilter.h Use float or float (and not a integer type) as type parameter
CFilter< FT >
Cfloat16	Stores float values with 2 bytes
Cfloat32	Stores float values as uint32_t so that we can use memory allocated with MALLOC_CAP_32BIT
CFloatAudio
►CFreeVerb
CSTKFreeVerb	Jezar at Dreampoint's FreeVerb, implemented in STK
CFS	Eumlate FS using C++ or Posix functions
CHLSParser	Simple Parser for HLS data. We select the entry with min bandwidth
►CHttpHeader	In a http request and reply we need to process header information. With this API we can define and query the header information. The individual header lines are stored in a vector. This is the common functionality for the HttpRequest and HttpReplyHeader subclasses
CHttpReplyHeader	Reading and Writing of Http Replys
CHttpRequestHeader	Reading and writing of Http Requests
CHttpHeaderLine	A individual key - value header line
►CHttpLineReader	We read a single line. A terminating 0 is added to the string to make it compliant for c string functions
CHttpChunkReader	Http might reply with chunks. So we need to dechunk the data. see https://en.wikipedia.org/wiki/Chunked_transfer_encoding
CI2SDriverESP32	Basic I2S API - for the ESP32. If we receive 1 channel, we expand the result to 2 channels
CI2SDriverESP32V1	Basic I2S API for the ESP32 (using the new API). https://docs.espressif.com/projects/esp-idf/en/v5.0.1/esp32/api-reference/peripherals/i2s.html#i2s-communication-mode
CI2SDriverESP8266	Basic I2S API - for the ESP8266 Only 16 bits are supported !
CI2SDriverNanoBLE	Basic I2S API - for the Arduino Nano BLE Sense See https://content.arduino.cc/assets/Nano_BLE_MCU-nRF52840_PS_v1.1.pdf Douplex mode (RXTX_MODE) is currently not supported, but it should be quite easy to implement
CI2SDriverSAMD	Basic I2S API - for the SAMD
►CIAudioSource
CRTSPSourceFromAudioStream	Simple Facade which can turn AudioStream into a IAudioSource. This way we can e.g. use an I2SStream as source to stream data Depends on the https://github.com/pschatzmann/Micro-RTSP-Audio/ library
CRTSPSourceStream	Simple Facade which can turn any Stream into a IAudioSource. This way we can e.g. use an I2SStream as source to stream data Depends on the https://github.com/pschatzmann/Micro-RTSP-Audio/ library
CICYUrlSetup	Resolve icy-metaint from HttpRequest and execute metadata callbacks
CID3v1
CID3v1Enhanced
CID3v2
CMetaDataFilter::ID3v2	ID3 verion 2 TAG Header (10 bytes)
CID3v2Frame
CID3v2FrameString
CIMAState
Cint24_3bytes_t	24bit integer which is used for I2S sound processing. The values are really using 3 bytes. It works only on little endian machines!
Cint24_4bytes_t	24bit integer which is used for I2S sound processing. The values are represented as int32_t, but only 3 bytes are used. If you assign values which are too big, they are clipped
CList< T >::Iterator
CVector< T >::iterator	Iterator for the Vector class
►CJCRev
CSTKChowningReverb	John Chowning's reverberator class
CSynthesizer::KeyParameter
CLastSampleFader	If we end audio and the last sample is not close to 0 we can hear a popping noise. This functionality brings the last value slowly to 0. Typless implementation
CLastSampleFaderT< T >	If we end audio and the last sample is not close to 0 we can hear a popping noise. This functionality brings the last value slowly to 0
CLastSampleFaderT< audio_tools::int24_4bytes_t >
CLastSampleFaderT< int16_t >
CLastSampleFaderT< int32_t >
CLEDOutput	LED output using the FastLED library
CLEDOutputConfig
CLEDOutputUnoR4	LED output using the R4 LED matrix library
CLEDOutputUnoR4Config
►CLentPitShift
CSTKLentPitShift	Pitch shifter effect class based on the Lent algorithm
CList< T >	Double linked list
CList< audio_tools::DataNode * >
CList< audio_tools::HttpHeaderLine * >
CList< String >
CLock	A simple RIA locking class for the ESP32 using _lock_t
CLockGuard	RAII implementaion using a Mutex: Only a few microcontrollers provide lock guards, so I decided to roll my own solution where we can just use a dummy Mutex implementation that does nothing for the cases where this is not needed
CMedianFilter< T >::MedianFilter_t
CMedianFilter< T >::MedianNode_t
►CMediaSink
COurSink
CMemoryManager	MemoryManager which activates the use of external SPIRAM memory. When external memory is in use, the allocation strategy is to initially try to satisfy smaller allocation requests with internal memory and larger requests with external memory. This sets the limit between the two, as well as generally enabling allocation in external memory
CMeta	Minimial implementtion of Meta which just ignores the data
►CMetaDataID3Base	ID3 Meta Data Common Functionality
CMetaDataID3V1	Simple ID3 Meta Data API which supports ID3 V1
CMetaDataID3V2	Simple ID3 Meta Data API which supports ID3 V2: We only support the "TALB", "TOPE", "TIT2", "TCON" tags
►CModulationBaseClass	Class provides a wave table that can be populated with a number of preallocated waveforms. These can be used to generate audio in themselves or to modulate The parameters of another effect. Class initialised with sample rate
CSimpleChorus	Simple Chorus effect with a single delay voice and mono output Chorus is effective between 15 and 20 miliseconds delay of original audio. Requires the sample rate when initialising
CMP4Atom	Represents a single MPEG4 atom
CMP4ParseBuffer
CMusicalNotes	Determination of the frequency of a music note
►CMutexBase	Empty Mutex implementation which does nothing
CMutexRP2040	Mutex API for non IRQ mutual exclusion between cores. Mutexes are application level locks usually used protecting data structures that might be used by multiple threads of execution. Unlike critical sections, the mutex protected code is not necessarily required/expected to complete quickly, as no other sytem wide locks are held on account of an acquired mutex
CMutexRTOS	Mutex implemntation using FreeRTOS
CNoInterruptHandler	Disable, enable interrupts (only on the actual core)
CSpinLock
CNano_BLE_freq_info	Mapping Frequency constants to available frequencies
CNano_BLE_ratio_info	Mapping from Ratio Constants to frequency ratios
CList< T >::Node
CQueueLockFree< T >::Node
►CNRev
CSTKNReverb	CCRMA's NRev reverberator class
CNumberConverter	Converts from a source to a target number with a different type
CNumberReader	Reads n numbers from an Arduino Stream
COscSinCos< T >
CParseBuffer	We try to keep the necessary buffer for parsing as small as possible, The data() method provides the start of the actual data and with consume we remove the processed data from the buffer to make space again
CParseObject
►CPCMInfo
CRTSPOutputPCMInfo	PCMInfo subclass which provides the audio information from the related AudioStream Depends on the https://github.com/pschatzmann/Micro-RTSP-Audio/ library
CRTSPPCMAudioInfo	PCMInfo subclass which provides the audio information from the AudioInfo parameter
CMTSDecoder1::pid_array
CPIDController	A simple header only PID Controller
CPinInfoESP32	Information for a PIN
►CPitShift
CSTKPitShift	Simple Pitch shifter effect class: This class implements a simple pitch shifter using a delay line
CPoly
►CPRCRev
CSTKPerryReverb	Perry's simple reverberator class
►CPrint
CAudioOutput	Abstract Audio Ouptut class
CFileOutput	Simple layer for Print object to write to a c++ file
COutputMixer< T >	Mixing of multiple outputs to one final output
►CStream
►CBaseStream	Base class for all Streams. It relies on write(const uint8_t *buffer, size_t size) and readBytes(uint8_t *buffer, size_t length)
►CFileLoopT< File >
CFileLoop	A simple class which implements a automatic looping file. The file needs to be of the class File from FS.h. The number of loops can be defined by calling setLoopCount(). You can also optinally limit the total looping file size by calling setSize();
CQueueStream< uint8_t >
CAudioStream	Base class for all Audio Streams. It support the boolean operator to test if the object is ready with data
CCatStream	Provides data from a concatenation of Streams. Please note that the provided Streams can be played only once! You will need to reset them (e.g. moving the file pointer to the beginning) and readd them back if you want to process them a second time. The default timeout on the available() method is set to 0. This might be not good if you use e.g. a URLStream
CDynamicMemoryStream	MemoryStream which is written and read using the internal RAM. For each write the data is allocated on the heap
CESPNowStream	ESPNow as Arduino Stream
CFileLoopT< FileType >	A simple class which implements a automatic looping file. In order to support different file implementation the file class is a template parameter. The number of loops can be defined by calling setLoopCount(). You can also optinally limit the total looping file size by calling setSize();
CHammingFEC< bytecount, block_t >	Hamming forware error correction. Inspired by https://github.com/nasserkessas/hamming-codes
CHttpRequest	Simple API to process get, put, post, del http requests I tried to use Arduino HttpClient, but I did not manage to extract the mime type from streaming get requests
CNullStream	The Arduino Stream which provides silence and simulates a null device when used as audio target or audio source
CQueueStream< T >	Stream class which stores the data in a temporary queue buffer. The queue can be consumed e.g. by a callback function by calling readBytes();
CReedSolomonFEC< bytecount, additional_bytes >	Forward error correction using Reed-Solomon: write is encoding and readBytes does the decoding
CStdioStream	Direct binary Audio Output to stdout. On linux you can hear the audio e.g. with ./generator | aplay -f cd or reading data from stdin
CUDPStream	A UDP class which makes sure that we can use UDP as AudioSource and AudioSink. By default the WiFiUDP object is used and we login to wifi if the ssid and password is provided and we are not already connected
CClient
CFile	Arduino File support using std::fstream
CHDLCStream	High-Level Data Link Control (HDLC) is a bit-oriented code-transparent synchronous data link layer protocol
CHardwareSerial
CReadioHeadStream	Arduino Stream which is using the RadioHead library to send and receive data. We use the river API directly
CPrintable
CQueue< T >	FIFO Queue which is based on a List
CQueueFromVector< T >	FIFO Queue which is based on a Vector
CQueueFromVector< audio_tools::BaseBuffer< T > * >
CQueueLockFree< T >	A simple single producer, single consumer lock free queue
CQueueRTOS< T >	FIFO Queue whch is based on the FreeRTOS queue API. The default allocator will allocate the memory from psram if available
CQueueRTOS< audio_tools::BaseBuffer< T > * >
►CR2RDriverBase	R2R driver base class
CR2RDriver	R2R driver which uses the Arduino API to setup and write to the digital pins
CMetaDataFilter::Range	Metadata range
CReasampleLinearInterpolation	Range 0:1
CRECT
CReedSolomon< msg_length, ecc_length >
CReedSolomon< bytecount, additional_bytes >
CResample2Point3Order
CResample4Point2Order
CResampleBSpline	Range -1:2
CResampleLagrange	Range -1 : 2
CResampleParabolic
CResmpleHermite
CTfLiteMicroSpeechRecognizeCommands::Result
►CRTSPClient
COurRTSPClient
►CRTSPFormat
►CRTSPFormatAudioTools	RTSPFormat which supports the AudioInfo class
CRTSPFormatAbtX	AbtX format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatG711	G711 μ-Law format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats Packet intervall: 20, frame size: any
CRTSPFormatGSM	GSM format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatOpus	Opus format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatPCM	PCM format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatPCM8	L8 format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CSDDirect< SDT, FileT >	We access the files directy with an index. The index is determined by a recurseve tree walk thru the directory. Unfortunatly the SDTFAT library has it's own API which is incompatible with the SD API
CSDDirect< AudioFs, AudioFile >
CSDDirect< fs::LittleFSFS, fs::File >
CSDDirect< fs::SDFS, fs::File >
CSDDirect< fs::SDMMCFS, fs::File >
CSDDirect< fs::SPIFFSFS, fs::File >
CSDIndex< SDT, FileT >	We store all the relevant file names in an sequential index file. Form there we can access them via an index
CSDIndex< AudioFs, AudioFile >
CSDIndex< fs::SDMMCFS, fs::File >
CSimpleContainerConfig
CSimpleContainerDataHeader
CSimpleContainerMetaDataHeader
CSlice< T >	Helps to split up a big memory array into smaller slices. There are no additinal heap allocations! Example: if we have an array with 9 entries (1,2,3,4,5,6,7,8,9): slices(5) gives 2. slice(5,0) returns size 5 with 1,2,3,4,5 and slice(5,1) returns size 4 with 6,7,8,9!
►CSoundGenerator< T >	Base class to define the abstract interface for the sound generating classes
CGeneratorFixedValue< T >	Just returns a constant value
CGeneratorFromArray< T >	We generate the samples from an array which is provided in the constructor
CGeneratorFromStream< T >	An Adapter Class which lets you use any Stream as a Generator
CGeneratorMixer< T >	Generator which combines (mixes) multiple sound generators into one output
CPinkNoiseGenerator< T >	Generates pink noise
CSTKGenerator< StkCls, T >	The Synthesis ToolKit in C++ (STK) is a set of open source audio signal processing and algorithmic synthesis classes written in the C++ programming language. You need to install https://github.com/pschatzmann/Arduino-STK
CSilenceGenerator< T >	Provides a fixed value (e.g. 0) as sound data. This can be used e.g. to test the output functionality which should optimally just output silence and no artifacts
CSineFromTable< T >	A sine generator based on a table. The table is created using degrees where one full wave is 360 degrees
►CSineWaveGenerator< T >	Generates a Sound with the help of sin() function. If you plan to change the amplitude or frequency (incrementally), I suggest to use SineFromTable instead
CFastSineGenerator< int16_t >
►CFastSineGenerator< T >	Sine wave which is based on a fast approximation function
CSquareWaveGenerator< T >	Generates a square wave sound
CSawToothGenerator< T >	SawToothGenerator
CSoundGeneratorModulation< T >	SoundGenerator using the ModulationBaseClass to generate the samples
CTestGenerator< T >	Generates a test signal which is easy to check because the values are incremented or decremented by 1
CWhiteNoiseGenerator< T >	Generates a random noise sound with the help of rand() function
►CSoundGenerator< effect_t >
CAudioEffects< GeneratorT >	OBSOLETE AudioEffects: the template class describes the input audio to which the effects are applied: e.g. SineWaveGenerator, SquareWaveGenerator, GeneratorFromStream etc. We support only one channel of int16_t data!
►CSoundGenerator< int16_t >
CSTKGenerator< StkCls, int16_t >
CSynthesizer	A simple Synthesizer which can generate sound having multiple keys pressed. The main purpose of this class is managing the synthezizer channels
CStack< T >	LIFO Stack which is based on a List
CStack< audio_tools::ParseObject >
CStreamClientState
CStreamCopyT< T >	Typed Stream Copy which supports the conversion from channel to 2 channels. We make sure that we allways copy full samples
CStreamCopyT< uint8_t >
►CStrView	A simple wrapper to provide string functions on existing allocated char*. If the underlying char* is a const we do not allow any updates; The ownership of the char* must be managed externally!
CStr	Str which keeps the data on the heap. We grow the allocated memory only if the copy source is not fitting
CSynchronizedQueue< T, TMutex >	FIFO Queue which is based on a List that is thread save
CSynthesizerKey	Arduino GPIO pin to note assossiation
CTask	FreeRTOS task
►CTfLiteAbstractRecognizeCommands	Base class for implementing different primitive decoding models on top of the instantaneous results from running an audio recognition model on a single window of samples
CTfLiteMicroSpeechRecognizeCommands	This class is designed to apply a very primitive decoding model on top of the instantaneous results from running an audio recognition model on a single window of samples. It applies smoothing over time so that noisy individual label scores are averaged, increasing the confidence that apparent matches are real. To use it, you should create a class object with the configuration you want, and then feed results from running a TensorFlow model into the processing method. The timestamp for each subsequent call should be increasing from the previous, since the class is designed to process a stream of data over time
CTfLiteConfig	Configuration settings for TfLiteAudioStream
CTfLiteQuantizer	Quantizer that helps to quantize and dequantize between float and int8
►CTfLiteReader	Input class which provides the next value if the TfLiteAudioStream is treated as an audio sourcce
CTfLiteSineReader	Generate a sine output from a model that was trained on the sine method. (=hello_world)
►CTfLiteWriter	Output class which interprets audio data if TfLiteAudioStream is treated as audio sink
CTfLiteMicroSpeachWriter	TfLiteMicroSpeachWriter for Audio Data
CTimerAlarmRepeating	Common Interface definition for TimerAlarmRepeating
►CTimerAlarmRepeatingDriverBase
CTimerAlarmRepeatingDriverAVR	Repeating Timer functions for repeated execution: Plaease use the typedef TimerAlarmRepeating
CTimerAlarmRepeatingDriverESP8266	Repeating Timer functions for repeated execution: Plaease use the typedef TimerAlarmRepeating
CTimerAlarmRepeatingDriverMBED	Repeating Timer functions for repeated execution: Plaease use the typedef TimerAlarmRepeating
CTimerAlarmRepeatingDriverRenesas	Repeating Timer functions for repeated execution: Plaease use the typedef TimerAlarmRepeating. By default we use a new GPT timer. You can also request 1 AGT timer by calling setTimer(1);
CTimerAlarmRepeatingDriverSTM32	STM32 Repeating Timer functions for repeated execution: Please use the typedef TimerAlarmRepeating. By default the TIM1 is used
CTransformationReader< T >	ConverterStream Helper class which implements the readBytes with the help of write
CTransformationReader< audio_tools::ReformatBaseStream >
CUI	Minimum implementation of UI parameters. We only support the setting and getting of values
CUrl	URL parser which breaks a full url string up into its individual parts
CURLHistory
►CURLLoaderHLSBase	Abstract API for URLLoaderHLS
CURLLoaderHLS
CURLLoaderHLSOutput	URLLoader which saves the HLS segments to the indicated output
►CUSBAudioCB
►CUSBDeviceAudio
CUSBDeviceAudioAdafruit
CUSBDeviceAudioESP32
CUSBAudioConfig	Configuration for TinyUSB Audio
CUSBConfigESP32
CUSBDeviceAudioAPI
CVBan
CVBanHeader
CVector< T >	Vector implementation which provides the most important methods as defined by std::vector. This class it is quite handy to have and most of the times quite better then dealing with raw c arrays
CVector< audio_tools::AbstractSynthesizerChannel * >
CVector< audio_tools::AllocSize >
CVector< audio_tools::AudioActions::Action * >
CVector< audio_tools::AudioEffect * >
CVector< audio_tools::AudioInfoSupport * >
CVector< audio_tools::AudioOutput * >
CVector< audio_tools::AVIStreamHeader >
CVector< audio_tools::BaseConverter * >
CVector< audio_tools::ChannelSplitOutput::ChannelSelectionOutputDef >
CVector< audio_tools::ChannelsSelectOutput::ChannelSelectionOutputDef >
CVector< audio_tools::int24_4bytes_t >
CVector< audio_tools::MedianFilter::MedianNode_t >
CVector< audio_tools::ModifyingStream * >
CVector< audio_tools::PinInfoESP32 >
CVector< audio_tools::QueueLockFree::Node >
CVector< audio_tools::RingBuffer< T > * >
CVector< audio_tools::SoundGenerator< T > * >
CVector< audio_tools::Str >
CVector< audio_tools::Stream * >
CVector< audio_tools::TfLiteMicroSpeechRecognizeCommands::Result >
CVector< bool >
CVector< char >
CVector< const char * >
CVector< CRGB >
CVector< effect_t >
CVector< Entry >
CVector< FLAC__int32 >
CVector< float >
CVector< ggwave_ProtocolId >
CVector< int >
CVector< int16_t >
CVector< int8_t >
CVector< mbed::PwmOut * >
CVector< mp3d_sample_t >
CVector< MTSStreamType >
CVector< PwmOut * >
CVector< PWMPin >
CVector< StreamContentType >
CVector< TSDPMTStreamType >
CVector< uint16_t >
CVector< uint8_t >
►CVideoAudioSync	Logic to Synchronize video and audio output: This is the minimum implementatin which actually does not synchronize, but directly processes the data. No additinal memory is used! Provide your own optimized platform specific implementation
CVideoAudioBufferedSync	Logic to Synchronize video and audio output: we use a buffer to store the audio and instead of delaying the frames with delay() we play audio. The bufferSize defines the audio buffer in bytes. The correctionMs is used to slow down or speed up the playback of the video to prevent any audio buffer underflows
►CVideoOutput	Abstract class for video playback. This class is used to assemble a complete video frame in memory
CJpegOpenCV	Display image with opencv to be used on the desktop
CJpegTFT	Display jpeg image using https://github.com/Bodmer/TFT_eSPI and https://github.com/Bodmer/JPEGDecoder
►CVolumeControl	Abstract class for handling of the linear input volume to determine the multiplication factor which should be applied to the audio signal
CCachedVolumeControl	In order to optimize the processing time we cache the last input & factor and recalculate the new factor only if the input has changed
CCallbackVolumeControl	Provide the volume function as callback method: This is easy to use e.g together with a lamda function!
CExponentialVolumeControl	Simple exponentional volume control using the formula pow(2.0, input) - 1.0;
CLinearVolumeControl	The simplest possible implementation of a VolumeControl: The input = output which describes a linear curve. You would use this implementation if you physically connect an audio pot!
CLogarithmicVolumeControl	Parametric Logarithmic volume control. Using the formula pow(b,input) * a - a, where b is b = pow(((1/ym)-1), 2) and a is a = 1.0 / (b - 1.0). The parameter ym is determining the steepness. See https://electronics.stackexchange.com/questions/304692/formula-for-logarithmic-audio-taper-pot
CSimulatedAudioPot	Simple simulated audio pot volume control inspired by https://eepower.com/resistor-guide/resistor-types/potentiometer-taper/# We split up the input/output curve into 2 linear pieces with a slow and a fast raising part. The slow raising part goes from (0,0) to (x,y). The fast raising part goes from (x,y) to (1,1)
►CVolumeSupport	Supports the setting and getting of the volume
CA2DPStream	Stream support for A2DP using https://github.com/pschatzmann/ESP32-A2DP: begin(TX_MODE) opens a a2dp_source and begin(RX_MODE) a a2dp_sink. The data is in int16_t with 2 channels at 44100 hertz. We support only one instance of the class! Please note that this is a conveniance class that supports the stream api, however this is rather inefficient, beause quite a big buffer needs to be allocated. It is recommended to use the API with the callbacks. Examples can be found in the a2dp examples directory starting with basic
CAudioPlayer	Implements a simple audio player which supports the following commands:
CBoost	Boost AudioEffect
CGeneratorFromStream< T >	An Adapter Class which lets you use any Stream as a Generator
CI2SCodecStream	I2S Stream which also sets up a codec chip and i2s
CMaximilian	AudioTools integration with Maximilian
CMozziStream	Stream that provides audio information that was generated using the Mozzi API using the updateControl() and updateAudio() methods
CVS1053Stream	VS1053 Output Interface which processes PCM data by default. If you want to write encoded data set is_encoded_data = true in the configuration;
CVolumeStream	Adjust the volume of the related input or output: To work properly the class needs to know the bits per sample and number of channels! AudioChanges are forwareded to the related Print or Stream class
CWAVFormatX
CWAVHeader	Parser for Wav header data for details see https://de.wikipedia.org/wiki/RIFF_WAVE
CWavIMAHeader
►CWindowFunction	FFT Window Function
CBlackman	Blackman FFT Window function
CBlackmanHarris	BlackmanHarris FFT Window function
CBlackmanNuttall	BlackmanNuttall FFT Window function
CBufferedWindow	Buffered window function, so that we do not need to re-calculate the values
CFlatTop	FlatTop FFT Window function
CHamming	Hamming FFT Window function
CHann	Hann FFT Window function
CNuttall	Nuttall FFT Window function
CRectange	Rectange FFT Window function
CTriangle	Triangle FFT Window function
CWelch	Welch FFT Window function