Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 123]

►Naudio_tools	Generic Implementation of sound input and output for desktop environments using portaudio
CA2DPConfig	Configuration for A2DPStream
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
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
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
CAbstractMetaData	Common Metadata methods
CAbstractParameter	Base class for all parameters
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
CAbstractURLStream	Abstract Base class for all URLStream implementations
CAdapterAudioOutputToAudioStream	Wrapper which converts a AudioStream to a AudioOutput
CAdapterAudioStreamToAudioOutput	Wrapper which converts a AudioStream to a AudioOutput
CAdapterPrintToAudioOutput	Wrapper which converts a Print to a AudioOutput
CADPCMDecoder	Decoder for ADPCM. Depends on https://github.com/pschatzmann/adpcm
CADPCMDecoderXQ	Decoder for ADPCM-XQ. Depends on https://github.com/pschatzmann/arduino-adpcm-xq
CADPCMEncoder	Encoder for ADPCM - Depends on https://github.com/pschatzmann/adpcm>
CADPCMEncoderXQ	Encoder for ADPCM-XQ - Depends on https://github.com/pschatzmann/arduino-adpcm-xq
CADSR	Generates ADSR values between 0.0 and 1.0
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]
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
►CADTSParser	Structure to hold ADTS header field values
CADTSHeader
CALACBinaryConfig	Magic Cookie
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
CAMRNBDecoder	AMR Narrowband Decoder See https://github.com/pschatzmann/codec-amr
CAMRNBEncoder	AMR NB Encoder See https://github.com/pschatzmann/codec-amr
CAMRWBDecoder	AMR Wideband Decoder See https://github.com/pschatzmann/codec-amr
CAMRWBEncoder	AMR Wideband Encoder See https://github.com/pschatzmann/codec-amr
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
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
CAnalogDriverArduino	Please use the AnalogAudioStream: Reading Analog Data using a timer and the Arduino analogRead() method and writing using analogWrite();
CAnalogDriverBase
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
CFIFO	Custom FIFO class
CIO16Bit
►CAnalogDriverESP32V2	AnalogAudioStream: A very fast DAC using DMA using the new dac_continuous API. This implementation assumes that the issue with the different number of samples per channel has been resolved! https://github.com/espressif/esp-idf/issues/12337
CIO16Bit
CAnalogDriverMBED	Please use AnalogAudioStream: A ADC and DAC API for the Arduino Giga
CAppropriateSumType	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 >
CAPTXDecoder	Decoder for OpenAptx. Depends on https://github.com/pschatzmann/libopenaptx
CAPTXEncoder	Encoder for OpenAptx - Depends on https://github.com/pschatzmann/libopenaptx
►CAudioActions	A simple class to assign functions to gpio pins e.g. to implement a simple navigation control or volume control with buttons
CAction
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
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
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
CAudioClientRTSP	A simple RTSPClient using https://github.com/pschatzmann/arduino-live555
CAudioCmsisFFT	AudioFFT for ARM processors that provided Cmsis DSP
CAudioConfirmDataToReceive	Protocol Record for Request
CAudioDataBegin	Protocal Record To Start
CAudioDataEnd	Protocol Record for End
CAudioDecoder	Decoding of encoded audio into PCM data
CAudioDecoderExt
CAudioEffect	Abstract Base class for Sound Effects
CAudioEffectCommon
CAudioEffects	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!
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	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>;
CAudioEncoder	Encoding of PCM data
CAudioEncoderExt
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
CAudioESP32FFT	AudioFFT using https://github.com/pschatzmann/esp32-fft
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
CAudioEspressifFFT	AudioFFT using FFTReal. The only specific functionality is the access to the dataArray
CAudioFFTBase	Executes FFT using audio data privded by write() and/or an inverse FFT where the samples are made available via readBytes(). The Driver which is passed in the constructor selects a specifc FFT implementation
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
CAudioFFTResult	Result of the FFT
CAudioHeader	Common Header for all records
CAudioInfo	Basic Audio information which drives e.g. I2S
CAudioInfoLAME	LAME parameters
CAudioInfoSource	Supports the subscription to audio change notifications
CAudioInfoSupport	Supports changes to the sampling rate, bits and channels
CAudioKissFFT	AudioFFT using FFTReal. The only specific functionality is the access to the dataArray
CAudioKitStream	AudioKit Stream which uses the https://github.com/pschatzmann/arduino-audiokit library
CAudioKitStreamConfig	Configuration for AudioKitStream: we use as subclass of I2SConfig
CAudioLoRa	LoRa Audio Sending and Receiving
CAudioLoRaConfig	LoRa Audio Configuration with default values maximised for speed
CAudioMP34DT05	MP34DT05 Microphone of Nano BLE Sense. We provide a proper Stream implementation. See https://github.com/arduino/ArduinoCore-nRF528x-mbedos
CAudioMP34DT05Config	Config for MP34DT05 Microphone. Supported sample rates 16000, 41667, Supported bits_per_sample only 16
CAudioOutput	Abstract Audio Ouptut class
CAudioOutputAdapter	Base class for Output Adpapters
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
CAudioPlayer	Implements a simple audio player which supports the following commands:
CAudioPlayerProtocol
CAudioPlayerProtocolServer
CAudioRealFFT	AudioFFT using RealFFT
CAudioSendData	Protocol Record for Data
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
CAudioServerExConfig	Config information for AudioServerEx
CAudioServerT	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
CAudioSource	Abstract Audio Data Source for the AudioPlayer which is used by the Audio Players
CAudioSourceArray	Audio Data Source managing a static array of file names (const char*). Designed for PROGMEM storage on Arduino platforms with static file lists. This class is a template to support multiple SD libraries and other Streams
CAudioSourceCallback	Callback Audio Data Source which is used by the Audio Players
CAudioSourceDynamicURL	Audio Source which provides the data via the network from an URL. The URLs are stored in an Vector of dynamically allocated strings
CAudioSourceFTP	An AudioSource that uses the https://github.com/pschatzmann/TinyFTPClient library to retrieve files from a FTP Server. You need to provide an FTPClient object to the constructor and make sure that you open it before you access the files. The storage of the expanded file names is done on the heap, so in order to limit the requested memory we can limit the number of files
CAudioSourceIdxSD	ESP32 AudioSource for AudioPlayer using an SD card as data source. An index file is used to speed up the access to the audio files by index. This class is based on the Arduino SD implementation Connect the SD card to the following pins:
CAudioSourceIdxSDFAT	ESP32 AudioSource for AudioPlayer using an SD card as data source. An index file is used to speed up the access to the audio files by index. 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. An index file is used to speed up the access to the audio files by index. 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
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
CAudioSourceVector	Flexible Audio Data Source using a Vector of (file) names with minimal RAM usage. Files are stored with separated path index and name to minimize memory consumption. Identical paths are stored only once in a shared path registry. This class is a template to support multiple SD libraries and other Streams
CAudioSourceVFS	AudioSource using the standard C++ api. In order to make this work you need to configure and provide a VFS object!
CAudioStream	Base class for all Audio Streams. It support the boolean operator to test if the object is ready with data
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!
CAudioSyncWriter	Audio Writer which is synchronizing the amount of data that can be processed with the AudioReceiver
CAudioTime	Tools for calculating timer values
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
CAudioWAVServerEx	A powerfull WAV Web server which is based on https://github.com/pschatzmann/TinyHttp. It supports multiple concurrent clients
CAudioWriter	E.g. used by Encoders and Decoders
CAudioWriterToAudioOutput	Adapter class which lets an AudioWriter behave like a Print
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
CAVIMainHeader
CAVIStreamHeader
CBandPassFilter	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
CBaseBuffer	Shared functionality of all buffers
CBaseConverter	Abstract Base class for Converters A converter is processing the data in the indicated array
CBaseInterpolator	Base class for resampling algorithms using a buffer of float values
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)
CBin	Provides reduced sampling rates through binning
CBinaryContainerDecoder	Decodes the provided data from the DAT and CFG segments
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
CBinT
CBiQuadDF1	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	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
CBitmapInfoHeader
CBlackman	Blackman FFT Window function
CBlackmanHarris	BlackmanHarris FFT Window function
CBlackmanNuttall	BlackmanNuttall FFT Window function
CBoost	Boost AudioEffect
CBSplineInterpolator	Cubic B-spline interpolation using y[0]..y[3]
CBufferedArray	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
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
CBufferedTaskStream	A FreeRTOS task is filling the buffer from the indicated stream. Only to be used on the ESP32
CBufferedWindow	Buffered window function, so that we do not need to re-calculate the values
CBufferRP2040T	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	Buffer implementation which is using a FreeRTOS StreamBuffer. The default allocator uses psram is available
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
CCallbackConverterT	You can provide a lambda expression to convert the data
CCallbackStream	CallbackStream: A Stream that allows to register callback methods for accessing and providing data. The callbacks can be lambda expressions. Warning: this class does not propagate audio info changes to the target stream. You need to do this manually
CCallbackVolumeControl	Provide the volume function as callback method: This is easy to use e.g together with a lamda function!
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 read 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 too small if you use e.g. a URLStream
CChannelAvg
CChannelAvgT	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	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!
CChannelConverter	Increasing or decreasing the number of channels
CChannelDiff
CChannelDiffT	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!
CChannelEnhancer	Increases the channel count
CChannelFormatConverterStream	Channel converter which does not use a template
CChannelFormatConverterStreamT	Converter for reducing or increasing the number of Channels
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	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
►CChannelSplitOutput	Simple functionality to extract mono streams from a multichannel (e.g. stereo) signal
CChannelSelectionOutputDef
►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
CChannelSelectionOutputDef
CChartT	Displays audio in a Jupyter as chart Just wrapps a stream to provide the chart data
CClient
CCodec2Decoder	Decoder for Codec2. Depends on https://github.com/pschatzmann/arduino-libcodec2
CCodec2Encoder	Encoder for Codec2 - Depends on https://github.com/pschatzmann/arduino-libcodec2
CCodecChain	CodecChain - allows to chain multiple decoders and encoders together
►CCodecFactory	Factory for creating new decoders based on the mime type or id
CDecoderFactoryLine
CEncoderFactoryLine
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
CCommonHeader
CCompressor	Compressor inspired by https://github.com/YetAnotherElectronicsChannel/STM32_DSP_COMPRESSOR/blob/master/code/Src/main.c
CConfigEqualizer3Bands	Configuration for 3 Band Equalizer
CContainerDecoder	Parent class for all container formats
CContainerM4A	M4A Demuxer that extracts audio from M4A/MP4 containers. The audio is decoded into pcm with the help of the provided decoder. format
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
CConverter1Channel	Converter for 1 Channel which applies the indicated Filter
CConverterAutoCenter	Makes sure that the avg of the signal is set to 0
CConverterAutoCenterT	Makes sure that the avg of the signal is set to 0
CConverterFillLeftAndRight	Make sure that both channels contain any data
CConverterNChannels	Converter for n Channels which applies the indicated Filter
CConverterScaler	Multiplies the values with the indicated factor adds the offset and clips at maxValue. To mute use a factor of 0.0!
CConverterStream	Both the data of the read or write operations will be converted with the help of the indicated converter
CConverterSwitchLeftAndRight	Switches the left and right channel
CConverterToInternalDACFormat	Special case for internal DAC output, the incomming PCM buffer needs to be converted from signed 16bit to unsigned
CCopyChannels	Copy channel Cx value of type T shifted by S bits to all Cn channels
CCopyDecoder	Dummy Decoder which just copies the provided data to the output. You can define if it is PCM data
CCopyEncoder	Dummy Encoder which just copies the provided data to the output
CCsvOutput	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 ,
CDataNode
CDebouncer	Helper class to debounce user input from a push button
CDecimate	Provides a reduced sampling rate by taking a sample at every factor location (ingoring factor-1 samples)
CDecimateT	Provides reduced sampling rates
CDecoderAdapter	Adapter class which allows the AudioDecoder API on a StreamingDecoder
CDecoderALAC	ALAC (Apple Lossless Audio Codec) decoder. This class depends on https://github.com/pschatzmann/codec-alac. This implementaion is based on https://github.com/macosforge/alac
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. In addition WAV files are also supported
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
CDecoderNetworkFormat	PCM decoder which converts from network format to the host format
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>>>();
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
CDelayEffectBase	A Base class for delay based digital effects. Provides the basic methods that are shared amongst Flanger, Delay, Chorus and Phaser
CDistortion	Distortion AudioEffect
CDriverPWMBase	Base Class for all PWM drivers
CDSFDecoder	DSF (DSD Stream File) format decoder
CDSFMetadata	Metadata structure for DSF (DSD Stream File) format
CDynamicMemoryStream	MemoryStream which is written and read using the internal RAM. For each write the data is allocated on the heap
CDynamicMultiBuffer	Auto-expanding buffer composed of multiple buffer instances
CDynamicResamplingQueueStream	An Audio Stream backed by a buffer (queue) which tries to correct jitter and automatically adjusts for the slightly different clock rates between an audio source and audio target. Use separate tasks to write and read the data. Also make sure that you protect the access with a mutex or provide a thread save buffer!
CEffectSuiteBase	Base Class for Effects
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
CEncodedAudioStream	A more natural Stream class to process encoded data (aac, wav, mp3...) which also supports the decoding by calling readBytes()
CEncoderALAC	ALAC (Apple Lossless Audio Codec) encoder. This class is responsible for encoding audio data into ALAC format. The implementaion is based on https://github.com/macosforge/alac
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
CEncoderNetworkFormat	Encoder which converts from the host format to the network format
CEnvelopeFilter	EnvelopeFilter
►CEqualizer3Bands	3 Band Equalizer with identical settings for all channels
CEQSTATE	Filter state for each channel
►CEqualizer3BandsPerChannel	3 Band Equalizer with per-channel frequency and gain control Allows independent frequency and gain settings for each audio channel. Each channel can have different low/high frequency cutoffs and different gain values for low, medium, and high frequency bands
CEQSTATE
CESP3288AudioOutput	Stream Adapter for ESP8288-Audio AudioOutput
CESPNowStream	ESPNow as Arduino Stream
CESPNowStreamConfig	Configuration for ESP-NOW protocolö.W
CExponentialVolumeControl	Simple exponentional volume control using the formula pow(2.0, input) - 1.0;
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
CFadeConverter	Converter which does a fade out or fade in
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
CFastSineGenerator	Sine wave which is based on a fast approximation function
CFaustStream	Integration into Faust DSP see https://faust.grame.fr/ To generate code from faust, select src and cpp
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
CFFTEffect
CFFTEffectConfig	Common configuration for FFT effects
CFFTInverseOverlapAdder	Inverse FFT Overlapp Add
CFFTNop	Apply FFT and IFFT w/o any changes to the frequency domain
CFFTPitchShift	Apply Pitch Shift FFT Effect on frequency domain data: we just move the bins up or down
CFFTPitchShiftConfig	Pitch Shift FFT Effect Configuration
CFFTRobotize	Apply Robotize FFT Effect on frequency domain data. See https://learn.bela.io/tutorials/c-plus-plus-for-real-time-audio-programming/phase-vocoder-part-3/
CFFTWhisper	Apply Robotize FFT Effect on frequency domain data. See https://learn.bela.io/tutorials/c-plus-plus-for-real-time-audio-programming/phase-vocoder-part-3/
CFileEntry	File entry to minimize RAM usage by using path index and name
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();
CFileLoopT	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();
CFileOutput	Simple layer for Print object to write to a c++ file
CFilter	Abstract filter interface definition;
CFilterChain	FilterChain - A Cascade of multiple filters
CFilteredDelay	Delay effect that filters the repeat delay
CFilteredStream	Stream to which we can apply Filters for each channel. The filter might change the result size!
CFilterEffectBase	A Base class for filter based effects including methods for simple high, low and band pass filtering
CFIR	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
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/
CFLACDecoderFoxen	Foxen FLAC Decoder using https://github.com/astoeckel/libfoxenflac Unlike FLACDecoder which is a streaming decoder, this is a simple AudioDecoder implementation
CFLACEncoder	FLACEncoder
CFlatTop	FlatTop FFT Window function
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
CFormatConverterStream	Converter which converts bits_per_sample, channels and the sample_rate. The conversion is supported both on the input and output side
CFrameBuffer
CFrequencyDetectorAutoCorrelation	Detects frequency using autocorrelation on audio samples
►CFrequencyDetectorZeroCrossing	Detects frequency using upward zero crossings in audio samples
CChannelState	Holds state for each channel during zero crossing detection
CFuzz	Fuzz AudioEffect
CG711_ALAWDecoder	64 kbit/s g711 ALOW Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG711_ALAWEncoder	64 kbit/s g711 ALOW Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG711_ULAWDecoder	64 kbit/s g711 ULOW Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG711_ULAWEncoder	64 kbit/s g711 ULOW Encoder 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
CG711Encoder	64 kbit/s g711 ULOW Encoder based on https://github.com/pschatzmann/arduino-libg7xx Supported encoder parameters: linear2alaw2, linear2ulaw
CG721Decoder	32Kbps G721 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG721Encoder	32Kbps G721 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG722Decoder	Decoder for G.722. Depends on https://github.com/pschatzmann/arduino-libg722
CG722Encoder	Encoder for G.722 - Depends on https://github.com/pschatzmann/arduino-libg722. Inspired by g722enc.c
CG723_24Decoder	24Kbps G723 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_24Encoder	24Kbps G723 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_40Decoder	40Kbps G723 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG723_40Encoder	40Kbps G723 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CG7xxDecoder	G723_24, g721, g723_40 Decoder based on https://github.com/pschatzmann/arduino-libg7xx
CG7xxEncoder	G723_24, g721, g723_40 Encoder based on https://github.com/pschatzmann/arduino-libg7xx
CGeneratedSoundStream	Source for reading generated tones. Please note
CGeneratorFixedValue	Just returns a constant value
CGeneratorFromArray	We generate the samples from an array which is provided in the constructor
CGeneratorFromStream	An Adapter Class which lets you use any Stream as a Generator
CGeneratorMixer	Generator which combines (mixes) multiple sound generators into one output
CGGWaveDecoder	GGWaveDecoder: Translates audio into text Codec using https://github.com/ggerganov/ggwave-arduino
CGGWaveEncoder	GGWaveEncoder: Translates text into audio Codec using https://github.com/ggerganov/ggwave-arduino
CGoertzelConfig	Configuration for Goertzel algorithm detectors
CGoertzelDetector	Single-frequency Goertzel algorithm implementation for tone detection. The Goertzel algorithm is an efficient way to compute the magnitude of a specific frequency component in a signal. It's particularly useful for DTMF (touch-tone) detection and other single-frequency detection applications
CGoertzelStream	AudioStream implementation that processes audio data through Goertzel algorithm. This class acts as a passthrough filter that can detect specific frequencies in the audio stream
CGSMDecoder	Decoder for GSM. Depends on https://github.com/pschatzmann/arduino-libgsm. Inspired by gsmdec.c
CGSMEncoder	Encoder for GSM - Depends on https://github.com/pschatzmann/arduino-libgsm. Inspired by gsmenc.c
CHamming	Hamming FFT Window function
CHammingFEC	Hamming forware error correction. Inspired by https://github.com/nasserkessas/hamming-codes
CHann	Hann FFT Window function
CHardwareSerial
CHDLCStream	High-Level Data Link Control (HDLC) is a bit-oriented code-transparent synchronous data link layer protocol for reliable, framed, and error-checked communication
CHeaderParserAAC	AAC header parser to check if the data is a valid ADTS aac which can extract some relevant audio information
CHeaderParserMP3	MP3 header parser to check if the data is a valid mp3 and to extract some relevant audio information. We try to find some valid frames with a valid sync in the beginning and the end. See https://www.codeproject.com/KB/audio-video/mpegaudioinfo.aspx
CHermiteInterpolator	Cubic Hermite interpolation using y[0]..y[3]
CHexDumpOutput	Creates a Hex Dump
CHighPassFilter	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	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
CHLSStreamT	HTTP Live Streaming using HLS: The resulting .ts data is provided via readBytes() that dynamically reload new Segments. Please note that this reloading adds a considerable delay: So if you want to play back the audio, you should buffer the content in a seaparate task
CHttpChunkReader	Http might reply with chunks. So we need to dechunk the data. see https://en.wikipedia.org/wiki/Chunked_transfer_encoding
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
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
CHttpReplyHeader	Reading and Writing of Http Replys
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
CHttpRequestHeader	Reading and writing of Http Requests
CI2SCodecConfig	Configuration for I2SCodecStream
CI2SCodecStream	I2S Stream which also sets up a codec chip and i2s
CI2SConfigESP32	Configuration for ESP32 legacy i2s
CI2SConfigESP32V1	Configuration for ESP32 i2s for IDF > 5.0
CI2SConfigStd	Configuration for i2s
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
CDriverCommon
CDriverI2S
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
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..
CICYStreamT	Icecast/Shoutcast audio stream that separates ICY metadata from audio bytes
CICYUrlSetup	Resolve icy-metaint from HttpRequest and execute metadata callbacks
CID3v1
CID3v1Enhanced
CID3v2
CID3v2Frame
CID3v2FrameString
CIIR	IIRFilter Converted from https://github.com/tttapa/Filters/blob/master/src/IIRFilter.h
CILBCDecoder	Decoder for iLBC. Depends on https://github.com/pschatzmann/libilbc
CILBCEncoder	Encoder for iLBC - Depends on https://github.com/pschatzmann/libopenilbc
CIMAState
►CInputMerge	Merges multiple input streams. 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
CMergeRecord
CInputMixer	MixerStream is mixing the input from Multiple Input Streams. All streams must have the same audo format (sample rate, channels, bits per sample)
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
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
CJupyterAudioT	Output to Jupyter. We write the data just to a file from where we can load the data again for different representations
►CKARadioProtocol	KA-Radio Protocol: We can use the KA-Radio protocol to control the audio player provided by the audiotools. Supported commands: play, instant, volume, volume+, volume-, pause, resume, stop, start, next, prev, mute, infos, version. Example: volume=50&play=128&infos See https://github.com/karawin/Ka-Radio32/blob/master/Interface.md
CAction
CKARadioProtocolServer	KA-Radio Protocol Server which provides the KARadioProtocol over http to control the audio player provided by the audiotools
CLagrangeInterpolator	Cubic Lagrange interpolation using y[0]..y[3]
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	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
CLC3Decoder	Decoder for LC3. Depends on https://github.com/pschatzmann/arduino-liblc3
CLC3Encoder	Encoder for LC3 - Depends on https://github.com/pschatzmann/arduino-liblc3
CLEDOutput	LED output using the FastLED library
CLEDOutputConfig
CLEDOutputUnoR4	LED output using the R4 LED matrix library
CLEDOutputUnoR4Config
CLinearInterpolator	Linear interpolation between y[0] and y[1]
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!
►CList	Double linked list
CIterator
CNode
►CListLockFree	Lock-free double linked list using atomic operations
CIterator
CNode
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
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
CLoRaConfig	LoRa Audio Configuration with default values maximised for speed using the LoRa library from sandeepmistry: https://github.com/sandeepmistry/arduino-LoRa
CLoRaStream	LoRa: Sending and Receiving Audio
CLowPassFilter	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	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
CM4AAudioDemuxer	A simple M4A audio data demuxer which is providing AAC, MP3 and ALAC frames
CM4AAudioFileDemuxer	Demuxer for M4A/MP4 files to extract audio data using an Arduino File. This class locates the mdat and stsz boxes using MP4Parser
►CM4ACommonDemuxer	Abstract base class for M4A/MP4 demuxers. Provides shared functionality for both file-based and stream-based demuxers
CESDSParser	A parser for the ESDS segment to extract the relevant aac information
CFrame
CM4AAudioConfig
CSampleExtractor	Extracts audio data based on the sample sizes defined in the stsz box. It collects the data from the mdat box and calls the callback with the extracted frames
CM4AFileSampleSizeBuffer	A buffer that reads sample sizes from an M4A file using the M4AAudioFileDemuxer. No RAM is used to store the sample sizes as they are read directly from the file
CMaximilian	AudioTools integration with Maximilian
CMeasuringStream	Class which measures the thruput
►CMedianFilter	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
CMedianFilter_t
CMedianNode_t
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
CMemoryOutput	Writes to a preallocated memory
CMemoryStream	A simple Stream implementation which is backed by allocated memory
►CMetaDataFilter	Class which filters out ID3v1 and ID3v2 Metadata and provides only the audio data to the decoder
CID3v2	ID3 verion 2 TAG Header (10 bytes)
CRange	Metadata range
CMetaDataFilterDecoder
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
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
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
►CMimeDetector	Logic to detemine the mime type from the content. By default the following mime types are supported (audio/aac, audio/mpeg, audio/vnd.wave, audio/ogg, audio/flac). You can register your own custom detection logic to cover additional file types
CCheck
CMimeSource	Abstract interface for classes that can provide MIME type information
CMiniAudioConfig	Configuration for MiniAudio
CMiniAudioStream	MiniAudio: https://miniaud.io/
CModifyingOutput	Abstract class: Objects can be put into a pipleline
CModifyingStream	Abstract class: Objects can be put into a pipleline
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
CMovingAverage	Caclulates the moving average of a number of values
CMozziConfig
CMozziStream	Stream that provides audio information that was generated using the Mozzi API using the updateControl() and updateAudio() methods
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
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
►CMP4Parser	MP4Parser is a class that parses MP4 container files and extracts boxes (atoms). It provides a callback mechanism to process each box as it is parsed. You can define specific callbacks for individual box types or use a generic callback for the undefined boxes: By default it just prints the box information to Serial. If a container box contains data, it will be processed recursively and if it contains data itself, it might be reported in a second callback call
CBox	Represents an individual box in the MP4 file
CCallbackEntry	Structure for type-specific callbacks
CContainerInfo	Structure for container box information
CMTSDecoder	MPEG-TS (MTS) decoder. Extracts (demuxes) the indicated audio/video data from a MPEG-TS (MTS) data stream. You can define the relevant stream types via the API: addStreamType(MTSStreamType). By default, the decoder selects the AUDIO_AAC, AUDIO_AAC_LATM stream types
CMTSDecoderTSDemux	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. Required dependency: https://github.com/pschatzmann/arduino-tsdemux
CMultiChannelResampler	Multi-channel resampler that applies a BaseInterpolator-derived algorithm to each channel
CMultiConverter	Combines multiple converters
►CMultiDecoder	Manage multiple AudioDecoders with automatic format detection
CDecoderInfo	Information about a registered decoder
CMultiOutput	Replicates the output to multiple destinations
►CMultiStreamingDecoder	Manage multiple StreamingDecoders with automatic format detection
CDecoderInfo	Information about a registered decoder
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
CNamePrinter	Print class that calls addName for each printed line. Useful for collecting file names from text output (e.g., directory listings)
CNano_BLE_freq_info	Mapping Frequency constants to available frequencies
CNano_BLE_ratio_info	Mapping from Ratio Constants to frequency ratios
CNBuffer	A lock free N buffer. If count=2 we create a DoubleBuffer, if count=3 a TripleBuffer etc
CNBufferExt	A NBufferExt is a subclass of NBuffer which allows to use a direct access API to the BaseBuffer
CNBufferFile
CNoFilter	No change to the input
CNoInterruptHandler	Disable, enable interrupts (only on the actual core)
CNOPConverter	Dummy converter which does nothing
CNotchFilter	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
CNullStream	The Arduino Stream which provides silence and simulates a null device when used as audio target or audio source
CNumberConverter	Converts from a source to a target number with a different type
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	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
CNumberReader	Reads n numbers from an Arduino Stream
CNuttall	Nuttall FFT Window function
CObjectStream	A Arduino Stream which makes sure that we read back the same size as we wrote. It adds a size prefix to the data stream
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
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
COggContainerOutput	Output class for the OggContainerEncoder. Each write is ending up as container entry
COpusAudioDecoder	Decoder for the Opus audio format. Each Opus frame must be provided with one write() call. Therefore, Opus is usually encapsulated in a container format (e.g., Ogg) that splits the stream into frames
COpusAudioEncoder	Encode for Opus audio
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
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
COpusOggEncoder	Opus Encoder which uses the Ogg Container: see https://datatracker.ietf.org/doc/html/rfc7845 Dependency: https://github.com/pschatzmann/arduino-libopus
COpusOggWriter
COpusSettings	Setting for Opus Decoder
COSCBinaryData	Simple structure to hold binary data
COSCContainerDecoder	Decodes the provided data from the OSC segments. I recommend to assign a MultiDecoder so that we can support muiltiple audio types
►COSCContainerEncoder	Wraps the encoded data into OSC info and data segments so that the receiver can recover the audio configuration and orignial segments
COSCOutput	Output Encoded Audio via OSC
►COSCData	A simple OSC Data composer and parser. A OSC data starts with an address string followed by a format string. This is followed by the data. You need to call the read and write methods in the sequence defined by the format string. There is no validation for this, so you need to be careful and test your code properly. To compose a message call:
CCallback
COutputMixer	Mixing of multiple outputs to one final output. By default a RingBuffer is used as buffer type
CParabolicInterpolator	Parabolic interpolation using y[0]..y[3]
CParameter	A constant value
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
CPathNamesRegistry	Interface for classes that can collect file names
CPIDController	A simple header only PID Controller
CPinInfoESP32	Information for a PIN
CPinInfoESP32Compl	Mapping information for one complementary PWM audio channel
CPinkNoiseGenerator	Generates pink noise
►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();
CModifyingStreamAdapter	Support for ModifyingOutput
CPitchShift	Shifts the pitch by the indicated step size: e.g. 2 doubles the pitch
CPitchShiftInfo	Configuration for PitchShiftOutput
CPitchShiftOutput	Real-time pitch shifting audio effect
CPoppingSoundRemover	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
CPortAudioConfig	PortAudio information
CPortAudioStream	Arduino Audio Stream using PortAudio
CPrint
CPriorityQueue	Priority Queue which is based on a List. The order of the elements is defined by a compare function which is provided in the constructor. If the function returns > 0 if v1 > v2, the data will be provided in increasing order
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
CProgressStreamInfo	Configuration for ProgressStream
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
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
CPWMComplementaryDriverESP32	Audio output to PWM pins for the ESP32. The ESP32 supports up to 16 channels
CPWMConfig	Configuration data for PWM audio output
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
CQueue	FIFO Queue which is based on a List
CQueueFromVector	FIFO Queue which is based on a Vector
►CQueueLockFree	A simple single producer, single consumer lock free queue
CNode
CQueueRTOS	FIFO Queue whch is based on the FreeRTOS queue API. The default allocator will allocate the memory from psram if available
CQueueStream	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();
CR2RConfig	R2R configuration
CR2RDriver	R2R driver which uses the Arduino API to setup and write to the digital pins
CR2RDriverBase	R2R driver base class
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
CRCAudioPlayerOSCReceiver	Audio Player OSC Receiver: Receives OSC messages from the AudioPlayerOSCSender and applies it to the AudioPlayer
CRCAudioPlayerOSCSender	Audio Player OSC Sender: Remote control for AudioPlayer class. Sends OSC messages to the RCAudioPlayerOSCReceiver
CReadioHeadStream	Arduino Stream which is using the RadioHead library to send and receive data. We use the river API directly
CRECT
CRectange	Rectange FFT Window function
►CRedisBuffer	Buffer implementation that stores and retrieves data from a Redis server using the Arduino Client
CRedisResult
CReedSolomonFEC	Forward error correction using Reed-Solomon: write is encoding and readBytes does the decoding
CReformatBaseStream	Base class for chained converting streams
CResampleConfig	Optional Configuration object. The critical information is the channels and the step_size. All other information is not used
CResampleStream	Dynamic Resampling. We can use a variable factor to speed up or slow down the playback
CResampleStreamT	A Stream implementation for resamping using a specified interpolation algorithm
CRingBuffer	Implements a typed Ringbuffer
►CRingBufferFile	An File backed Ring Buffer that we can use to receive streaming audio. We expect an open file as parameter
COffsetInfo
CRingBufferStream	An AudioStream backed by a Ringbuffer. We can write to the end and read from the beginning of the stream
CRTSPFormatAbtX	AbtX format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatAudioTools	RTSPFormat which supports the AudioInfo class
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
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
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
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
CSawToothGenerator	SawToothGenerator
CSBCDecoder	Decoder for SBC. Depends on https://github.com/pschatzmann/arduino-libsbc. Inspired by sbcdec.c
CSBCEncoder	Encoder for SBC - Depends on https://github.com/pschatzmann/arduino-libsbc. Inspired by sbcenc.c
CScaledParameter	Scales a dynamic parameter to the indicated range
CSDDirect	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
CSDIndex	We store all the relevant file names in an sequential index file. Form there we can access them via an index
CSilenceGenerator	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
CSilenceRemovalConverter	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
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
CSimpleContainerConfig
CSimpleContainerDataHeader
CSimpleContainerMetaDataHeader
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
CSimpleLPF	SimpleLPF
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)
CSineFromTable	A sine generator based on a table. The table is created using degrees where one full wave is 360 degrees
CSineWaveGenerator	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
CSingleBuffer	A simple Buffer implementation which just uses a (dynamically sized) array
CSlice	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!
CSmoothTransition	Changes the samples at the beginning or at the end to slowly ramp up the volume
CSOSFilter	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
CSoundGenerator	Base class to define the abstract interface for the sound generating classes
CSoundGeneratorModulation	SoundGenerator using the ModulationBaseClass to generate the samples
CSPDIFConfig	SPDIF configuration
CSPDIFOutput	Output as 16 bit stereo SPDIF on the I2S data output pin. For the time beeing only the ESP32 is officially supported
CSquareWaveGenerator	Generates a square wave sound
CStack	LIFO Stack which is based on a List
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
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
CSTKGenerator	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
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
CSTKStream	STK Stream for Instrument or Voicer
CStr	Str which keeps the data on the heap. We grow the allocated memory only if the copy source is not fitting
CStream
CStreamCopyT	Typed Stream Copy which supports the conversion from channel to 2 channels. We make sure that we allways copy full samples
CStreamingDecoder	A Streaming Decoder where we provide both the input and output as streams
CStreamingDecoderAdapter	Converts any AudioDecoder to a StreamingDecoder
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!
CSynchronizedBuffer	Wrapper class that can turn any Buffer into a thread save implementation
CSynchronizedNBufferRTOST	NBuffer which uses some RTOS queues to manage the available and filled buffers
CSynchronizedQueue	FIFO Queue which is based on a List that is thread save
CSynchronizedStream
►CSynthesizer	A simple Synthesizer which can generate sound having multiple keys pressed. The main purpose of this class is managing the synthezizer channels
CKeyParameter
CSynthesizerKey	Arduino GPIO pin to note assossiation
CTask	FreeRTOS task
CTestGenerator	Generates a test signal which is easy to check because the values are incremented or decremented by 1
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
CTfLiteAudioStream	TfLiteAudioStream which uses Tensorflow Light to analyze the data. If it is used as a generator (where we read audio data)
CTfLiteAudioStreamBase	Astract TfLiteAudioStream to provide access to TfLiteAudioStream for Reader and Writers
CTfLiteConfig	Configuration settings for TfLiteAudioStream
CTfLiteMicroSpeachWriter	TfLiteMicroSpeachWriter for Audio Data
►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
CResult
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
CThrottle	Throttle the sending or receiving of the audio data to limit it to the indicated sample rate
CThrottleConfig	Configure Throttle setting
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!
CTimerAlarmRepeating	Common Interface definition for TimerAlarmRepeating
CTimerAlarmRepeatingDriverAVR	Repeating Timer functions for repeated execution: Plaease use the typedef TimerAlarmRepeating
CTimerAlarmRepeatingDriverBase
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
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
CTimerCallbackAudioStreamInfo	TimerCallbackAudioStream Configuration
CTransformationReader	ConverterStream Helper class which implements the readBytes with the help of write
CTremolo	Tremolo AudioEffect
CTriangle	Triangle FFT Window function
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
CUrl	URL parser which breaks a full url string up into its individual parts
CURLStream	Represents the content of a URL as Stream. We use the WiFi.h API. If you run into performance issues, check if the data is provided chunked. In this chase you can check if setting the protocol to "HTTP/1.0" improves the situation
CURLStreamBufferedT	URLStream implementation for the ESP32 based on a separate FreeRTOS task: the
CURLStreamESP32	URLStream using the ESP32 IDF API
CUSBAudio2DescriptorBuilder
CUSBAudioConfig
CUSBAudioDevice
CVariableSpeedRingBuffer	Optimized buffer implementation for pitch shifting with interpolation
CVariableSpeedRingBuffer180	Variable speed ring buffer with 180-degree phase shifting
CVariableSpeedRingBufferSimple	Very Simple Buffer implementation for Pitch Shift
CVBANConfig
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
►CVector	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
Citerator	Iterator for the Vector class
CVFS
CVFS_LittleFS	ESP32 Virtual File System for the LittleFS. The default mount point is "/littlefs" DRAFT implementation: not tested See https://github.com/espressif/esp-idf/tree/master/examples/storage/sd_card/sdspi
CVFS_Multi	Define multipe VFS with their mount point
CVFS_SDMMC	ESP32 Virtual File System for SDMMC. The default mount point is "/sdcard" DRAFT implementation: not tested see https://github.com/espressif/esp-idf/blob/master/examples/storage/sd_card/sdmmc/README.md
CVFS_SDSPI	ESP32 Virtual File System for SPI SD. The default mount point is "/sdcard" DRAFT implementation: not tested See https://github.com/espressif/esp-idf/tree/master/examples/storage/sd_card/sdspi
CVFS_SPFFS	ESP32 Virtual File System for the SPFFS. The default mount point is "/spiffs" DRAFT implementation: not tested See https://github.com/espressif/esp-idf/tree/master/examples/storage/sd_card/sdspi
CVFSFile	Arduino File support using std::fstream
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
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
CVideoOutput	Abstract class for video playback. This class is used to assemble a complete video frame in memory
CVolumeControl	Abstract class for handling of the linear input volume to determine the multiplication factor which should be applied to the audio signal
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
CVolumeStreamConfig	Config for VolumeStream
CVolumeSupport	Supports the setting and getting of the volume
CVorbisDecoder	Vorbis Streaming Decoder using https://github.com/pschatzmann/arduino-libvorbis-tremor
CVS1053Config	Configuration for VS1053Stream
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;
CWAVAudioInfo	Sound information which is available in the WAV header
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
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
CWAVFormatX
CWAVHeader	Parser for Wav header data for details see https://de.wikipedia.org/wiki/RIFF_WAVE
CWavIMAAudioInfo	Sound information which is available in the WAV header - adjusted for IMA ADPCM
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!
CWavIMAHeader
CWebSocketOutput	A simple wrapper class that lets you use the standard Arduino Print class output commands to send audio data over a WebSocket connection. Uses https://github.com/Links2004/arduinoWebSockets
CWelch	Welch FFT Window function
CWhiteNoiseGenerator	Generates a random noise sound with the help of rand() function
CWiFiESP32	Login to Wifi using the ESP32 IDF functionality. This can be accessed with the global object IDF_WIFI
CWindowFunction	FFT Window Function
CWM8960Config	Configuration for WM8960
CWM8960Stream	Stream for reading and writing audio data using the WM8960 Codec Chip You need to install https://github.com/pschatzmann/arduino-wm8960
►Naudio_tools_hls	Hide hls implementation in it's own namespace
CHLSParser	Simple Parser for HLS data
CURLHistory
CURLLoaderHLS
►Naudiotools_rtsp	AudioTools internal: rtsp
COurRTSPClient
COurSink
CStreamClientState
►Nffft	AudioTools internal: FFT
CArray
CDynArray
CFFTReal
CFFTRealFixLen
CFFTRealFixLenParam
CFFTRealPassDirect
CFFTRealPassInverse
CFFTRealSelect
CFFTRealUseTrigo
COscSinCos
►NRS	AudioTools internal: Reed-Solomon
CPoly
CReedSolomon