Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

Naudio_tools	Generic Implementation of sound input and output for desktop environments using portaudio
Naudio_tools	AutioTools Configuration
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
CAllocator	Memory allocateator which uses malloc
CAllocatorESP32	ESP32 Memory allocateator which forces the allocation with the defined attributes (default MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL)
CAllocatorExt	Memory allocateator which uses ps_malloc (on the ESP32) and if this fails it resorts to malloc
CAllocatorPSRAM	Memory allocateator which uses ps_malloc to allocate the memory in PSRAM on the ESP32
CAllocatorZephyr	Zephyr allocator using the kernel heap (k_malloc / k_free). This is the standard allocator for Zephyr builds
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 >
CAudioDecoder	Decoding of encoded audio into PCM data
CAudioDecoderExt	Extended AudioDecoder interface to support block size configuration
CAudioEncoder	Encoding of PCM data
CAudioEncoderExt	Extended AudioEncoder interface to support block size configuration
CAudioInfo	Basic Audio information which drives e.g. I2S
CAudioInfoFormat	AudioInfo extended with a WAVEFORMATEX-style codec tag (the "wav code"): identifies the codec (PCM, AAC, ALAC, ...) - AudioFormat::UNKNOWN if not determined. mime() derives the corresponding mime type from format - not a separately stored field, so it can never go stale
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
CAudioOutput	Abstract Audio Ouptut class
CAudioOutputAdapter	Base class for Output Adpapters
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
CAudioTime	Tools for calculating timer values
CAudioTimer	Common Interface definition for AudioTimer
CAudioTimerDriverAVR	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer
CAudioTimerDriverBase
CAudioTimerDriverESP32	Repeating Timer functions for simple scheduling of repeated execution using esp_timer_create()
CAudioTimerDriverESP32Legacy	Repeating Timer functions for simple scheduling of repeated execution. The basic logic is taken from https://www.toptal.com/embedded/esp32-audio-sampling. Plaease use the typedef AudioTimer
CAudioTimerDriverESP8266	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer
CAudioTimerDriverLinux	Repeating software timer driver for Desktop using std::thread
CAudioTimerDriverMBED	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer
CAudioTimerDriverRenesas	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer. By default we use a new GPT timer. You can also request 1 AGT timer by calling setTimer(1);
CAudioTimerDriverSTM32	STM32 Repeating Timer functions for repeated execution: Please use the typedef AudioTimer. By default the TIM1 is used
CAudioTimerDriverZephyr	Repeating Timer driver for Zephyr using k_timer
CAudioTimeSourceStream	AudioTimeSourceStream: A stream that provides time information based on the audio data actually processed - implements the TimeSource interface. millis() (inherited, unmodified) is plain wall time; playbackTime() is the audio-derived progress, which is what a consumer that must stay tied to genuine playback (e.g. PacedVideoOutput) should use instead - see playbackTime()'s own comment for why they can diverge
CAudioWriter	E.g. used by Encoders and Decoders
CAudioWriterToAudioOutput	Adapter class which lets an AudioWriter behave like a Print
CBandPassFilter	Second-order band-pass filter (BiQuad DF2). Passes frequencies near the center frequency and attenuates those further away. The bandwidth is controlled by the Q factor: higher Q produces a narrower passband. Coefficients are derived from the Audio EQ Cookbook
CBandPassFilterDF1	Second-order band-pass filter (BiQuad DF1). Same coefficients as BandPassFilter; use this (not BandPassFilter) when T is a bounded fixed-point type like q1_14_t – see LowPassFilterDF1 for why
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
CBinState
CBinStateT
CBinT
CBiQuadCoeffs	Biquad coefficients, always computed in float regardless of the filter's sample type T. Intermediate values like the angular cutoff frequency w0 range up to PI (~3.14) at Nyquist, which overflows bounded fixed-point sample types like q1_14_t (range ~[-2,2)); only the final, range-safe coefficients (typically within [-2,2) for a stable filter) get cast into T when assigned to a BiQuadDF1/BiQuadDF2 instance
CBiQuadDF1	Second-order IIR filter in Direct Form I. Maintains separate input and output histories (x and y delay lines). Requires more memory than DF2 but is less susceptible to quantization issues with fixed-point arithmetic
CBiQuadDF2	Second-order IIR filter in Direct Form II. Uses a single delay line, requiring less memory than DF1. This is the base class for the ready-to-use filter types (LowPassFilter, HighPassFilter, BandPassFilter, NotchFilter, LowShelfFilter, HighShelfFilter) which compute their coefficients from frequency, sample rate and Q/gain parameters
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
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 and updating data. The callbacks can be lambda expressions. The update callback can also be used just to read the data without changing it. Warning: this class does not propagate audio info changes to the target stream. You need to do this manually
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. If you set beginReset to true in the constructor, the system will automatically reset the streams when begin() is called
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
CChannelBinDiffState
CChannelBinDiffStateT
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
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
CCodecNOP	Dummy no implmentation Codec. This is used so that we can initialize some pointers to decoders and encoders to make sure that they do not point to null
CContainerDecoder	Parent class for all container formats
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
CConverterInvert	Inverts the signal (multiplies every sample by -1)
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
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
CDecimate	Provides a reduced sampling rate by taking a sample at every factor location (ingoring factor-1 samples)
CDecimateState
CDecimateStateT
CDecimateT	Provides reduced sampling rates
CDynamicMemoryStream	MemoryStream which is written and read using the internal RAM. For each write the data is allocated on the heap
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()
CFastIntSineGenerator	Sine wave generator that does not use any floating point operations in the readSample() hot path: it advances a 32 bit phase accumulator with an integer increment and looks up the result in a Q15 fixed point table. All floating point math (converting frequency/sample_rate into the phase increment) is done once in setFrequency()/setAudioInfo(), never per sample. This makes it a good fit for MCUs without a hardware FPU - e.g. the RP2040 - where sinf() is comparatively expensive
CFastSineGenerator	Sine wave which is based on a fast approximation function using floating point math
CFilter	Abstract filter interface definition. Subclasses implement process() to transform audio samples one at a time. Use reset() to clear internal state (e.g. delay lines) without changing the filter coefficients
CFilterChain	A cascade of N arbitrary filters applied in series. Each sample is passed through all filters in order. The caller owns the filter pointers and must ensure they outlive the chain
CFilteredStream	Stream to which we can apply Filters for each channel. The filter might change the result size!
CFilterSampleConverter	Converts a raw sample (type T) to/from a filter's arithmetic type (FT) for ConverterNChannels. The default just casts the raw sample straight through – this matches the traditional convention used here, where FT=float and filter coefficients are calibrated against the sample's raw magnitude (e.g. up to +-32767 for 16-bit audio), so no rescaling is wanted. Specialized below for FT=q1_14_t, whose bounded ~[-2,2) range means a plain (q1_14_t)sample cast would misinterpret the raw PCM magnitude as a literal Q1.14 value and saturate almost immediately; q1_14_t::fromIntNN()/toIntNN() do the correct bit-shift scaling instead
CFilterSampleConverter< int16_t, q1_14_t >
CFilterSampleConverter< int24_t, q1_14_t >
CFilterSampleConverter< int32_t, q1_14_t >
CFIR	Finite Impulse Response (FIR) filter. Performs convolution of the input signal with a set of feedforward coefficients b[]. For integer types, an optional scaling factor is applied to preserve precision. You can use https://www.arc.id.au/FilterDesign.html to design the coefficients
CFloatSineGenerator	Generates a Sound with the help of sin() function. If performance is of concern, I suggest to use theSineFromTable, the FastSineGenerator or the FastIntSineGenerator
CFrameBuffer	A FrameBuffer reads multiple values for array of 2 dimensional frames
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
CGeneratorQueue	Queues SoundGenerators and plays them sequentially. Queued SoundGenerators must be limited (eg: setPlayTime()) or no later Generator will ever be played
CQNode
CHexDumpOutput	Creates a Hex Dump
CHighPassFilter	Second-order high-pass filter (BiQuad DF2). Attenuates frequencies below the cutoff frequency. Coefficients are derived from the Audio EQ Cookbook
CHighPassFilterDF1	Second-order high-pass filter (BiQuad DF1). Same coefficients as HighPassFilter; use this (not HighPassFilter) when T is a bounded fixed-point type like q1_14_t – see LowPassFilterDF1 for why
CHighShelfFilter	Second-order high-shelf filter (BiQuad DF2). Boosts or cuts frequencies above the shelf frequency by the specified gain (in dB) while leaving lower frequencies unchanged. Commonly used in tone controls and equalization. Coefficients are derived from the Audio EQ Cookbook
CHighShelfFilterDF1	Second-order high-shelf filter (BiQuad DF1). Same coefficients as HighShelfFilter. NOTE: unlike the other DF1 filters here, this is NOT a working fix for q1_14_t (or similar bounded fixed-point types) – see the
CIIR	Infinite Impulse Response (IIR) filter. Uses both feedforward (b[]) and feedback (a[]) coefficients. The a[0] coefficient is used to normalize all other coefficients. For integer types, an optional scaling factor is applied to preserve precision
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
CList	Double linked list
CIterator
CNode
CLowPassFilter	Second-order low-pass filter (BiQuad DF2). Attenuates frequencies above the cutoff frequency. Coefficients are derived from the Audio EQ Cookbook
CLowPassFilterDF1	Second-order low-pass filter (BiQuad DF1). Same coefficients as LowPassFilter, but built on BiQuadDF1, whose separate x[]/y[] delay lines stay bounded to the actual signal range – unlike DF2's single delay line, which can need far more dynamic range than the signal for low cutoff/ sampleRate ratios. Use this (not LowPassFilter) when T is a bounded fixed-point type like q1_14_t
CLowShelfFilter	Second-order low-shelf filter (BiQuad DF2). Boosts or cuts frequencies below the shelf frequency by the specified gain (in dB) while leaving higher frequencies unchanged. Commonly used in tone controls and equalization. Coefficients are derived from the Audio EQ Cookbook
CLowShelfFilterDF1	Second-order low-shelf filter (BiQuad DF1). Same coefficients as LowShelfFilter. NOTE: switching to DF1 does NOT make this reliable for bounded fixed-point types like q1_14_t – shelf coefficients scale with the linear gain factor and can exceed the type's range even at modest gain settings; this is a coefficient headroom problem, not the DF2 state-headroom problem DF1 fixes elsewhere. Watch for the LOGE warning from checkCoeffRange() in begin()
CMemoryOutput	Writes to a preallocated memory
CMemoryStream	A simple Stream implementation which is backed by allocated memory
CMimeSource	Abstract interface for classes that can provide MIME type information
CMixGain	Mixing of multiple audio input streams into a single output stream
CModifyingOutput	Abstract class: Objects can be put into a pipleline
CModifyingStream	Abstract class: Objects can be put into a pipleline
CMultiConverter	Combines multiple converters
CMultiOutput	Replicates the output to multiple destinations
CMultiOutputRecord	Record describing a single replicated output
CNBuffer	A 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	Passes the input through unchanged. Useful as a placeholder when a Filter is required but no processing is desired
CNOPConverter	Dummy converter which does nothing
CNotchFilter	Second-order notch (band-reject) filter (BiQuad DF2). Rejects frequencies near the center frequency and passes those further away. Useful for removing a specific unwanted frequency (e.g. mains hum at 50/60 Hz). Coefficients are derived from the Audio EQ Cookbook
CNotchFilterDF1	Second-order notch (band-reject) filter (BiQuad DF1). Same coefficients as NotchFilter; use this (not NotchFilter) when T is a bounded fixed-point type like q1_14_t – see LowPassFilterDF1 for why
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
CNumberReader	Reads n numbers from an Arduino Stream
COutputMixer
CPinkNoiseGenerator	Generates pink noise
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
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
Cq1_14_t	Fixed-point Q1.14 number: a plain 16-bit signed integer holding 1 integer bit and 14 fractional bits (value = raw / 16384.0). Covers the range [-2.0, 1.99993896484375] with a resolution of ~6.1e-5, using only integer add/sub/mul/div – no hardware floating-point instructions
CQueue	FIFO Queue which is based on a List
CQueueFromVector	FIFO Queue which is based on a Vector
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();
CReformatBaseStream	Base class for chained converting streams
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
CRingBufferSPSC	Lock-free Single-Producer Single-Consumer ring buffer
CRingBufferStream	An AudioStream backed by a Ringbuffer. We can write to the end and read from the beginning of the stream
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
CRTSPFormatH264	H.264 (AVC) format for RTSP video streaming, per RFC 6184
CRTSPFormatMJPEG	MJPEG (Motion JPEG) format for RTSP video streaming
CRTSPFormatMP3	MP3 format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatMTS	MPEG-2 Transport Stream (MP2T) format for RTSP streaming of a pre-muxed audio+video container, per RFC 2250
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
CRTSPPlatform	Template-based platform abstraction for RTSP networking
CRTSPVideoInfo	Video Information Structure
CRTSPVideoInfoSupport	Base class for video information support
CSawToothGenerator	Generates a saw tooth wave sound. Uses a 32 bit phase accumulator with an integer increment, just like FastIntSineGenerator: no floating point operations or divisions in the readSample() hot path. Unlike a sine, a saw tooth needs no lookup table either - a wrapping unsigned accumulator reinterpreted as signed already is a linear ramp - so this is even cheaper than FastIntSineGenerator and a good fit for MCUs without a hardware FPU (e.g. RP2040), where the previous sinf()/float based implementation (inherited from SineGenerator) was comparatively expensive
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
CSineFromTable	A sine generator based on a table. The table is created using degrees where one full wave is 360 degrees
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
Csoft_float_t	Software "pseudo-float": a real number represented as a signed 16-bit mantissa plus a 16-bit exponent (value = mantissa * 2^exponent), computed with integer multiply/shift/compare only – no hardware floating-point instructions. This generalizes speexdsp's classic fixed-point trick of tracking a handful of wide-dynamic-range control variables as a normalized mantissa+exponent pair into a full, operator-overloaded numeric type usable as a drop-in replacement for float (see MDFFixedPoint in MDFEchoCancellation.h, which uses this class as the element type for the MDF echo canceller's sample/spectrum arrays and internal state, so the whole algorithm runs without native float arithmetic)
CSOSFilter	Second Order Sections (SOS) filter — a cascade of N BiQuad DF2 stages. Higher-order filters should be decomposed into second-order sections to avoid numerical instability. Each section has its own b[3]/a[3] coefficients and optional gain. Tools like scipy.signal.butter(..., output='sos') or MATLAB's tf2sos produce the required coefficient arrays
CSoundGenerator	Base class to define the abstract interface for the sound generating classes
CSquareWaveGenerator	Generates a square wave sound. Uses the same 32 bit phase accumulator as SawToothGenerator/FastIntSineGenerator: no floating point operations or sin() calls in the readSample() hot path. A square wave needs neither a sine approximation nor a lookup table - just the sign bit of the ramp - so readSample() is a single comparison, making this a good fit for MCUs without a hardware FPU (e.g. RP2040), where the previous FastSineGenerator based implementation still did a float polynomial evaluation per sample just to keep its sign
CStack	LIFO Stack which is based on a List
CStr	Str which keeps the data on the heap. We grow the allocated memory only if the copy source is not fitting
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!
CTestGenerator	Generates a test signal which is easy to check because the values are incremented or decremented by 1
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!
CTimerCallback	Internal class to manage the different timer callbacks for the 4 hardware timers
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
CTimeSource	Interface for classes that can provide time information - two distinct notions of "now", not interchangeable: millis() is real wall time; playbackTime() is however far actual processing has gotten, which is not the same thing whenever the two can diverge (a consumer blocked/starved, a paused source, ...). A consumer that must stay tied to genuine progress (e.g. PacedVideoOutput scheduling video against actual decoded-audio playback, not merely time passing) should use playbackTime(), not millis()
CTransformationReader	ConverterStream Helper class which implements the readBytes with the help of write
CUserCallback	Internal class to manage User callbacks. An optinal parameter can be passed to the callback method We support 4 timers
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
CVolumeMeter	A simple class to determine the volume. You can use it as final output or as output or input in your audio chain
CVolumeSupport	Supports the setting and getting of the volume
CWhiteNoiseGenerator	Generates a random noise sound with the help of rand() function
Ni2s_detail
CHasDmaBufferInPsram
CHasDmaBufferInPsram< T, std::void_t< decltype(std::declval< T & >().dma_buffer_in_psram)> >
CHasDmaBurstSize
CHasDmaBurstSize< T, std::void_t< decltype(std::declval< T & >().dma_burst_size)> >
Nquickstart_detail	SFINAE helper for FileSeekableSource's auto-quickStart: calls writer.quickStart() if that method exists, no-op otherwise - most WriterT types (e.g. an AVI/WAV decoder) don't have one
CHasQuickStart
Nstd
Cnumeric_limits< audio_tools::int24_3bytes_t >
Cnumeric_limits< audio_tools::int24_4bytes_t >
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/codec-faad 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/
CAACDecoderFAAD2	AAC Decoder (LC, HE-AAC, MAIN, LTP) using faad2: https://github.com/pschatzmann/codec-faad2 Supports ADTS, ADIF and raw AAC. This needs a big stack and you need to make sure that memory is allocated on PSRAM
CAACDecoderFDK	Audio Decoder which decodes AAC into a PCM stream This is basically just a wrapper using https://github.com/pschatzmann/codec-fdk-aac which uses AudioInfo and provides the handlig of AudioInfo changes
CAACDecoderHelix	AAC Decoder using libhelix: https://github.com/pschatzmann/codec-helix This is basically just a simple wrapper to provide AudioInfo and AudioInfoSupport
CAACEncoderFAAC	AAC Encoder (AAC-LC and HE-AAC v1) using faac: https://github.com/pschatzmann/codec-faac
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/codec-fdk-aac
CAACEncoderVO	AAC Encoder based on the VisualOn vo-aacenc implementation (https://github.com/pschatzmann/codec-vo-aacenc)
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
CAC3AudioDecoder	AC-3 (Dolby Digital / ATSC A/52) Decoder using https://github.com/pschatzmann/codec-ac3
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
CAdaptiveResamplingBuffer	A BaseBuffer<uint8_t> that wraps a raw (unresampled) backing buffer and transparently resamples on read to correct jitter and compensate 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 backing buffer!
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/codec-adpcm-xq
CADPCMEncoder	Encoder for ADPCM - Depends on https://github.com/pschatzmann/adpcm>
CADPCMEncoderXQ	Encoder for ADPCM-XQ - Depends on https://github.com/pschatzmann/codec-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
CAGCPCMTraits
CAGCPCMTraits< int16_t >
CAGCPCMTraits< int24_t >
CAGCPCMTraits< int32_t >
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
CAllocatorZephyr	Zephyr allocator using the kernel heap (k_malloc / k_free). This is the standard allocator for Zephyr builds
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
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
CAnalogConfigZephyr	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
CAnalogDriverZephyr
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/codec-openaptx
CAPTXEncoder	Encoder for OpenAptx - Depends on https://github.com/pschatzmann/codec-openaptx
CAudioActions	A simple class to assign functions to gpio pins e.g. to implement a simple navigation control or volume control with buttons
CAction	Action definition per pin
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	Extended AudioDecoder interface to support block size configuration
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. SineGenerator, 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. Each channel is processed by its own independent clone of the effect chain (created via AudioEffect::clone()), so e.g. a stereo signal keeps its channel separation and effects that carry internal state (Delay's ring buffer, ADSRGain/Tremolo's envelope or oscillator phase, etc.) don't get confused by interleaved samples from different channels. addEffect() adds to a shared template chain that is cloned into every channel on begin() (and immediately cloned into all already-active channels if called afterwards); use addEffect(channel, effect) to register an effect directly on just one channel instead. Note that size()/operator[]/findEffect() operate on the template chain, not on the per-channel clones: mutating a pointer obtained from them after begin() has already cloned it does not retroactively change already-cloned per-channel copies. 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	Extended AudioEncoder interface to support block size configuration
CAudioEncoderServerT	A simple Arduino Webserver which encodes the provided PCM audio (from a Stream or a callback) with the given AudioEncoder and streams the result to the connected HTTP client, e.g. WAV, MP3 or any other supported format. This class extends AudioServerT, so it inherits its Client/Server template parameters as well as its transfer-encoding behavior: if setMaxOutputSize() is not called, the response defaults to Transfer-Encoding: chunked; otherwise a Content-Length header is sent instead
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
CMelFilter	One triangular mel filter: weights for bins [start_bin, start_bin+count)
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
CAudioFixedFFT	AudioFFT using the fixedpoint-fft library. CalcT selects the calculation type (default int16_t, see FFTDriverFixedFFT); pick int8_t on RAM-constrained plain AVR targets, or float/double on FPU-equipped targets
CAudioHeader	Common Header for all records
CAudioInfo	Basic Audio information which drives e.g. I2S
CAudioInfoFormat	AudioInfo extended with a WAVEFORMATEX-style codec tag (the "wav code"): identifies the codec (PCM, AAC, ALAC, ...) - AudioFormat::UNKNOWN if not determined. mime() derives the corresponding mime type from format - not a separately stored field, so it can never go stale
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	Sends and receives audio over a LoRa radio link (via the sandeepmistry/arduino-LoRa library) as a regular AudioTools Stream, so it can be dropped into a StreamCopy pipeline like any other audio source/sink – e.g. StreamCopy(audioLoRa, i2sMic) to transmit, or StreamCopy(i2sSpeaker, audioLoRa) to receive. See AudioLoRaConfig's documentation first for why, even with its audio-tuned defaults, this only works at all in a narrow envelope (very low bitrate, short clips/bursts)
CAudioLoRaConfig	Configuration for AudioLoRa
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
CAudioPlayerCommand
CAudioPlayerMimeSourceFromFile	MimeSource that determines the mime type from the file name extension of the file that an AudioPlayer is currently playing
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
CAudioPlayerThreadSafe	Lock-free asynchronous control wrapper for AudioPlayer using a command queue
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 minimal, single-client HTTP server that streams audio (or any other data) to a browser or media player: in -copy> client. The data is provided either from an Arduino Stream or via an AudioServerDataCallback, and is copied to the connected client on each doLoop()/copy() call, so no threads or blocking loops are used
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
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	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:
CAudioSourceSMB	An AudioSource that uses the SMBClient of the https://github.com/pschatzmann/TinySMB library to retrieve the files from a Windows, macOS, Samba or NAS share. You need to provide an SMBClient object to the constructor and make sure that you call begin() on it before you access the files
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!
CAudioSourceZephyr	AudioSource using Zephyr FS API (NO mounting, only uses mounted FS). Mount using the ZephyrSD class
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
CAudioTimer	Common Interface definition for AudioTimer
CAudioTimerDriverAVR	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer
CAudioTimerDriverBase
CAudioTimerDriverESP32	Repeating Timer functions for simple scheduling of repeated execution using esp_timer_create()
CAudioTimerDriverESP8266	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer
CAudioTimerDriverMBED	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer
CAudioTimerDriverRenesas	Repeating Timer functions for repeated execution: Plaease use the typedef AudioTimer. By default we use a new GPT timer. You can also request 1 AGT timer by calling setTimer(1);
CAudioTimerDriverSTM32	STM32 Repeating Timer functions for repeated execution: Please use the typedef AudioTimer. By default the TIM1 is used
CAudioTimerDriverZephyr	Repeating Timer driver for Zephyr using k_timer
CAudioTimeSourceStream	AudioTimeSourceStream: A stream that provides time information based on the audio data actually processed - implements the TimeSource interface. millis() (inherited, unmodified) is plain wall time; playbackTime() is the audio-derived progress, which is what a consumer that must stay tied to genuine playback (e.g. PacedVideoOutput) should use instead - see playbackTime()'s own comment for why they can diverge
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
CAutomaticGainControlStream	Slow automatic loudness normalization for PCM audio
CAutomaticGainControlStreamConfig	Configuration for AutomaticGainControlStream
CAVIMainHeader
CAVIStreamHeader
CBandPassFilter	Second-order band-pass filter (BiQuad DF2). Passes frequencies near the center frequency and attenuates those further away. The bandwidth is controlled by the Q factor: higher Q produces a narrower passband. Coefficients are derived from the Audio EQ Cookbook
CBandPassFilterDF1	Second-order band-pass filter (BiQuad DF1). Same coefficients as BandPassFilter; use this (not BandPassFilter) when T is a bounded fixed-point type like q1_14_t – see LowPassFilterDF1 for why
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
CBinState
CBinStateT
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
CBiQuadCoeffs	Biquad coefficients, always computed in float regardless of the filter's sample type T. Intermediate values like the angular cutoff frequency w0 range up to PI (~3.14) at Nyquist, which overflows bounded fixed-point sample types like q1_14_t (range ~[-2,2)); only the final, range-safe coefficients (typically within [-2,2) for a stable filter) get cast into T when assigned to a BiQuadDF1/BiQuadDF2 instance
CBiQuadDF1	Second-order IIR filter in Direct Form I. Maintains separate input and output histories (x and y delay lines). Requires more memory than DF2 but is less susceptible to quantization issues with fixed-point arithmetic
CBiQuadDF2	Second-order IIR filter in Direct Form II. Uses a single delay line, requiring less memory than DF1. This is the base class for the ready-to-use filter types (LowPassFilter, HighPassFilter, BandPassFilter, NotchFilter, LowShelfFilter, HighShelfFilter) which compute their coefficients from frequency, sample rate and Q/gain parameters
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]
CBufferBlocking	Buffer implementation which provides the same blocking, thread-safe semantics as BufferRTOS (ESP32/STM32) and BufferZephyr, for platforms that have no native blocking stream buffer primitive - built on a SpinLock-protected RingBuffer plus a delay(1) polling wait loop
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
CBufferZephyr	Buffer implementation using Zephyr semaphores + mutex as a bounded ring buffer
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 and updating data. The callbacks can be lambda expressions. The update callback can also be used just to read the data without changing it. 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!
CCameraFrameSource	VideoFrameSource that pulls frames from the ESP32 camera (esp_camera.h, the Arduino-ESP32 "esp32-camera" component) - nextFrame() returns esp_camera_fb_get()'s buffer, releasing the previous frame (esp_camera_fb_return()) first; as with any VideoFrameSource, the returned pointer is only valid until the next nextFrame() call
CCameraFrameSourceOpenCV	VideoFrameSource that pulls frames from an OpenCV cv::VideoCapture (e.g. a USB/CSI webcam via V4L2 on Linux/Raspberry Pi, or any other OpenCV-supported backend) - the desktop/Linux counterpart to CameraFrameSource, which targets the ESP32 esp_camera.h driver instead
CCameraFrameSourceTinyCamera	VideoFrameSource that pulls frames from a camera via TinyCamera (https://github.com/pschatzmann/TinyCamera) - so it works on every platform TinyCamera supports (ESP32 via esp32-camera, ESP32-P4 MIPI-CSI via ESP_Video, RP2040, STM32, desktop). nextFrame() returns the buffer of a freshly captured frame, returning the previous one to the driver first; as with any VideoFrameSource, the returned pointer is only valid until the next nextFrame() call
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. If you set beginReset to true in the constructor, the system will automatically reset the streams when begin() is called
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
CChannelBinDiffState
CChannelBinDiffStateT
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
CChunkedPrint	Wraps a Print target and applies HTTP chunked transfer encoding framing (chunk-size in hex + CRLF + data + CRLF) to everything that is written to it. see https://en.wikipedia.org/wiki/Chunked_transfer_encoding
CChunkedSampleTableStore	RAM-backed like RamSampleTableStore, but grows by allocating additional fixed-size chunks instead of reallocating and copying one single growing array
CClient
CCodec2Decoder	Decoder for Codec2. Depends on https://github.com/pschatzmann/codec-codec2
CCodec2Encoder	Encoder for Codec2 - Depends on https://github.com/pschatzmann/codec-codec2
CCodecChain	CodecChain - allows to chain multiple decoders and encoders together
CCodecCopy
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
CConverterInvert	Inverts the signal (multiplies every sample by -1)
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
CCountingPrint	Minimal Print wrapper that counts the bytes actually written to the wrapped output. Used by WAVEncoder to track the number of encoded bytes an external AudioEncoderExt has emitted, since AudioEncoder::write() reports the number of raw PCM input bytes it accepted, not the number of encoded bytes it produced (these differ for compressing formats like ADPCM)
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)
CDecimateState
CDecimateStateT
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/codec-g7xx 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/codec-helix. 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<SineGenerator<int16_t>>> *channel = new DefaultSynthesizerChannel<AudioEffects<SineGenerator<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
CDemuxer	Common interface for demuxers (DemuxerAVI, DemuxerMP4) that split a container's video and (optional) audio tracks apart. Write code against this interface instead of a concrete class if it should work with either container format
CDemuxerAVI	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
CDemuxerMP4	DemuxerMP4 extracts both the audio and (H.264) video track from a general, interleaved MP4/ISO-BMFF stream - unlike M4AAudioDemuxer/ M4AAudioFileDemuxer, which only handle a single (audio) track
CStscEntry	Sample-to-chunk table entry (stsc)
CSttsEntry
CTrack	One track (audio or video) as found in 'moov'
CDemuxerMPG	MPEG-1 System (Program) Stream Demuxer, as defined by ISO/IEC 11172-1: splits the pack_header/system_header/PES_packet framing apart and forwards the raw MPEG-1 video (ISO/IEC 11172-2) and MPEG-1 audio (ISO/IEC 11172-3, Layer I/II/III) elementary streams to setOutputVideo()/ setOutputAudio(). Both elementary streams are self-delimiting (the video ES has its own picture_start_code sequence, the audio ES its own frame sync word) so, like DemuxerAVI/DemuxerMP4, no separate decoding is done here - point the outputs at whatever decoder understands the codec (e.g. an MPEG1 video decoder, or an EncodedAudioStream wrapping an MP3/MP2 AudioDecoder)
CDemuxerMTS	ISO/IEC 13818-1 MPEG Transport Stream Demuxer: parses the fixed 188-byte TS packet framing, follows PAT -> PMT to discover the video and (optional) audio elementary stream PIDs and their codec (stream_type), reassembles each PES packet's payload from the TS packets between one payload_unit_start_indicator and the next, and forwards the raw elementary-stream bytes to setOutputVideo()/setOutputAudio() - same scope and design as DemuxerMPG (ContainerMPG.h): no decoding happens here, point the outputs at whatever decoder understands the codec
CDistortion	Distortion AudioEffect
CDSFDecoder	Decodes DSF files containing DSD audio and converts to PCM
CDSFEncoder	DSF (DSD Stream File) format encoder
CChannelModState
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
CEchoState	Internal echo canceller state structure
CEffectSuiteBase	Base Class for Effects
CEmulated_TinyUSB	Minimal wrapper around the ESP32 TinyUSB API. We emulate the basic functionality so that we can use the same TinyUSBDevice API on RP2040 and ESP32
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/codec-g7xx
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
CEqualizer3BandsPerChannelT	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
CEqualizer3BandsT	3 Band Equalizer with identical settings for all channels
CEQSTATE	Filter state for each channel
CEqualizerNBands	N-Band Equalizer using FIR filters with logarithmically spaced bands
CEQFIRFilter
CESP3288AudioOutput	Stream Adapter for ESP8288-Audio AudioOutput
CESPNowStream	ESPNow as Arduino Stream. When use_send_ack is true we prevent any buffer overflows by blocking writes until the previous packet has been confirmed. When no acknowledgments are used, you might need to throttle the send speed to prevent any buffer overflow on the receiver side
CESPNowStreamConfig	Configuration for ESP-NOW protocolö.W
CEthernetZephyr
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
CFastIntSineGenerator	Sine wave generator that does not use any floating point operations in the readSample() hot path: it advances a 32 bit phase accumulator with an integer increment and looks up the result in a Q15 fixed point table. All floating point math (converting frequency/sample_rate into the phase increment) is done once in setFrequency()/setAudioInfo(), never per sample. This makes it a good fit for MCUs without a hardware FPU - e.g. the RP2040 - where sinf() is comparatively expensive
CFastSineGenerator	Sine wave which is based on a fast approximation function using floating point math
CFaustStream	Integration into Faust DSP see https://faust.grame.fr/ To generate code from faust, select src and cpp
Cfft_state	FFT state management structure
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
CFFTDriverFixedFFT	Driver for the fixedpoint-fft library (https://github.com/pschatzmann/fixedpoint-fft). CalcT selects the calculation type used by the underlying engine: int8_t/int16_t/int32_t for fixed point Qn math (smallest/fastest, ideal for plain AVR), or float/double on FPU-equipped targets (ESP32, Cortex-M4F/M7, desktop). Defaults to int16_t (Q15), which gives good precision at any FFT size without needing an FPU. The FFTDriver interface itself is always float, so values are rescaled into/out of CalcT's Qn range on the way in/out via fixedpoint_fft::fftConvertSample
CFFTDriverKissFFT	Driver for RealFFT
CFFTDriverRealFFT	Driver for RealFFT
CFFTEffect	Abstract base class for effects that operate on audio in the frequency domain: incoming samples are transformed with a forward FFT, the resulting bins are modified by the effect() method that a subclass implements, and the modified spectrum is transformed back with an inverse FFT (overlap-add) and streamed to the output
CFFTEffectConfig	Common configuration for FFT effects
CFFTEqualizer	Graphic Equalizer implemented as an FFT effect: boosts or cuts logarithmically spaced frequency bands (20Hz .. Nyquist) by scaling the magnitude of the bins that fall into each band while leaving their phase untouched. Since this operates directly on the frequency-domain bins rather than an FIR/IIR approximation, band edges are exact and there is no filter ripple
CFFTEqualizerConfig	Equalizer FFT Effect Configuration
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 Whisper FFT Effect on frequency domain data: keep the magnitude of each bin but randomize its phase. 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
CFileSeekableSource	Adapts a single concrete file/stream (Arduino's File, or anything else exposing position(), seek(size_t) and a readBytes(size_t) overload) to SeekableSource, and also drives feeding that same file's bytes into a DemuxerMP4 (or any other AudioWriter with a setSeekSource(SeekableSource&) method) via copy() - replacing the separate CodecCopy/StreamCopy a sketch would otherwise need, and letting this class use just one File for everything instead of requiring two independent handles (one for sequential forward reads, one for the out-of-band seeks SourceSeekSampleTableStore performs)
CFileSpoolStorage	Adapts any concrete file/stream type to SpoolStorage - same role as FileSeekableSource, just adding write(). This is the one place the concrete file type appears for spool-backed storage
CFilter	Abstract filter interface definition. Subclasses implement process() to transform audio samples one at a time. Use reset() to clear internal state (e.g. delay lines) without changing the filter coefficients
CFilterChain	A cascade of N arbitrary filters applied in series. Each sample is passed through all filters in order. The caller owns the filter pointers and must ensure they outlive the chain
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
CFilterSampleConverter	Converts a raw sample (type T) to/from a filter's arithmetic type (FT) for ConverterNChannels. The default just casts the raw sample straight through – this matches the traditional convention used here, where FT=float and filter coefficients are calibrated against the sample's raw magnitude (e.g. up to +-32767 for 16-bit audio), so no rescaling is wanted. Specialized below for FT=q1_14_t, whose bounded ~[-2,2) range means a plain (q1_14_t)sample cast would misinterpret the raw PCM magnitude as a literal Q1.14 value and saturate almost immediately; q1_14_t::fromIntNN()/toIntNN() do the correct bit-shift scaling instead
CFilterSampleConverter< int16_t, q1_14_t >
CFilterSampleConverter< int24_t, q1_14_t >
CFilterSampleConverter< int32_t, q1_14_t >
CFIR	Finite Impulse Response (FIR) filter. Performs convolution of the input signal with a set of feedforward coefficients b[]. For integer types, an optional scaling factor is applied to preserve precision. You can use https://www.arc.id.au/FilterDesign.html to design the coefficients
CFLACDecoder	Decoder for FLAC. Depends on https://github.com/pschatzmann/codec-flac. 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	Half-precision IEEE-754 binary16 float compressed into 2 bytes (1 sign + 5 exponent + 10 mantissa bits, no infinity/NaN encoding), used to halve the memory footprint of large float buffers (e.g. sample or FFT data) at the cost of precision: range +-131008.0, minimum positive normal ~6.1035156E-5, ~3.3 significant decimal digits. Unlike float32, this is a genuinely lossy compression – converting a value in and back out will generally not return the exact original float
Cfloat32	A plain 32-bit float's bit pattern reinterpreted as a uint32_t, so instances can live in memory obtained from a capability-specific allocator (e.g. ESP32's MALLOC_CAP_32BIT, which some heap regions require for word-addressed access and won't necessarily hand out for a plain float array). Conversion to/from float is a zero-cost bitwise reinterpretation (see as_uint()/as_float()), not an encoding – unlike float16, this class is bit-for-bit identical to float and loses no precision or range; it exists purely to control storage/allocation, not to compress data
CFloatAudio
CFloatSineGenerator	Generates a Sound with the help of sin() function. If performance is of concern, I suggest to use theSineFromTable, the FastSineGenerator or the FastIntSineGenerator
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
CFrequencyFrame
CFuzz	Fuzz AudioEffect
CG711_ALAWDecoder	64 kbit/s g711 ALOW Decoder based on https://github.com/pschatzmann/codec-g7xx
CG711_ALAWEncoder	64 kbit/s g711 ALOW Encoder based on https://github.com/pschatzmann/codec-g7xx
CG711_ULAWDecoder	64 kbit/s g711 ULOW Decoder based on https://github.com/pschatzmann/codec-g7xx
CG711_ULAWEncoder	64 kbit/s g711 ULOW Encoder based on https://github.com/pschatzmann/codec-g7xx
CG711Decoder	64 kbit/s g711 ULOW Decoder based on https://github.com/pschatzmann/codec-g7xx Supported decoder parameters: alaw2linear, ulaw2linear
CG711Encoder	64 kbit/s g711 ULOW Encoder based on https://github.com/pschatzmann/codec-g7xx Supported encoder parameters: linear2alaw2, linear2ulaw
CG721Decoder	32Kbps G721 Decoder based on https://github.com/pschatzmann/codec-g7xx
CG721Encoder	32Kbps G721 Encoder based on https://github.com/pschatzmann/codec-g7xx
CG722Decoder	Decoder for G.722. Depends on https://github.com/pschatzmann/codec-g722
CG722Encoder	Encoder for G.722 - Depends on https://github.com/pschatzmann/codec-g722. Inspired by g722enc.c
CG723_24Decoder	24Kbps G723 Decoder based on https://github.com/pschatzmann/codec-g7xx
CG723_24Encoder	24Kbps G723 Encoder based on https://github.com/pschatzmann/codec-g7xx
CG723_40Decoder	40Kbps G723 Decoder based on https://github.com/pschatzmann/codec-g7xx
CG723_40Encoder	40Kbps G723 Encoder based on https://github.com/pschatzmann/codec-g7xx
CG729Decoder	G.729 decoder using the bcg729 library
CG729Encoder	G.729 encoder using the bcg729 library
CG7xxDecoder	G723_24, g721, g723_40 Decoder based on https://github.com/pschatzmann/codec-g7xx
CG7xxEncoder	G723_24, g721, g723_40 Encoder based on https://github.com/pschatzmann/codec-g7xx
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
CGeneratorQueue	Queues SoundGenerators and plays them sequentially. Queued SoundGenerators must be limited (eg: setPlayTime()) or no later Generator will ever be played
CQNode
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/codec-gsm. Inspired by gsmdec.c
CGSMEncoder	Encoder for GSM - Depends on https://github.com/pschatzmann/codec-gsm. Inspired by gsmenc.c
CH264Decoder	H.264 video decoder: wraps TinyH264Decoder (https://github.com/pschatzmann/TinyH264) as a VideoOutput, so it can be plugged directly into e.g. DemuxerAVI::setOutputVideo()/ DemuxerMP4::setOutputVideo(). Consumes an Annex-B H.264 bitstream via write() and, once a complete picture has been decoded, writes it - converted to setVideoFormat()'s format (RGB565 by default, the common TFT wire format) - to the Print target configured via setOutput(), one write() call per decoded picture
CH264DecoderESP32S3	H.264 video decoder for ESP32-S3: wraps esp_h264::H264Decoder (https://github.com/pschatzmann/ESP32S3-h264) as a VideoOutput, so it can be plugged directly into e.g. DemuxerAVI::setOutputVideo()/ DemuxerMP4::setOutputVideo() - the same role H264Decoder (CodecH264.h, the portable TinyH264-based decoder) plays, for boards where the ESP32-S3-specific esp_h264 backend is preferred instead. Consumes an Annex-B H.264 bitstream via write() and, once a complete picture has been decoded, writes it - converted to setVideoFormat()'s format (RGB565 by default, the common TFT wire format) - to the Print target configured via setOutput(), one write() call per decoded picture
CH264Encoder	H.264 video encoder: wraps TinyH264Encoder (https://github.com/pschatzmann/TinyH264). Configure via setSize()/ setQp() (or setTargetBitrate() for rate control) same as TinyH264Encoder and setVideoFormat() for the raw picture format write() expects (I420 - planar Y/U/V concatenated in one buffer - by default), then feed raw pictures via write() - the resulting Annex-B bitstream is written to the Print target configured via setOutput() (e.g. a Muxer's addVideoFrame() by way of an adapter, or any other Print) instead of a caller-supplied buffer
CH264EncoderESP32P4	H.264 video encoder for ESP32-P4: wraps esp_h264_p4::H264EncoderP4 (https://github.com/pschatzmann/codec-h264-ESP32P4), which drives ESP32-P4's dedicated H.264 hardware encoder block - the ESP32-P4-specific counterpart of H264Encoder (CodecH264.h, the portable TinyH264-based software encoder) and a hardware-backed sibling of H264EncoderESP32S3 (whose wrapped esp_h264::H264Encoder is software-only, since the S3 has no H.264 hardware block)
CDualOutputPrint
CH264EncoderESP32S3	H.264 video encoder for ESP32-S3: wraps esp_h264::H264Encoder (https://github.com/pschatzmann/ESP32S3-h264) - the ESP32-S3-specific counterpart of H264Encoder (CodecH264.h, the portable TinyH264-based encoder). Configure via setSize()/setFrameRate()/setBitrate()/ setGop()/setQpRange()/setVideoFormat() (I420 - the default -, RGB565 or YUV422), then feed raw pictures via write() - it writes the resulting Annex-B bitstream straight to the Print target passed to setOutput() (the underlying esp_h264::H264Encoder methods already take a Print& and handle the write, retrying on partial writes - see H264Encoder.h's encode())
CDualOutputPrint
CH264RtpEncoder	H.264 RTP Encoder - Packetizes Annex-B H.264 access units per RFC 6184 for RTSP video streaming
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	Second-order high-pass filter (BiQuad DF2). Attenuates frequencies below the cutoff frequency. Coefficients are derived from the Audio EQ Cookbook
CHighPassFilterDF1	Second-order high-pass filter (BiQuad DF1). Same coefficients as HighPassFilter; use this (not HighPassFilter) when T is a bounded fixed-point type like q1_14_t – see LowPassFilterDF1 for why
CHighShelfFilter	Second-order high-shelf filter (BiQuad DF2). Boosts or cuts frequencies above the shelf frequency by the specified gain (in dB) while leaving lower frequencies unchanged. Commonly used in tone controls and equalization. Coefficients are derived from the Audio EQ Cookbook
CHighShelfFilterDF1	Second-order high-shelf filter (BiQuad DF1). Same coefficients as HighShelfFilter. NOTE: unlike the other DF1 filters here, this is NOT a working fix for q1_14_t (or similar bounded fixed-point types) – see the
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
CI2SConfigZephyr	Configuration for i2s
CI2SDriverBase
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
CI2SDriverZephyr	Basic I2S API for Zephyr based targets
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..
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	Infinite Impulse Response (IIR) filter. Uses both feedforward (b[]) and feedback (a[]) coefficients. The a[0] coefficient is used to normalize all other coefficients. For integer types, an optional scaling factor is applied to preserve precision
CILBCDecoder	Decoder for iLBC. Depends on https://github.com/pschatzmann/libilbc
CILBCEncoder	Encoder for iLBC - Depends on https://github.com/pschatzmann/libopenilbc
CIMAState
CIMediaSource	Media Source Interface - Contract for Media Data Providers
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
CIPAddress	Arduino-compatible IPAddress class implemented in pure C++
CITask	Interface for a task that can be started and stopped
CJPEGRtpEncoder	JPEG RTP Encoder - Fragments JPEG frames per RFC 2435 for RTSP video streaming
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/codec-lc3
CLC3Encoder	Encoder for LC3 - Depends on https://github.com/pschatzmann/codec-lc3
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
CLMSEchoCancellationStream	Echo cancellation with adaptive LMS filtering for microcontrollers
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
CLowPassFilter	Second-order low-pass filter (BiQuad DF2). Attenuates frequencies above the cutoff frequency. Coefficients are derived from the Audio EQ Cookbook
CLowPassFilterDF1	Second-order low-pass filter (BiQuad DF1). Same coefficients as LowPassFilter, but built on BiQuadDF1, whose separate x[]/y[] delay lines stay bounded to the actual signal range – unlike DF2's single delay line, which can need far more dynamic range than the signal for low cutoff/ sampleRate ratios. Use this (not LowPassFilter) when T is a bounded fixed-point type like q1_14_t
CLowShelfFilter	Second-order low-shelf filter (BiQuad DF2). Boosts or cuts frequencies below the shelf frequency by the specified gain (in dB) while leaving higher frequencies unchanged. Commonly used in tone controls and equalization. Coefficients are derived from the Audio EQ Cookbook
CLowShelfFilterDF1	Second-order low-shelf filter (BiQuad DF1). Same coefficients as LowShelfFilter. NOTE: switching to DF1 does NOT make this reliable for bounded fixed-point types like q1_14_t – shelf coefficients scale with the linear gain factor and can exceed the type's range even at modest gain settings; this is a coefficient headroom problem, not the DF2 state-headroom problem DF1 fixes elsewhere. Watch for the LOGE warning from checkCoeffRange() in begin()
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
CMDFEchoCancellation	Acoustic echo canceller using MDF algorithm
CMDFEchoCancellationStream	MDF (Multi-Delay block Frequency) echo cancellation with stream API
CMDFFixedPoint	Selects soft_float_t (see soft_float_t.h) as MDFEchoCancellation's internal numeric representation, so the algorithm runs on integer mantissa/exponent arithmetic instead of native float instructions – useful on microcontrollers without an FPU. soft_float_t's arithmetic is verified against native float directly (see the soft_float_t tests in tests-cmake/stt/stt_test.cpp), and MDFEchoCancellation<int16_t, MDFFixedPoint> is smoke-tested to run without crashing/NaN and to converge similarly to MDFFloat on the same synthetic signal – but it has not received the same depth of numerical scrutiny as MDFFloat, so treat it as less battle-tested. Despite the name, this is not a classic narrow Q15 fixed-point format (that would over/underflow across this algorithm's actual value range – see soft_float_t's class doc for why)
CMDFFloat	Selects float as MDFEchoCancellation's internal numeric representation for sample/spectrum arrays (word16_t/word32_t) and wide-dynamic-range control state (float_t). This is the default, and the one that has been verified to converge (see test_mdf_converges in tests-cmake/stt/stt_test.cpp) – prefer it unless you specifically need to avoid hardware floating-point instructions (e.g. no FPU)
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
CID3v2Header	ID3 verion 2 TAG Header (10 bytes)
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, audio/ac3, audio/eac3). 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/
CMixGain	Mixing of multiple audio input streams into a single output stream
CMJPEGDecoder	Motion-JPEG video decoder: wraps TinyJPEGDecoder (https://github.com/pschatzmann/TinyJPEG, a header-only port of ChaN's TJpgDec) as a VideoDecoder, so it can be plugged directly into e.g. DemuxerAVI::setOutputVideo()/DemuxerMP4::setOutputVideo() - the same role H264Decoder (CodecH264.h) and MPGDecoder (CodecMPG.h) play for their own codecs. Named "MJPEGDecoder" rather than reusing TinyJPEGDecoder's own name to avoid shadowing that class from within this one
CMJPEGEncoder	Motion-JPEG video encoder: wraps TinyJPEGEncoder (https://github.com/pschatzmann/TinyJPEG) as a VideoEncoder - the MJPEG counterpart of H264Encoder (CodecH264.h), e.g. for VideoMuxer/ VideoMuxerWithTasks with a camera that delivers raw pictures. Configure it via setSize()/setVideoFormat() (RGB565 - the default -, RGB888 or RGB666, packed) and optionally setQuality()/setSubsample(), then feed raw pictures via write(): each one is encoded into one complete JPEG image, which is written to the target configured via setOutput() in a single write() call - as the muxers expect one frame per call
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
CMP2Decoder	Decoder for MPEG-1 Layer II (MP2) audio using the TinyMP2 library. Compressed data provided via write() does not need to be aligned on frame boundaries: bytes are accumulated internally and decoded frame by frame; any invalid/garbage bytes are skipped automatically (resync)
CMP3DecoderHelix	MP3 Decoder using libhelix: https://github.com/pschatzmann/codec-helix This is basically just a simple wrapper to provide AudioInfo and AudioInfoSupport
CMP3DecoderMAD	MP3 Decoder using https://github.com/pschatzmann/codec-mad
CMP3DecoderMini	MP3 Decoder using https://github.com/pschatzmann/codec-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/codec-lame
CFrameWriter	Receives the output of LAME and passes it on in complete MP3 frames
CMP3EncoderShine	Lean MP3 Encoder using the shine library
CMP3ParserEncoder	Parses MP3 frames, extracts audio info, and outputs complete frames. The frame duration is determined e.g. for RTSP streaming
CMP4BoxWriter	Minimal ISO-BMFF box builder: appends bytes to an in-memory buffer, with beginBox()/endBox() taking care of the 4-byte size prefix (backpatched once the box's content is known) - used internally by MuxerMP4 to assemble 'moov' once and each 'moof' per fragment
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
CMPGDecoder	MPEG-1 (part 2) video decoder wrapper around TinyMPGDecoder
CMPGEncoder	MPEG-1 part 2 video encoder wrapper around TinyMPGEncoder
CMPGParseBuffer	Minimal byte accumulator used by DemuxerMPG to parse start-code delimited units that may straddle write() calls - analogous to (but simpler than, since Program Stream framing has no nested LIST/CHUNK structure) ContainerAVI.h's ParseBuffer
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/codec-tsdemux
CMTSParseBuffer	Minimal byte accumulator used by DemuxerMTS to buffer incoming bytes until at least one full 188-byte TS packet is available - analogous to ContainerMPG.h's MPGParseBuffer, but without any start-code search (TS packets are fixed-size and found via their own resync logic in DemuxerMTS::parse() instead)
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
CMultiOutputRecord	Record describing a single replicated output
CMultiStreamingDecoder	Manage multiple StreamingDecoders with automatic format detection
CDecoderInfo	Information about a registered decoder
CMultiVideoDecoder	Manages multiple VideoDecoders with automatic format detection - the video-side counterpart of MultiDecoder (AudioCodecs/MultiDecoder.h). No decoders are registered by default and this header has no codec- library dependency of its own - register whatever your content needs via addDecoder(), or use MultiVideoDecoderFull (MultiVideoDecoderFull.h) for one pre-registered with every video codec this library ships a portable (no hardware-specific backend) software decoder for (H264/MJPEG/MPEG-1)
CDecoderInfo
CMultiVideoDecoderFull	MultiVideoDecoder pre-registered with every video codec this library ships a portable (no hardware-specific backend) software decoder for: MJPEGDecoder (Motion-JPEG, TinyJPEG, CodecJPEG.h), MPGDecoder (MPEG-1, TinyMPG, CodecMPG.h), H264Decoder (H.264 Annex-B, TinyH264, CodecH264.h) - drop it into a demuxer's setOutputVideo() the same way any single decoder would go, and it self-selects the right one from the bitstream's own framing instead of the caller having to know the codec up front. Use the plain MultiVideoDecoder (MultiVideoDecoder.h) instead if you don't want all three codec libraries pulled in unconditionally - register only what your content actually needs via its own addDecoder()
CMultiVideoDemuxer	Manages multiple Demuxers with automatic container-format detection - the container-side counterpart of MultiVideoDecoder (Video/MultiVideoDecoder.h), which does the same job one layer down for the video elementary stream's own codec. No demuxers are registered by default and this header has no container-parser dependency of its own (it only needs the Demuxer interface, ContainerCommon.h) - register whichever concrete demuxers (DemuxerAVI/DemuxerMP4/DemuxerMPG) your content actually needs via addDemuxer()
CMultiVideoDemuxerFull	MultiVideoDemuxer pre-registered with every container format this library ships a demuxer for: DemuxerAVI (RIFF/AVI, AudioCodecs/ContainerAVI.h), DemuxerMP4 (ISO base media/MP4, AudioCodecs/ContainerMP4.h), DemuxerMPG (MPEG Program Stream, AudioCodecs/ContainerMPG.h), DemuxerMTS (MPEG Transport Stream, AudioCodecs/ContainerMTS.h) - drop it in wherever a plain Demuxer& is expected (VideoPlayer in fact uses one internally as its own built-in demuxer) and it self-selects the right one from the stream's own container signature instead of the caller having to know the file format up front. Use the plain MultiVideoDemuxer (MultiVideoDemuxer.h) instead if you don't want all four container parsers pulled in unconditionally - register only what your content actually needs via its own addDemuxer()
CMusicalNotes	Determination of the frequency of a music note
CMutexBase	Empty Mutex implementation which does nothing
CMutexRecursiveRTOS	Recursive Mutex implemntation using FreeRTOS
CMutexRecursiveZephyr	Recursive Mutex implementation using Zephyr kernel mutex
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
CMutexZephyr	Mutex implementation using Zephyr kernel mutex
CMuxer	Common interface for muxers (MuxerAVI, MuxerMP4) that combine an already-encoded video track (and optionally an audio track) into a container written to a Print (a local File to record, or e.g. a network Client to publish a live stream to an HTTP/TCP client). Write code against this interface instead of a concrete class if it should work with either container format
CMuxerAudioSink	Print adapter that writes each write() call to a Muxer as one audio frame (Muxer::addAudioFrame()) - e.g. the output of an AudioEncoder, since a Muxer is a VideoOutput, not a Print
CMuxerAVI	Configuration for the (single) video track written by MuxerAVI
CMuxerMP4	Video track configuration for MuxerMP4 - update before calling begin()
CMuxerMPG	MPEG-1 System (Program) Stream Encoder, as defined by ISO/IEC 11172-1: muxes an already-encoded MPEG-1 video elementary stream (ISO/IEC 11172-2) and an optional MPEG-1 audio elementary stream (ISO/IEC 11172-3, Layer I/II/III) into pack_header/system_header/PES_packet framing written to a Print (a local File to record, or e.g. a network Client to publish a live stream)
CMuxerMTS	ISO/IEC 13818-1 MPEG Transport Stream Encoder: packetizes an already-encoded video elementary stream (H.264 by default - see MuxerVideoConfig::format) and an optional audio elementary stream (AAC ADTS by default - see setAudioInfo()) into 188-byte TS packets, with a PAT and PMT describing the one program/two streams, written to a Print (a local File to record a .ts, or e.g. a network Client to publish a live/HLS-segment stream)
CMuxerVideoConfig	Shared video track configuration for muxers (MuxerAVI, MuxerMP4) - call before begin()
CMuxerVideoSink	Print sink that writes each frame it receives to a Muxer's video track via addVideoFrame(), determining a real isKeyFrame value instead of relying on that method's isKeyFrame=true default - via isH264KeyFrame() (Video.h) when the Muxer's video track is VideoFormat::H264, otherwise always true (correct for e.g. MJPEG, where every frame is independently decodable)
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 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	Passes the input through unchanged. Useful as a placeholder when a Filter is required but no processing is desired
CNoInterruptHandler	Disable, enable interrupts (only on the actual core)
CNOPConverter	Dummy converter which does nothing
CNotchFilter	Second-order notch (band-reject) filter (BiQuad DF2). Rejects frequencies near the center frequency and passes those further away. Useful for removing a specific unwanted frequency (e.g. mains hum at 50/60 Hz). Coefficients are derived from the Audio EQ Cookbook
CNotchFilterDF1	Second-order notch (band-reject) filter (BiQuad DF1). Same coefficients as NotchFilter; use this (not NotchFilter) when T is a bounded fixed-point type like q1_14_t – see LowPassFilterDF1 for why
CNRF24Config	NRF24L01 Audio Configuration optimized for low-latency audio streaming. Uses the RF24 library from TMRh20: https://github.com/nRF24/RF24
CNRF24Stream	NRF24L01(+) Stream for sending and receiving audio via the nRF24L01 2.4GHz radio module. Optimized for low-latency, high-throughput audio with small 32-byte packets
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	An 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/codec-opus
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/codec-opus
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
COpusMultiStreamAudioDecoder	Decoder for the Opus multistream audio format. Supports up to 255 channels by combining multiple Opus streams into a single packet. Each Opus frame must be provided with one write() call
COpusMultiStreamAudioEncoder	Encoder for Opus multistream audio. Supports up to 255 channels by combining multiple Opus streams into a single packet. Each fully encoded frame is written to the output stream
COpusMultiStreamEncoderSettings	Settings for Opus MultiStream Encoder
COpusMultiStreamSettings	Settings for Opus MultiStream Decoder
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/codec-opus
COpusOggEncoder	Opus Encoder which uses the Ogg Container: see https://datatracker.ietf.org/doc/html/rfc7845 Dependency: https://github.com/pschatzmann/codec-opus
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
COutputFPSMeter	Wraps a VideoOutput (typically a codec decoder, e.g. H264Decoder/ MJPEGDecoder/MPGDecoder or a MultiVideoDecoder) and measures how long decoding+outputting each frame actually takes - forwards every write()/ flush()/setSkipRender()/isKeyFrame() call unmodified to the wrapped target, but times write()+flush() together and classifies the result I- vs P-frame via the target's own isKeyFrame(), the same way PacedVideoOutput classifies frames for its own frameCountI()/ frameCountP() stats
COutputMixer
COutputOpenCV	Display a video frame with OpenCV, to be used on the desktop - VideoFormat::MJPEG (the default) expects one complete, already-encoded JPEG image assembled across write() calls and closed off by flush(), as produced by e.g. DemuxerAVI. Any other setVideoFormat() value (e.g. RGB565, the common raw picture format decoders like H264Decoder produce) expects one complete, already-decoded picture per write() call instead - setSize() must be called too in that case, since unlike JPEG a raw picture doesn't carry its own dimensions
COutputTest	Print sink that logs the length and a hex preview (first/last 10 bytes) of every write() call instead of actually outputting the data - useful for verifying that video/audio codecs and containers are feeding plausible data without needing a real display or audio device
COutputTFT_eSPI	Bridges VideoDecoder's write() calls to the TFT - VideoDecoder always hands over one complete frame per write() call (see its class comment), so this can push the whole frame in one go. Usually the data is in RGB565 format, but other formats are supported as well
COutputTinyGPU	Bridges VideoDecoder's write() calls to a TinyGPU DisplayDriver (e.g. ILI9341Driver, or any board wrapped in an LCDBoard - see the LCDBoard constructor) - VideoDecoder always hands over one complete frame per write() call (see its class comment), so this can push the whole frame in one go. Usually the data is in RGB565 format, but other formats are supported as well
CPacedVideoOutput	Buffers a small, configurable amount of video (see setQueueBytes()) and renders it frame by frame from a dedicated background task, timed against an audio clock - so a demuxer's own dispatch loop never blocks on video pacing. Wrap the real VideoOutput (e.g. H264Decoder) in this and pass it to setOutputVideo() instead of the decoder itself
CFrameHeader
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
CPWMConfigAVR	Configuration data for PWM audio output
CPWMConfigSTD	Configuration data for PWM audio output
CPWMConfigZephyr	Configuration data for PWM audio output. Define the pins as follows: config.pins = {PWM_PIN(pwm_led_0), PWM_PIN(pwm_led_2)}; which is a short for for the zephyr standard macros: config.pins = {PWM_DT_SPEC_GET(DT_NODELABEL(pwm_led_0)), PWM_DT_SPEC_GET(DT_NODELABEL(pwm_led_1))};
CPWMDriverAVR	Experimental: Audio output to PWM pins for the AVR. The AVR supports only up to 2 channels
CPWMDriverBase	Base Class for all PWM drivers
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
CPWMDriverZephyr	Audio output to PWM pins for Zephyr RTOS
Cq1_14_t	Fixed-point Q1.14 number: a plain 16-bit signed integer holding 1 integer bit and 14 fractional bits (value = raw / 16384.0). Covers the range [-2.0, 1.99993896484375] with a resolution of ~6.1e-5, using only integer add/sub/mul/div – no hardware floating-point instructions
CQualityAnalysisStream	Analyzes audio stream quality by detecting clicks/pops, gaps/dropouts, clipping/corruption, and whether the signal is genuine audio or just noise
CQualityStats	Statistics collected by QualityAnalysisStream
CQueue	FIFO Queue which is based on a List
CQueueFromVector	FIFO Queue which is based on a Vector
CQueueLockFree	Lock-free MPMC 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();
CQueueZephyr	FIFO Queue implementation based on Zephyr message queues
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
CRadioHeadStream	Arduino Stream which is using the RadioHead library to send and receive data. We use the driver API directly
CRamSampleTableStore	Keeps every entry in RAM (a plain Vector<T>) - the simplest and fastest option, but scales with the track's total sample/chunk count (e.g. ~4.5MB total for a 102-minute movie's stsz+stco tables). Default if no other SampleTableStore is configured
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
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
CRingBufferSPSC	Lock-free Single-Producer Single-Consumer ring buffer
CRingBufferStream	An AudioStream backed by a Ringbuffer. We can write to the end and read from the beginning of the stream
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
CRTSPFormatH264	H.264 (AVC) format for RTSP video streaming, per RFC 6184
CRTSPFormatMJPEG	MJPEG (Motion JPEG) format for RTSP video streaming
CRTSPFormatMP3	MP3 format for RTSP https://en.wikipedia.org/wiki/RTP_payload_formats
CRTSPFormatMTS	MPEG-2 Transport Stream (MP2T) format for RTSP streaming of a pre-muxed audio+video container, per RFC 2250
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
CRTSPFragmentQueue	Self-delimited fragment queue shared by packetized RTP video encoders (JPEGRtpEncoder, H264RtpEncoder, ...)
CRTSPMediaCallbackSource	Callback-based RTSP Media Source
CRTSPMediaSource	Unified RTSP Media Source - Works with both Stream and AudioStream
CRTSPMediaSourceMTS	IMediaSource for an MPEG transport stream, e.g. live video and audio muxed by MuxerMTS: the muxer writes its output to this object (it is a Print), and an RTSPMediaStreamer sends it as one RTP track (MP2T, RFC 2250 - see RTSPFormatMTS) to the RTSP client, which demuxes video and audio itself
CRTSPMediaStreamer	RTSPMediaStreamer - Timer-driven RTP Media Streaming Engine
CRTSPMediaStreamerBase	RTSPMediaStreamerBase - Core RTP Media Streaming Engine
CRTSPMediaStreamerTaskless	RTSPMediaStreamerTaskless - Manual RTP Audio Streaming Engine (no Task)
CRTSPMediaStreamerUsingTask	RTSPMediaStreamerUsingTask - Task-driven RTP Media Streaming Engine
CRTSPOutput	RTSPOutput - Audio Output Stream for RTSP Streaming
CRTSPPlatform	Template-based platform abstraction for RTSP networking
CRTSPServer	RTSPServer - Audio Streaming Server (task-based)
CRTSPServerBase	RTSPServerBase - Shared logic for RTSPServer and RTSPServerTaskless
CRTSPServerTaskless	RTSPServerTaskless - Manual RTSP Audio Streaming Server
CRtspSession	RTSP Session Handler - Individual Client Protocol Management
CRTSPVideoEncoder	Common base for RTP video payloaders (JPEGRtpEncoder, H264RtpEncoder, ...): an AudioEncoder that accepts complete video frames via write() and, as a packetized IMediaSource, hands the resulting RTP fragments back out through packetSize()/readBytes()
CRTSPVideoInfo	Video Information Structure
CRTSPVideoInfoSupport	Base class for video information support
CRTTTLOutput	RTTTL (Ring Tone Text Transfer Language) parser and player stream
CSampleTableStore	Sequential-access storage for one MP4 sample table (e.g. stsz sample sizes, stco chunk offsets, or the raw stsc/stts RLE entries). Every real access pattern in DemuxerMP4 is append-only while parsing 'moov', then forward-cursor reads while consuming 'mdat' - this interface intentionally only supports that (no random-access mutation, no delete), which is what keeps all three implementations below simple and correct
CSawToothGenerator	Generates a saw tooth wave sound. Uses a 32 bit phase accumulator with an integer increment, just like FastIntSineGenerator: no floating point operations or divisions in the readSample() hot path. Unlike a sine, a saw tooth needs no lookup table either - a wrapping unsigned accumulator reinterpreted as signed already is a linear ramp - so this is even cheaper than FastIntSineGenerator and a good fit for MCUs without a hardware FPU (e.g. RP2040), where the previous sinf()/float based implementation (inherited from SineGenerator) was comparatively expensive
CSBCDecoder	Decoder for SBC. Depends on https://github.com/pschatzmann/codec-sbc. Inspired by sbcdec.c
CSBCEncoder	Encoder for SBC - Depends on https://github.com/pschatzmann/codec-sbc. 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. Unfortunately 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
CSeekableSource	Minimal seek+read interface a SourceSeekSampleTableStore needs from "the original MP4 source" - kept deliberately tiny (no write, no generic Stream surface) and non-templated, so classes that only need to hold/pass a source around (like DemuxerMP4 itself) don't have to become templates just to support this one storage strategy
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
CSimpleContainerVideoConfig
CSimpleContainerVideoDataHeader
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
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
Csoft_float_t	Software "pseudo-float": a real number represented as a signed 16-bit mantissa plus a 16-bit exponent (value = mantissa * 2^exponent), computed with integer multiply/shift/compare only – no hardware floating-point instructions. This generalizes speexdsp's classic fixed-point trick of tracking a handful of wide-dynamic-range control variables as a normalized mantissa+exponent pair into a full, operator-overloaded numeric type usable as a drop-in replacement for float (see MDFFixedPoint in MDFEchoCancellation.h, which uses this class as the element type for the MDF echo canceller's sample/spectrum arrays and internal state, so the whole algorithm runs without native float arithmetic)
CSOSFilter	Second Order Sections (SOS) filter — a cascade of N BiQuad DF2 stages. Higher-order filters should be decomposed into second-order sections to avoid numerical instability. Each section has its own b[3]/a[3] coefficients and optional gain. Tools like scipy.signal.butter(..., output='sos') or MATLAB's tf2sos produce the required coefficient arrays
CSoundGenerator	Base class to define the abstract interface for the sound generating classes
CSoundGeneratorModulation	SoundGenerator using the ModulationBaseClass to generate the samples
CSourceSeekSampleTableStore	Discards every value right after appending it, keeping only the file offset of the first entry - get() seeks back into the original MP4 source and re-reads the entry directly (entries are fixed-size and contiguous on disk, so entry N sits at start_offset + N*sizeof(T)), trading RAM for repeated small seeks
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
CSPIAudioMaster	SPI master endpoint for remote audio sink configuration and PCM data transfer
CSPIAudioMasterConfig	Configuration for SPIAudioMaster
CSPIAudioSlave	SPI Audio Slave endpoint matching SPIAudioMaster protocol
CSPIAudioSlaveConfig	Configuration for SPIAudioSlave
CSpinLock	Busy-wait lock based on std::atomic - available on all platforms that support <atomic>
CSpoolFileSampleTableStore	Writes every entry to a caller-provided scratch file as it's appended, instead of keeping it in RAM - get() seeks that file and reads the entry back. Unlike SourceSeekSampleTableStore this needs no knowledge of (or seekability in) the original MP4 source - it works even when that source is a live, non-seekable stream, since it's writing its own local, sequential copy as data streams past. The tradeoff is disk I/O (both a write during parsing and a seek+read during playback) instead of a pure RAM cost
CSpoolStorage	Minimal seek+read+write interface a SpoolFileSampleTableStore needs from its scratch file - SeekableSource plus write(), kept non-templated for the same reason as SeekableSource (see its comment): so DemuxerMP4/SpoolStorageFactory don't need to become templates just to hold/pass one of these around
CSpoolStorageFactory	Factory DemuxerMP4 calls once per table, per track, to obtain a SpoolStorage for spool-backed sample table storage - needed (rather than a single shared file/setter, the way setSeekSource() works) because up to two tracks (video + audio) times four tables means up to eight distinct spool regions are needed, and DemuxerMP4 doesn't know how many tracks a file has, or which kind each one is, until it's actually parsing 'moov' - implement this to open/return whatever files or regions your storage scheme uses (e.g. one file per call, named by trackKind+tableKind)
CSquareWaveGenerator	Generates a square wave sound. Uses the same 32 bit phase accumulator as SawToothGenerator/FastIntSineGenerator: no floating point operations or sin() calls in the readSample() hot path. A square wave needs neither a sine approximation nor a lookup table - just the sign bit of the ramp - so readSample() is a single comparison, making this a good fit for MCUs without a hardware FPU (e.g. RP2040), where the previous FastSineGenerator based implementation still did a float polynomial evaluation per sample just to keep its sign
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
CStdMutex	Mutex implemntation based on std::mutex
CStdRecursiveMutex	Mutex implemntation based on std::mutex
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
CSTKInstrument	STK Stream for Instrument
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!
CSupportedRatesStream	Resampling stream that is restricted to a fixed list of supported sample rates (e.g. the rates a DAC or codec chip can actually run at). On setAudioInfo() the closest supported rate is selected, the resampler is reconfigured to convert to it, and the corrected AudioInfo (with the supported sample rate) is forwarded to any subscribers/output
CSynchronizedBuffer	Wrapper class that can turn any Buffer into a thread save implementation
CSynchronizedNBufferRTOST	NBuffer which uses FreeRTOS queues to manage the available and filled buffers, making it safe for cross-core SPSC (single producer, single consumer) use on dual-core ESP32
CSynchronizedNBufferZephyrT	NBuffer using Zephyr queues for 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
CTaskZephyr	Zephyr thread based 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
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
CTfLiteMicroSpeechWriter	TfLiteMicroSpeechWriter for Audio Data
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!
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
CTimeSource	Interface for classes that can provide time information - two distinct notions of "now", not interchangeable: millis() is real wall time; playbackTime() is however far actual processing has gotten, which is not the same thing whenever the two can diverge (a consumer blocked/starved, a paused source, ...). A consumer that must stay tied to genuine progress (e.g. PacedVideoOutput scheduling video against actual decoded-audio playback, not merely time passing) should use playbackTime(), not millis()
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	USB Audio Class 2.0 descriptor generator
CUSBAudioBackend	Abstract seam for every raw USB-stack call the UAC2 driver (USBAudioDeviceBase) needs. Concrete subclasses wrap TinyUSB (USBAudioBackendTinyUSB, today) or a native peripheral driver (STM32 HAL / Renesas USBFS — future work)
CUSBAudioBackendTinyUSB	USBAudioBackend implementation wrapping the real TinyUSB device stack. Injected by the ESP32, TinyUSB (RP2040/Adafruit), and TinyUSBFreeRTOS platform subclasses of USBAudioDeviceBase
CUSBAudioConfig	Configuration for USB Audio (inherits sample_rate / channels / bits_per_sample from AudioInfo)
CUSBAudioDeviceBase	USB Audio Device class for audio streaming over USB
Caudio_feedback_params_t	Parameters for audio feedback endpoint configuration
Caudiod_function_t	Internal structure representing a USB audio function instance
CUSBAudioDeviceESP32	USBAudioDeviceBase subclass for ESP32-S2/S3 using the arduino-esp32 stack
CUSBAudioDeviceRenesas	USBAudioDeviceBase subclass for the Arduino UNO R4 / Nano R4 (Renesas RA4M1, arduino:renesas_uno core)
CUSBAudioDeviceTinyUSB	USBAudioDeviceBase subclass for RP2040 / Adafruit TinyUSB
CUSBAudioDeviceTinyUSBFreeRTOS	Variant of USBAudioDeviceTinyUSB for RP2040 + FreeRTOS
CUSBAudioDeviceZephyr	USB Audio 2.0 device backend for Zephyr RTOS
CUSBAudioHostBackend	Abstract seam for every raw USB host stack call the UAC host class logic (USBAudioHostBase) needs. Concrete subclasses wrap TinyUSB host (USBAudioHostBackendTinyUSB) or the ESP-IDF usb_host library (USBAudioHostBackendESP32)
CUSBAudioHostBackendESP32	USBAudioHostBackend for the ESP-IDF usb_host library which is part of arduino-esp32 (ESP32-S2, ESP32-S3 and ESP32-P4)
CInterface
CStream
CUSBAudioHostBackendTinyUSB	USBAudioHostBackend for the TinyUSB host stack provided by the Adafruit TinyUSB Library (RP2040/RP2350 native or Pico-PIO-USB, ESP32-S2/ S3/P4 native OTG, STM32, or a MAX3421E host controller on any platform)
CStream
CUSBAudioHostBase	USB Audio Class (UAC1 and UAC2) host: reads PCM audio from an attached USB microphone and/or writes PCM audio to an attached USB speaker or headset, using the same API as the USB Audio device (USBAudioStream)
CAltSetting	One alternate setting of an audio streaming interface
CEntity	Audio Control entity (terminal, unit or clock) for the topology walk
CRateRange	Range of supported sample rates (UAC2 clock source GET_RANGE)
CStream	State of one direction (microphone or speaker)
CUSBAudioHostESP32	USB Audio host for ESP32-S2/S3/P4 using the ESP-IDF usb_host library: reads audio from an attached USB microphone and/or writes audio to an attached USB speaker
CUSBAudioHostEvents	Upcalls from a USB host backend into the stack independent UAC host class logic (USBAudioHostBase). All methods are called from the USB stack context (TinyUSB: inside tuh_task(); ESP-IDF: the USB host task)
CUSBAudioHostTinyUSB	USB Audio host for the Adafruit TinyUSB host stack: reads audio from an attached USB microphone and/or writes audio to an attached USB speaker
CUSBAudioHostTinyUSBFreeRTOS	Variant of USBAudioHostTinyUSB for FreeRTOS (e.g. RP2040 + FreeRTOS, or ESP32 with the Adafruit TinyUSB host stack)
CUSBAudioStreamBase	Role-independent front end shared by USB Audio devices (USBAudioDeviceBase, aliased as USBAudioStream) and USB Audio hosts (USBAudioHostBase, aliased as USBAudioHostStream)
CUsbEndpointDescriptorView	Backend-agnostic mirror of tusb_desc_endpoint_t (USB 2.0 spec Table 9-13). wMaxPacketSize is kept in its raw little-endian form (bits 10..0 = size, bits 12..11 = high-speed additional transactions per microframe) so it round-trips bit-for-bit back into a real endpoint descriptor for backends that need one; use packetSize() for the masked value the UAC2 driver's own sizing logic uses (this mirrors TinyUSB's tu_edpt_packet_size(), which also only masks the low 11 bits and does not apply the HS multiplier)
CUsbInterfaceDescriptorView	Backend-agnostic mirror of tusb_desc_interface_t — only the fields the UAC2 driver reads (USB 2.0 spec Table 9-12)
CUsbSetupPacket	Backend-agnostic mirror of the standard 8-byte USB SETUP packet (TinyUSB's tusb_control_request_t). Identical wire layout on any USB stack. The bmRequestType bitfields (USB 2.0 spec Table 9-2) are exposed as accessor methods instead of a bitfield union, so call sites read almost the same as before: p_request->bmRequestType_bit.type -> p_request.type()
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
CVideoDecoder	Common interface for video decoders (e.g. H264Decoder, H264DecoderESP32S3 - CodecH264.h/CodecH264ESP32S3.h) - standardizes lifecycle (begin()/end()), the Print target decoded pictures are written to, and the pixel format they're written in (setVideoFormat()), on top of VideoOutput's write()/flush() (the encoded-bitstream input side, inherited unchanged). Concrete decoders may still expose their own additional config knobs beyond this shared surface
CVideoEncoder	Common interface for video encoders (e.g. H264Encoder, H264EncoderESP32S3 - CodecH264.h/CodecH264ESP32S3.h; H264EncoderESP32P4
CVideoFrameMeter	Transparent write() wrapper that measures throughput/turnaround while forwarding every call unchanged to the target given in the constructor - drop it into a pipeline slot (e.g. h264Decoder.setOutput( meter) instead of h264Decoder.setOutput(tftOutput), with meter wrapping tftOutput) to find out how that one stage is actually performing, without instrumenting the stage itself
CPrintView
CVideoFrameSource	Pull-based provider of one already-encoded video/image frame at a time - e.g. wraps a camera capture + H264Encoder/MJPEG capture pipeline. Used by VideoMuxerWithTasks's video task, which calls nextFrame() once per iteration, at the rate given by videoInfo().fps. Implementations should produce/capture the frame here directly (not defer it): a slow nextFrame() only delays whatever is pulling from it
CVideoInfo	Basic video information (width/height/codec/frame size), analogous to AudioInfo - common to both DemuxerAVI and DemuxerMP4, accessible via their getVideoInfo() getter
CVideoInfoSource	Provider of VideoInfo (width/height/fps/format) for whoever needs to size buffers/panel setup against it - e.g. a Demuxer (already parsed from the container's own metadata) handed to VideoOutput:: setVideoInfoSource()
CVideoMuxer	Feeds a Muxer (MuxerAVI, MuxerMP4, ...) from a single copy() call
CVideoMuxerWithTasks	Feeds a Muxer (MuxerAVI, MuxerMP4, ...) from two background Tasks instead of a single loop()/copy() call - one per track, each write wrapped in a LockGuard over a shared mutex (real by default; override via setMutex()), since a Muxer is not safe to call from two threads concurrently
CVideoOutput	Abstract class for video playback. This class is used to assemble a complete video frame in memory. A video frame is written via one or more write() calls, then finalized with flush() - implementations use flush() to know a frame is complete (there is no separate frame-size hint, unlike a length-prefixed chunk format)
CVideoPlayer	High-level video playback pipeline and controller - the video counterpart of AudioPlayer (CoreAudio/AudioPlayer.h). Wraps a container Demuxer, a VideoDecoder driven through a PacedVideoOutput, and optionally an audio decode chain synced against it, behind one object driven by a single copy() call per loop() iteration
CVideoPlayerFull	VideoPlayer subclass pre-registered with every video/audio codec this library ships a portable decoder for - H264/MJPEG/MPEG-1 video, MP3/AAC/MP2 audio - so it's the "just point it at a file, any common codec just works" player. Use instead of the base VideoPlayer unless you want to keep these dependencies out of your build (the base class's own multi-decoders start out completely empty, requiring an explicit addVideoDecoder()/addAudioDecoder() call per codec)
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/codec-vorbis-tremor
CVS1053Config	Configuration for VS1053Stream
CVS1053Stream	Output Interface which processes PCM data by default using a VS1053 audio module. If you want to write encoded data set is_encoded_data = true in the configuration. Many VS1053 modules also have a built in microphone that can be used for recording: set the mode to RX_MODE to use this
CWakeWordDetector	Template-based wake word detector for microcontrollers using dominant frequency patterns
CTemplate
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. Since WAV files can use different ADPCM (or other) encodings, you can register more than one decoder with addDecoder(): the decoder matching the format tag found in the WAV header is selected automatically when a file is parsed
CDecoderEntry	Associates a WAV format tag with the decoder responsible for it
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
CWAVFileInfo	Utility for reading and rewriting WAV file metadata in place
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
CWiFiClientSecureZephyr
CWiFiClientZephyr
CWiFiESP32	Login to Wifi using the ESP32 IDF functionality. This can be accessed with the global object IDF_WIFI
CWiFiServerZephyr	WiFiServer (Zephyr zsock version) This class provides a TCP server interface using Zephyr's socket API (zsock). It mimics the Arduino WiFiServer API for compatibility
CWiFiUDPZephyr	WiFiUDP (Zephyr zsock version) This class provides a UDP interface using Zephyr's socket API (zsock). It mimics the Arduino WiFiUDP API for compatibility
CWiFiZephyr	Login to WiFi using Zephyr's wifi_mgmt / net_mgmt API. Access via the global object ZEPHYR_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
CZephyrFile	Arduino File API for Zephyr
CZephyrSDClass	Arduino SD API for Zephyr
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
Nstd
CFormat	Drop in pre c++20 Fromatter replacement for Arduino that supports {} placeholders and escaped {{}} braces which supports e.g Serial.println(Format("State: {} | Temp: {} C | Level: {}%", status, temp, battery).c_str());
CClient
Cdsp	Minimal dsp base class needed by Faust
Cdsp_memory_manager	Memory manager which uses psram when it is available
CHardwareSerial
CMeta	Minimial implementtion of Meta which just ignores the data
CPrint
CPrintable
CStream
CUI	Minimum implementation of UI parameters. We only support the setting and getting of values
CVBan
CVBAN_PING0
CVBanHeader