| ►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 | |
| 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 | |
| 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 | |
| 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 | Docoding 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 RealFFT |
| 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. 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: |
| 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 |
| 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 |
| CAudioSourceIdxSDFAT | ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation For UTF8 Support change SdFatConfig.h #define USE_UTF8_LONG_NAMES 1 |
| CAudioSourceIdxSDMMC | ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD_MMC implementation Connect the SD card to the following pins: |
| CAudioSourceLittleFS | ESP32 AudioSource for AudioPlayer using an the LittleFS file system |
| CAudioSourceSD | ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation Connect the SD card to the following pins: |
| CAudioSourceSDFAT | ESP32 AudioSource for AudioPlayer using an SD card as data source. This class is based on the Arduino SD implementation Connect the SD card. For UTF8 Support change SdFatConfig.h #define USE_UTF8_LONG_NAMES 1 |
| 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 |
| 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 |
| 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 |
| CBitBangDecimationStream | |
| CBitmapInfoHeader | |
| CBlackman | Blackman FFT Window function |
| CBlackmanHarris | BlackmanHarris FFT Window function |
| CBlackmanNuttall | BlackmanNuttall FFT Window function |
| CBoost | Boost AudioEffect |
| 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 conver the data |
| CCallbackStream | CallbackStream: A Stream that allows to register callback methods for accessing and providing data. The callbacks can be lambda expressions |
| 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 readd them back if you want to process them a second time. The default timeout on the available() method is set to 0. This might be not good if you use e.g. a URLStream |
| 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 |
| 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 |
| CConfigEquilizer3Bands | Configuration for 3 Band Equilizer: Set channels,bits_per_sample,sample_rate. Set and update gain_low, gain_medium and gain_high to value between 0 and 1.0 |
| CContainerDecoder | Parent class for all container formats |
| CContainerMP4 | Minimum flexible parser for MPEG4 data (which is based on the Quicktime format). Small atoms will be make available via a callback method. The big (audio) content is written to the Print object which was specified in the constructor. Depends on https://github.com/pschatzmann/arduino-libhelix! |
| 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 , |
| CDACInfo | Config info for DeltaSigma DAC |
| CDACOut | Output method for DeltaSigma DAC |
| 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 |
| CDecimationStreamExt | Deciates an sample stream by the indicated factor: Decimation counts the number of set bits. Please note that the factor is specified as multiple of the bits_per_sample. It is also assumed that we have only one channel in the data stream |
| CDecoderAdapter | Adapter class which allows the AudioDecoder API on a StreamingDecoder |
| CDecoderBase64 | DecoderBase64 - Converts a Base64 encoded Stream into the original data stream. Decoding only gives a valid result if we start at a limit of 4 bytes. We therefore use by default a newline to determine a valid start boundary |
| CDecoderBasic | DecoderBasic - supports mime type audio/basic Requires https://github.com/pschatzmann/arduino-libg7xx The content of the "audio/basic" subtype is single channel audio encoded using 8bit ISDN mu-law [PCM] at a sample rate of 8000 Hz |
| CDecoderFloat | DecoderFloat - Converts Stream of floats into 2 byte integers |
| CDecoderHelix | MP3 and AAC Decoder using libhelix: https://github.com/pschatzmann/arduino-libhelix. We dynamically create a MP3 or AAC decoder dependent on the provided audio format |
| CDecoderL16 | DecoderL16 - Converts an 16 Bit Stream into 16Bits network byte order |
| CDecoderL8 | DecoderL8 - Converts an 8 Bit Stream into 16Bits Most microcontrollers can not output 8 bit data directly. 8 bit data however is very memory efficient and helps if you need to store audio on constrained resources. This decoder translates 8bit data into 16bit data. By default the encoded data is represented as uint8_t, so the values are from 0 to 255 |
| 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 |
| CDynamicMemoryStream | MemoryStream which is written and read using the internal RAM. For each write the data is allocated on the heap |
| 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() |
| 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 |
| CEnvelopeFilter | EnvelopeFilter |
| ►CEquilizer3Bands | 3 Band Equilizer inspired from https://www.musicdsp.org/en/latest/Filters/236-3-band-equaliser.html |
| 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 |
| CFile | Arduino File support using std::fstream |
| 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/ |
| 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 |
| CFrequncyAutoCorrelationStream | Determine Frequency using Audio Correlation. based on https://github.com/akellyirl/AutoCorr_Freq_detect |
| CFrequncyZeroCrossingStream | Determine Frequency using upward 0 crossings |
| CFS | Eumlate FS using C++ or Posix functions |
| 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 |
| 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 |
| 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 |
| CHLSParser | Simple Parser for HLS data. We select the entry with min bandwidth |
| CHLSStream | HTTP Live Streaming using HLS: The result is a MPEG-TS data stream that must be decoded e.g. with a DecoderMTS |
| 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 |
| CI2SBitBang | I2S emulated with the help of the Arduion SPI api |
| 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.. |
| CICYStream | Icecast/Shoutcast Audio Stream which splits the data into metadata and audio data. The Audio data is provided via the regular stream functions. The metadata is handled with the help of the MetaDataICY state machine and provided via a callback method |
| CICYStreamBuffered | ICYStream implementation for the ESP32 based on a FreeRTOS task This is a Icecast/Shoutcast Audio Stream which splits the data into metadata and audio data. The Audio data is provided via the regular stream functions. The metadata is handled with the help of the MetaDataICY state machine and provided via a callback method |
| 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 channels. The input must be mono! So if you provide 2 mono channels you get a stereo signal as result with the left channel from channel 0 and the right from channel 1 |
| CInputMixer | 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 |
| 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 | |
| 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 | |
| CLock | A simple RIA locking class for the ESP32 using _lock_t |
| CLockGuard | RAII implementaion using a Mutex: Only a few microcontrollers provide lock guards, so I decided to roll my own solution where we can just use a dummy Mutex implementation that does nothing for the cases where this is not needed |
| 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 |
| 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 |
| 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 |
| 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 |
| CMP4Atom | Represents a single MPEG4 atom |
| CMP4ParseBuffer | |
| ►CMTSDecoder1 | MPEG-TS (MTS) decoder. Extracts the AAC audio data from a MPEG-TS (MTS) data stream. You can define the relevant stream types via the API. The parsing logic was taken from: https://github.com/Yokohama-Miyazawa/M5HLSPlayer/blob/main/src/AudioGeneratorTS.cpp Status: experimental! |
| Cpid_array | |
| CMultiConverter | Combines multiple converters |
| CMultiOutput | Replicates the output to multiple destinations |
| 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 |
| 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 |
| 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 |
| 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 | OpusAudioDecoder: Depends on https://github.com/pschatzmann/arduino-libopus.git |
| COpusAudioEncoder | OpusAudioEncoder: Dependens on https://github.com/pschatzmann/arduino-libopus.git |
| 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 |
| COutputMixer | Mixing of multiple outputs to one final output |
| COversamplingDAC | Abstract Software Implementation of an Oversampling DAC |
| COversamplingDAC32 | Software Implementation of a Simple DAC - We quantize a digital int16_t sample my mapping the value to the range of 0b0 to 0b11111111111111111111111111111111, where the intensity is represented by the number of ones. This gives an overall resultion of 5 bits and just uses one single timer |
| 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 | |
| CPDMMonoStreamT | Applies low pass filter to a decimated pdm signal to convert it to pcm |
| CPIDController | A simple header only PID Controller |
| CPinInfoESP32 | Information for a PIN |
| 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: set the pitch_shift to define the shift |
| CPitchShiftOutput | Pitch Shift: Shifts the frequency up or down w/o impacting the length! We reduce the channels to 1 to calculate the pitch shift and provides the pitch shifted result in the correct number of channels. The pitch shifting is done with the help of a buffer that can have potentially multiple implementations |
| 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 | |
| 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 |
| CPWMConfig | Configuration data for PWM audio output |
| CPWMDAC | Audio Output with PWM signal |
| 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 |
| CReadioHeadStream | Arduino Stream which is using the RadioHead library to send and receive data. We use the river API directly |
| CReasampleLinearInterpolation | Range 0:1 |
| CRECT | |
| CRectange | Rectange FFT Window function |
| CReedSolomonFEC | Forward error correction using Reed-Solomon: write is encoding and readBytes does the decoding |
| CReformatBaseStream | Base class for chained converting streams |
| CResample2Point3Order | |
| CResample4Point2Order | |
| CResampleBSpline | Range -1:2 |
| CResampleConfig | Optional Configuration object. The critical information is the channels and the step_size. All other information is not used |
| CResampleLagrange | Range -1 : 2 |
| CResampleParabolic | |
| CResampleStream | Dynamic Resampling. We can use a variable factor to speed up or slow down the playback |
| CResmpleHermite | |
| CRingBuffer | Implements a typed Ringbuffer |
| CRingBufferFile | An File backed Ring Buffer that we can use to receive streaming audio. We expect an open p_file as parameter |
| 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 |
| CSerialDAC | A SimpleDAC which uses the Serial UART to output values. This implementation is not using any timers and therefore should work on any microcontroller |
| 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 | |
| CSimpleDAC | Software Implementation of a Simple DAC - We quantize a digital int16_t sample my mapping the value to the range of 0b0 to info.output_bits number of 1, where the intensity is represented by the number of ones. This is very similar to PWM! |
| 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 |
| CSpinLock | |
| 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 |
| ►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 |
| CURLHistory | |
| CURLLoaderHLS | |
| CURLLoaderHLSBase | Abstract API for URLLoaderHLS |
| CURLLoaderHLSOutput | URLLoader which saves the HLS segments to the indicated output |
| CURLStream | Represents the content of a URL as Stream. We use the WiFi.h API |
| CURLStreamBuffered | URLStream implementation for the ESP32 based on a separate FreeRTOS task |
| CVariableSpeedRingBuffer | Optimized Buffer implementation for Pitch Shift. We try to interpolate the samples and restore the phase when the read pointer and write pointer overtake each other |
| CVariableSpeedRingBuffer180 | Varialbe speed ring buffer where we read with 0 and 180 degree and blend the result to prevent overrun artifacts. See https://github.com/YetAnotherElectronicsChannel/STM32_DSP_PitchShift |
| CVariableSpeedRingBufferSimple | Very Simple Buffer implementation for Pitch Shift. We write in constant speed, but reading can be done in a variable speed. We will hear some noise when the buffer read and write pointers overrun each other |
| 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 |
| 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 | |
| CWelch | Welch FFT Window function |
| CWhiteNoiseGenerator | Generates a random noise sound with the help of rand() function |
| 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 |
| ►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 |
| Ngf | |
| CPoly | |
| CReedSolomon | |
| Nstd | |
