| ►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 |
| CAdaptiveResamplingStream | 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-safe buffer! |
| 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 | |
| CAudioEncoderServerT | 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 |
| CAudioInputMonitor | Monitors audio input and reports if the volume exceeds a specified limit within a given period |
| 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 | High-level audio playback pipeline and controller |
| CAudioPlayerProtocol | Abstract class for protocol to control the audio player |
| CAudioPlayerProtocolServer | Audio Player Protocol Server: We can use the indicated protocol over http to control the audio player provided by the audiotools |
| 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 |
| CAudioWAVServerEx | A powerfull WAV Web server which is based on https://github.com/pschatzmann/TinyHttp. It supports multiple concurrent clients |
| CAudioWAVServerT | 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 |
| 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 | 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! |
| 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 |
| CChannelMixer | We mix all input channels in a datastream. E.g. if we have stereo input data we end up with 2 identical mono 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. We copy the data from the non-empty channel to the empty one |
| 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 for the ESP32. 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 |
| 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 | Abstract class for common Logic for FFT based effects. The effect is applied after the fft to the frequency domain before executing the ifft. Please note that this is quite processing time intensitive: so you might keep the sample rate quite low if the processor is not fast enough! |
| 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 | A FrameBuffer reads multiple values for array of 2 dimensional frames |
| 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 |
| 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-based multi-frequency Goertzel detector for real-time audio analysis |
| 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 that processes MP3 data incrementally and extracts complete MP3 frames. Can validate MP3 data and extract audio information. When used with a Print output, it splits incoming data into complete MP3 frames and writes them to the output stream |
| 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.. |
| CIAudioSource | Audio Source Interface - Contract for Audio Data Providers |
| CICYStreamBuffered | Buffered ICYStream with metadata callback support |
| 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 |
| CKalmanFilter | Simple 1D Kalman Filter for smoothing measurements |
| ►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 | MetaDataFiler applied to the indicated decoder: Class which filters out ID3v1 and ID3v2 Metadata and provides only the audio data to the decoder |
| CMetaDataFilterEncoder | MetaDataFilter applied to an encoder: filters out ID3v1 / ID3v2 metadata from the mp3 input stream before it is provided to the wrapped encoder. This is basically a pass-through for mp3 data with metadata skipped |
| 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 | |
| CMimeEntry | Extension to mime table (sorted alphabetically) |
| CMimeResolver | Lookup MIME types by file extension |
| 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 |
| CMP3ParserEncoder | Parses MP3 frames, extracts audio info, and outputs complete frames. The frame duration is determined e.g. for RTSP streaming |
| ►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 | A File backed buffer which uses the provided files for buffering with the indicated max size. A file is made available for reading as soon as it reached the size limit. You must provide the files opened in "Write" mode with the addFile() method! |
| 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 |
| COggVorbisDecoder | Ogg Vorbis Decoder |
| 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 audio input streams into a single output stream |
| 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 | Represents a LIST or a CHUNK: The ParseObject represents the current parsing result. We just keep position information and ids |
| 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 |
| CRTSPAudioSource | Unified RTSP Audio Source - Works with both Stream and AudioStream |
| CRTSPAudioStreamer | RTSPAudioStreamer - Timer-driven RTP Audio Streaming Engine |
| CRTSPAudioStreamerBase | RTSPAudioStreamerBase - Core RTP Audio Streaming Engine |
| CRTSPAudioStreamerTaskless | RTSPAudioStreamerTaskless - Manual RTP Audio Streaming Engine (no Task) |
| CRTSPAudioStreamerUsingTask | RTSPAudioStreamerUsingTask - Task-driven RTP Audio Streaming Engine |
| CRTSPClient | Efficient RTSP client for UDP/RTP audio with decoder pipeline |
| CRTSPFormat | Audio Format Definition - Base class for RTSP audio formats |
| CRTSPFormatAAC | AAC format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats See RFC 3640 for details |
| CRTSPFormatAbtX | AbtX format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats |
| CRTSPFormatADPCM | RTSP/RTP formatter for mono IMA ADPCM (DVI4) |
| 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 |
| CRTSPFormatMP3 | MP3 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 | Linear PCM Format for RTSP Streaming |
| CRTSPFormatPCM8 | L8 format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats |
| CRTSPOutput | RTSPOutput - Audio Output Stream for RTSP Streaming |
| CRTSPPlatform | Template-based platform abstraction for RTSP networking |
| CRTSPServer | RTSPServer - Multi-client Audio Streaming Server (task-based) |
| CRTSPServerBase | RTSPServerBase - Shared logic for RTSPServer and RTSPServerTaskless |
| CRTSPServerTaskless | RTSPServerTaskless - Manual Multi-client RTSP Audio Streaming Server |
| CRtspSession | RTSP Session Handler - Individual Client Protocol Management |
| CRTTTLOutput | RTTTL (Ring Tone Text Transfer Language) parser and player stream |
| 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 | Wrapper class that can turn any Stream into a thread save implementation. This is done by adding a Mutex to the Stream. The read and write operations are buffered and the access to the stream is protected by the Mutex |
| ►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 | Base class which uses c++ file functions. It is also used as base class for an ESP32 Virtual File System. After initializing the VFS the regular c file operations are supported |
| 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 |
| 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 | We feed the URLLoaderHLS with some url strings. The data of the related segments are provided via the readBytes() method |
| ►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 | |
| ►Ntinyusb | |
| CAudioDevice | |
| CUSBAudio2DescriptorBuilder | |
| Caudio_feedback_params_t | |
| CByteBuffer | A resizable buffer of bytes which manages the available bytes |
| Cdsp | Minimal dsp base class needed by Faust |
| Cdsp_memory_manager | Memory manager which uses psram when it is available |
| CMeta | Minimial implementtion of Meta which just ignores the data |
| CPrintable | |
| CUI | Minimum implementation of UI parameters. We only support the setting and getting of values |
| CUSBAudioCB | Basic TinyUSB Audio User Callbacks |
| CUSBAudioConfig | Configuration for TinyUSB Audio |
| CUSBConfigESP32 | |
| CUSBDeviceAudio | |
| CUSBDeviceAudioAdafruit | Adafruit TinyUSB Initialization logic |
| ►CUSBDeviceAudioAPI | Baisc TinyUSB Audio Device Driver as C++ class which does not rely on preprocesser defines! |
| ►Caudiod_function_t | |
| Cfeedback | |
| CUSBDeviceAudioESP32 | ESP32 Initialization logic: We need to provide the USBAudioConfig in the constructor, so that we can determine the descriptor properly when the object is constructed |
| CVBan | |
| CVBAN_PING0 | |
| CVBanHeader | |
