arduino-audio-tools
Loading...
Searching...
No Matches
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 CA2DPConfigConfiguration for A2DPStream
 CAbstractMetaDataCommon Metadata methods
 CAbstractParameterBase class for all parameters
 CAbstractSynthesizerChannelDefines 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
 CAudioActions::ActionAction definition per pin
 CKARadioProtocol::Action
 CAdafruit_USBD_Interface
 CADTSParser::ADTSHeader
 CADTSParserStructure to hold ADTS header field values
 CAGCPCMTraits< T >
 CAGCPCMTraits< int16_t >
 CAGCPCMTraits< int24_t >
 CAGCPCMTraits< int32_t >
 CALACBinaryConfigMagic Cookie
 CAllocatorMemory allocateator which uses malloc
 CAllocatorMemory allocateator which uses malloc
 CAllocSize
 CUSBAudioHostBase::AltSettingOne alternate setting of an audio streaming interface
 CAnalogDriverBase
 CAppropriateSumType< T >We reduce the number of samples in a datastream by summing (binning) or averaging. This will result in the same number of channels but binSize times less samples. If Average is true the sum is divided by binSize
 CAppropriateSumType< T >We reduce the number of samples in a datastream by summing (binning) or averaging. This will result in the same number of channels but binSize times less samples. If Average is true the sum is divided by binSize
 CAppropriateSumType< int16_t >
 CAppropriateSumType< int16_t >
 CAppropriateSumType< int24_t >
 CAppropriateSumType< int24_t >
 CAppropriateSumType< int32_t >
 CAppropriateSumType< int32_t >
 CAppropriateSumType< int8_t >
 CAppropriateSumType< int8_t >
 CArray< T, LEN >
 CUSBAudioDeviceBase::audio_feedback_params_tParameters for audio feedback endpoint configuration
 CAudioActionsA simple class to assign functions to gpio pins e.g. to implement a simple navigation control or volume control with buttons
 CAudioClientRTSPA simple RTSPClient using https://github.com/pschatzmann/arduino-live555
 CUSBAudioDeviceBase::audiod_function_tInternal structure representing a USB audio function instance
 CAudioEffectAbstract Base class for Sound Effects
 CAudioEffectCommon
 CAudioFFTResultResult of the FFT
 CAudioHeaderCommon Header for all records
 CAudioInfoBasic Audio information which drives e.g. I2S
 CAudioInfoBasic Audio information which drives e.g. I2S
 CAudioInfo
 CAudioInfoSourceSupports the subscription to audio change notifications
 CAudioInfoSourceSupports the subscription to audio change notifications
 CAudioInfoSupportSupports changes to the sampling rate, bits and channels
 CAudioInfoSupportSupports changes to the sampling rate, bits and channels
 CAudioPlayerCommand
 CAudioPlayerProtocolAbstract class for protocol to control the audio player
 CAudioPlayerProtocolServerAudio Player Protocol Server: We can use the indicated protocol over http to control the audio player provided by the audiotools
 CAudioPlayerThreadSafe< QueueT >Lock-free asynchronous control wrapper for AudioPlayer using a command queue
 CAudioServerT< Client, Server >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
 CAudioServerT< WiFiClient, WiFiServer >
 CAudioSourceAbstract Audio Data Source for the AudioPlayer which is used by the Audio Players
 CAudioTimeTools for calculating timer values
 CAudioTimeTools for calculating timer values
 CAudioTimerCommon Interface definition for AudioTimer
 CAudioTimerCommon Interface definition for AudioTimer
 CAudioTimerDriverBase
 CAudioTimerDriverBase
 CAVIMainHeader
 CAVIStreamHeader
 CBaseBuffer< T >Shared functionality of all buffers
 CBaseBuffer< T >Shared functionality of all buffers
 CBaseBuffer< audio_tools::audio_tools::GeneratorQueue::QNode * >
 CBaseBuffer< audio_tools::GeneratorQueue::QNode * >
 CBaseBuffer< float >
 CBaseBuffer< Frame >
 CBaseBuffer< int16_t >
 CBaseBuffer< int32_t >
 CBaseBuffer< Sample >
 CBaseBuffer< stsz_sample_size_t >
 CBaseBuffer< T >
 CBaseBuffer< uint16_t >
 CBaseBuffer< uint32_t >
 CBaseBuffer< uint8_t >
 CBaseConverterAbstract Base class for Converters A converter is processing the data in the indicated array
 CBaseConverterAbstract Base class for Converters A converter is processing the data in the indicated array
 CBaseInterpolatorBase class for resampling algorithms using a buffer of float values
 CBin::BinState
 CBin::BinState
 CBiQuadCoeffsBiquad 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
 CBiQuadCoeffsBiquad 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
 CBitmapInfoHeader
 CBLEAdvertisedDeviceCallbacks
 CBLECharacteristicCallbacks
 CBLEClientCallbacks
 CBLEServerCallbacks
 CMP4Parser::BoxRepresents an individual box in the MP4 file
 CBufferedArray< T >Class which is usfull ot provide incremental data access e.g. for EdgeImpulse which request data with an offset and length starting from 0 up to the buffer length, restarting at 0 again
 CBufferedArray< T >Class which is usfull ot provide incremental data access e.g. for EdgeImpulse which request data with an offset and length starting from 0 up to the buffer length, restarting at 0 again
 COSCData::Callback
 CMP4Parser::CallbackEntryStructure for type-specific callbacks
 CChannelBinDiff::ChannelBinDiffState
 CChannelBinDiff::ChannelBinDiffState
 CChannelConverter< T >Increasing or decreasing the number of channels
 CChannelConverter< T >Increasing or decreasing the number of channels
 CChannelEnhancer< T >Increases the channel count
 CChannelEnhancer< T >Increases the channel count
 CDSFEncoder::ChannelModState
 CChannelSplitOutput::ChannelSelectionOutputDef
 CChannelsSelectOutput::ChannelSelectionOutputDef
 CChannelSplitOutput::ChannelSelectionOutputDef
 CChannelsSelectOutput::ChannelSelectionOutputDef
 CFrequencyDetectorZeroCrossing::ChannelStateHolds state for each channel during zero crossing detection
 CChartT< T >Displays audio in a Jupyter as chart Just wrapps a stream to provide the chart data
 CMimeDetector::Check
 CChorus
 CCodecCopy
 CCodecFactoryFactory for creating new decoders based on the mime type or id
 CCommonHeader
 CMP4Parser::ContainerInfoStructure for container box information
 CContainerTargetContainerTarget: 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
 CContainerTargetContainerTarget: 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
 CDataNode
 CDataNode
 CDebouncerHelper class to debounce user input from a push button
 CDecimate::DecimateState
 CDecimate::DecimateState
 CWAVDecoder::DecoderEntryAssociates a WAV format tag with the decoder responsible for it
 CCodecFactory::DecoderFactoryLine
 CMultiDecoder::DecoderInfoInformation about a registered decoder
 CMultiStreamingDecoder::DecoderInfoInformation about a registered decoder
 CMultiVideoDecoder::DecoderInfo
 CDelayEffectBase< effectsuite_t >A Base class for delay based digital effects. Provides the basic methods that are shared amongst Flanger, Delay, Chorus and Phaser
 CDelayEffectBase< effectsuite_t_default >
 CI2SDriverESP32V1::DriverCommon
 CdspMinimal dsp base class needed by Faust
 Cdsp_memory_managerMemory manager which uses psram when it is available
 CDynArray< T >
 CEcho
 CEchoState< T, SampleType >Internal echo canceller state structure
 CEmulated_TinyUSBMinimal wrapper around the ESP32 TinyUSB API. We emulate the basic functionality so that we can use the same TinyUSBDevice API on RP2040 and ESP32
 CCodecFactory::EncoderFactoryLine
 CUSBAudioHostBase::EntityAudio Control entity (terminal, unit or clock) for the topology walk
 CEqualizer3BandsPerChannelT< T >::EQSTATE
 CEqualizer3BandsT< T >::EQSTATEFilter state for each channel
 CM4ACommonDemuxer::ESDSParserA parser for the ESDS segment to extract the relevant aac information
 CESPNowStreamConfigConfiguration for ESP-NOW protocolö.W
 CEthernetZephyr
 CFadeFade 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
 Cfalse_type
 Cfft_stateFFT state management structure
 CFFTBinAnd individual FFT Bin
 CFFTDisplay
 CFFTDriverAbstract Class which defines the basic FFT functionality
 CFFTInverseOverlapAdderInverse FFT Overlapp Add
 CFFTReal< DT >
 CFFTRealFixLen< LL2 >
 CFFTRealFixLenParam
 CFFTRealPassDirect< PASS >
 CFFTRealPassInverse< PASS >
 CFFTRealSelect< P >
 CFFTRealUseTrigo< ALGO >
 CAnalogDriverESP32V1::FIFO< T >Custom FIFO class
 CFileEntryFile entry to minimize RAM usage by using path index and name
 CFilter< T >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
 CFilter< T >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
 CFilter< float >
 CFilter< int16_t >
 CFilter< SampleT >
 CFilter< T >
 CFilterSampleConverter< T, FT >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< T, FT >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< int16_t, q1_14_t >
 CFilterSampleConverter< int24_t, q1_14_t >
 CFilterSampleConverter< int24_t, q1_14_t >
 CFilterSampleConverter< int32_t, q1_14_t >
 CFilterSampleConverter< int32_t, q1_14_t >
 Cfloat16Half-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
 Cfloat32A 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
 CFormatDrop 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());
 CM4ACommonDemuxer::Frame
 CFrameBuffer< T >A FrameBuffer reads multiple values for array of 2 dimensional frames
 CFrameBuffer< T >A FrameBuffer reads multiple values for array of 2 dimensional frames
 CPacedVideoOutput::FrameHeader
 CFreeVerb
 CFrequencyFrame< N >
 CGoertzelDetectorSingle-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
 CHasQuickStart< T >
 CHeaderParserAACAAC header parser to check if the data is a valid ADTS aac which can extract some relevant audio information
 CHeaderParserMP3MP3 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
 CHLSParser< URLStream >Simple Parser for HLS data
 CHttpHeaderIn 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
 CHttpHeaderLineA individual key - value header line
 CHttpLineReaderWe read a single line. A terminating 0 is added to the string to make it compliant for c string functions
 CI2SDriverBase
 CICYUrlSetupResolve icy-metaint from HttpRequest and execute metadata callbacks
 CID3v1
 CID3v1Enhanced
 CID3v2
 CID3v2Frame
 CID3v2FrameString
 CMetaDataFilter::ID3v2HeaderID3 verion 2 TAG Header (10 bytes)
 CIMAState
 CIMediaSourceMedia Source Interface - Contract for Media Data Providers
 Cint24_3bytes_t24bit integer which is used for I2S sound processing. The values are really using 3 bytes. It works only on little endian machines!
 Cint24_3bytes_t24bit integer which is used for I2S sound processing. The values are really using 3 bytes. It works only on little endian machines!
 Cint24_4bytes_t24bit 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
 Cint24_4bytes_t24bit 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
 CUSBAudioHostBackendESP32::Interface
 CIPAddressArduino-compatible IPAddress class implemented in pure C++
 CITaskInterface for a task that can be started and stopped
 CList< T >::Iterator
 CList< T >::Iterator
 CListLockFree< T >::Iterator
 CVector< T >::iteratorIterator for the Vector class
 CVector< T >::iteratorIterator for the Vector class
 CJCRev
 CKalmanFilterSimple 1D Kalman Filter for smoothing measurements
 CSynthesizer::KeyParameter
 CLastSampleFaderIf we end audio and the last sample is not close to 0 we can hear a popping noise. This functionality brings the last value slowly to 0. Typless implementation
 CLastSampleFaderT< T >If we end audio and the last sample is not close to 0 we can hear a popping noise. This functionality brings the last value slowly to 0
 CLEDOutputLED output using the FastLED library
 CLEDOutputConfig
 CLEDOutputUnoR4LED output using the R4 LED matrix library
 CLEDOutputUnoR4Config
 CLentPitShift
 CList< T >Double linked list
 CList< T >Double linked list
 CListLockFree< T >Lock-free double linked list using atomic operations
 CLockGuardRAII 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
 CM4ACommonDemuxer::M4AAudioConfig
 CM4ACommonDemuxerAbstract base class for M4A/MP4 demuxers. Provides shared functionality for both file-based and stream-based demuxers
 CMDFFixedPointSelects 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)
 CMDFFloatSelects 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)
 CMedianFilter< T >::MedianFilter_t
 CMedianFilter< T >::MedianNode_t
 CMediaSink
 CAudioFFTBase::MelFilterOne triangular mel filter: weights for bins [start_bin, start_bin+count)
 CMemoryManagerMemoryManager 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
 CInputMerge< T >::MergeRecord
 CInputMerge< T >::MergeRecord
 CMetaMinimial implementtion of Meta which just ignores the data
 CMetaDataID3BaseID3 Meta Data Common Functionality
 CMimeEntryExtension to mime table (sorted alphabetically)
 CMimeResolverLookup MIME types by file extension
 CMimeSourceAbstract interface for classes that can provide MIME type information
 CMimeSourceAbstract interface for classes that can provide MIME type information
 CMixGain< T >Mixing of multiple audio input streams into a single output stream
 CMixGain< T >Mixing of multiple audio input streams into a single output stream
 CModulationBaseClass< effectsuite_t >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
 CModulationBaseClass< effectsuite_t_default >
 CMovingAverage< N >Caclulates the moving average of a number of values
 CMP4BoxWriterMinimal 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
 CMP4ParserMP4Parser 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
 CMPGParseBufferMinimal 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
 CMTSParseBufferMinimal 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< TInterpolator >Multi-channel resampler that applies a BaseInterpolator-derived algorithm to each channel
 CMultiOutput::MultiOutputRecordRecord describing a single replicated output
 CMultiOutput::MultiOutputRecordRecord describing a single replicated output
 CMusicalNotesDetermination of the frequency of a music note
 CMutexBaseEmpty Mutex implementation which does nothing
 CMuxerVideoConfigShared video track configuration for muxers (MuxerAVI, MuxerMP4) - call before begin()
 CNano_BLE_freq_infoMapping Frequency constants to available frequencies
 CNano_BLE_ratio_infoMapping from Ratio Constants to frequency ratios
 CList< T >::Node
 CList< T >::Node
 CListLockFree< T >::Node
 CQueueLockFree< T >::Node
 CNRev
 CNumberConverterConverts from a source to a target number with a different type
 CNumberConverterConverts from a source to a target number with a different type
 CNumberReaderReads n numbers from an Arduino Stream
 CNumberReaderReads n numbers from an Arduino Stream
 Cnumeric_limits< audio_tools::int24_3bytes_t >
 Cnumeric_limits< audio_tools::int24_4bytes_t >
 CRingBufferFile< File, T >::OffsetInfo
 CRingBufferFile< File, T >::OffsetInfo
 COSCBinaryDataSimple structure to hold binary data
 COSCDataA 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:
 COscSinCos< T >
 CParseBufferWe 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
 CParseObjectRepresents a LIST or a CHUNK: The ParseObject represents the current parsing result. We just keep position information and ids
 CPathNamesRegistryInterface for classes that can collect file names
 CPIDControllerA simple header only PID Controller
 CPinInfoESP32Information for a PIN
 CPinInfoESP32ComplMapping information for one complementary PWM audio channel
 CPitShift
 CPoly
 CPRCRev
 CPrint
 CPrint
 CPrintable
 CPriorityQueue< T >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
 CPriorityQueue< T >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
 CPWMDriverBaseBase Class for all PWM drivers
 Cq1_14_tFixed-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
 Cq1_14_tFixed-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
 CGeneratorQueue< T >::QNode
 CGeneratorQueue< T >::QNode
 CQualityStatsStatistics collected by QualityAnalysisStream
 CQueue< T >FIFO Queue which is based on a List
 CQueue< T >FIFO Queue which is based on a List
 CQueueFromVector< T >FIFO Queue which is based on a Vector
 CQueueFromVector< T >FIFO Queue which is based on a Vector
 CQueueLockFree< T >Lock-free MPMC queue
 CQueueRTOS< T >FIFO Queue whch is based on the FreeRTOS queue API. The default allocator will allocate the memory from psram if available
 CQueueZephyr< T >FIFO Queue implementation based on Zephyr message queues
 CR2RDriverBaseR2R driver base class
 CUSBAudioHostBase::RateRangeRange of supported sample rates (UAC2 clock source GET_RANGE)
 CRCAudioPlayerOSCReceiverAudio Player OSC Receiver: Receives OSC messages from the AudioPlayerOSCSender and applies it to the AudioPlayer
 CRCAudioPlayerOSCSenderAudio Player OSC Sender: Remote control for AudioPlayer class. Sends OSC messages to the RCAudioPlayerOSCReceiver
 CRECT
 CRedisBuffer< T >::RedisResult
 CReedSolomon< msg_length, ecc_length >
 CTfLiteMicroSpeechRecognizeCommands::Result
 CRTSPClient
 CRTSPFormatAudio Format Definition - Base class for RTSP audio formats
 CRTSPFormatAudio Format Definition - Base class for RTSP audio formats
 CRTSPFragmentQueueSelf-delimited fragment queue shared by packetized RTP video encoders (JPEGRtpEncoder, H264RtpEncoder, ...)
 CRTSPMediaStreamerBase< Platform >RTSPMediaStreamerBase - Core RTP Media Streaming Engine
 CRTSPPlatform< TcpServer, TcpClient, UdpSocket >Template-based platform abstraction for RTSP networking
 CRTSPPlatform< TcpServer, TcpClient, UdpSocket >Template-based platform abstraction for RTSP networking
 CRTSPServerBase< Platform >RTSPServerBase - Shared logic for RTSPServer and RTSPServerTaskless
 CRtspSession< Platform >RTSP Session Handler - Individual Client Protocol Management
 CRTSPVideoInfoVideo Information Structure
 CRTSPVideoInfoVideo Information Structure
 CRTSPVideoInfoSupportBase class for video information support
 CRTSPVideoInfoSupportBase class for video information support
 CM4ACommonDemuxer::SampleExtractorExtracts 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
 CSampleTableStore< T >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
 CSDDirect< SDT, FileT >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< SDT, FileT >We store all the relevant file names in an sequential index file. Form there we can access them via an index
 CSeekableSourceMinimal 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
 CSimpleContainerConfig
 CSimpleContainerDataHeader
 CSimpleContainerMetaDataHeader
 CSimpleContainerVideoConfig
 CSimpleContainerVideoDataHeader
 CSlice< T >Helps to split up a big memory array into smaller slices. There are no additinal heap allocations! Example: if we have an array with 9 entries (1,2,3,4,5,6,7,8,9): slices(5) gives 2. slice(5,0) returns size 5 with 1,2,3,4,5 and slice(5,1) returns size 4 with 6,7,8,9!
 CSlice< T >Helps to split up a big memory array into smaller slices. There are no additinal heap allocations! Example: if we have an array with 9 entries (1,2,3,4,5,6,7,8,9): slices(5) gives 2. slice(5,0) returns size 5 with 1,2,3,4,5 and slice(5,1) returns size 4 with 6,7,8,9!
 Csoft_float_tSoftware "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)
 Csoft_float_tSoftware "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)
 CSoundGenerator< T >Base class to define the abstract interface for the sound generating classes
 CSoundGenerator< T >Base class to define the abstract interface for the sound generating classes
 CSoundGenerator< effect_t >
 CSoundGenerator< int16_t >
 CSoundGenerator< T >
 CSpoolStorageFactoryFactory 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)
 CStack< T >LIFO Stack which is based on a List
 CStack< T >LIFO Stack which is based on a List
 CUSBAudioHostBackendESP32::Stream
 CUSBAudioHostBackendTinyUSB::Stream
 CUSBAudioHostBase::StreamState of one direction (microphone or speaker)
 CStreamClientState
 CStreamCopyT< T >Typed Stream Copy which supports the conversion from channel to 2 channels. We make sure that we allways copy full samples
 CStrViewA 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!
 CStrViewA 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!
 CDemuxerMP4::StscEntrySample-to-chunk table entry (stsc)
 CDemuxerMP4::SttsEntry
 CSynchronizedQueue< T, TMutex >FIFO Queue which is based on a List that is thread save
 CSynthesizerKeyArduino GPIO pin to note assossiation
 CTaskZephyrZephyr thread based task
 CWakeWordDetector< T, N >::Template
 CTfLiteAbstractRecognizeCommandsBase 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
 CTfLiteConfigConfiguration settings for TfLiteAudioStream
 CTfLiteQuantizerQuantizer that helps to quantize and dequantize between float and int8
 CTfLiteReaderInput class which provides the next value if the TfLiteAudioStream is treated as an audio sourcce
 CTfLiteWriterOutput class which interprets audio data if TfLiteAudioStream is treated as audio sink
 CTimerCallbackInternal class to manage the different timer callbacks for the 4 hardware timers
 CTimeSourceInterface 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()
 CTimeSourceInterface 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()
 CDemuxerMP4::TrackOne track (audio or video) as found in 'moov'
 CTransformationReader< T >ConverterStream Helper class which implements the readBytes with the help of write
 CTransformationReader< T >ConverterStream Helper class which implements the readBytes with the help of write
 Ctrue_type
 CUIMinimum implementation of UI parameters. We only support the setting and getting of values
 CUrlURL parser which breaks a full url string up into its individual parts
 CURLHistory
 CURLLoaderHLS< URLStream >We feed the URLLoaderHLS with some url strings. The data of the related segments are provided via the readBytes() method
 CUSBAudio2DescriptorBuilderUSB Audio Class 2.0 descriptor generator
 CUSBAudioBackendAbstract 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)
 CUSBAudioDeviceZephyrUSB Audio 2.0 device backend for Zephyr RTOS
 CUSBAudioHostBackendAbstract 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)
 CUSBAudioHostEventsUpcalls 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)
 CUsbEndpointDescriptorViewBackend-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)
 CUsbInterfaceDescriptorViewBackend-agnostic mirror of tusb_desc_interface_t — only the fields the UAC2 driver reads (USB 2.0 spec Table 9-12)
 CUsbSetupPacketBackend-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()
 CUserCallbackInternal class to manage User callbacks. An optinal parameter can be passed to the callback method We support 4 timers
 CVBan
 CVBAN_PING0
 CVBanHeader
 CVector< T >Vector implementation which provides the most important methods as defined by std::vector. This class it is quite handy to have and most of the times quite better then dealing with raw c arrays
 CVector< T >Vector implementation which provides the most important methods as defined by std::vector. This class it is quite handy to have and most of the times quite better then dealing with raw c arrays
 CVFSBase 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
 CVideoEncoderCommon interface for video encoders (e.g. H264Encoder, H264EncoderESP32S3 - CodecH264.h/CodecH264ESP32S3.h; H264EncoderESP32P4
 CVideoFrameSourcePull-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
 CVideoInfoBasic video information (width/height/codec/frame size), analogous to AudioInfo - common to both DemuxerAVI and DemuxerMP4, accessible via their getVideoInfo() getter
 CVideoInfoSourceProvider 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()
 CVideoMuxerFeeds a Muxer (MuxerAVI, MuxerMP4, ...) from a single copy() call
 CVideoMuxerWithTasksFeeds 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
 CVideoOutputAbstract 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)
 CVideoPlayerHigh-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
 CVolumeControlAbstract class for handling of the linear input volume to determine the multiplication factor which should be applied to the audio signal
 CVolumeSupportSupports the setting and getting of the volume
 CVolumeSupportSupports the setting and getting of the volume
 CWAVFileInfo< FileT >Utility for reading and rewriting WAV file metadata in place
 CWAVFormatX
 CWAVHeaderParser for Wav header data for details see https://de.wikipedia.org/wiki/RIFF_WAVE
 CWavIMAHeader
 CWiFiESP32Login to Wifi using the ESP32 IDF functionality. This can be accessed with the global object IDF_WIFI
 CWiFiServerZephyrWiFiServer (Zephyr zsock version) This class provides a TCP server interface using Zephyr's socket API (zsock). It mimics the Arduino WiFiServer API for compatibility
 CWiFiUDPZephyrWiFiUDP (Zephyr zsock version) This class provides a UDP interface using Zephyr's socket API (zsock). It mimics the Arduino WiFiUDP API for compatibility
 CWiFiZephyrLogin to WiFi using Zephyr's wifi_mgmt / net_mgmt API. Access via the global object ZEPHYR_WIFI
 CWindowFunctionFFT Window Function
 CZephyrSDClassArduino SD API for Zephyr
Generated by doxygen 1.15.0