Media Codecs: Audio Encoders & Decoders Architecture#

The Sound Open Firmware (SOF) Media Codec subsystem enables hardware-accelerated, ultra-low-power compressed audio streaming directly within the digital signal processor (DSP). By offloading bitstream decoding and encoding tasks from the host central processing unit (CPU) to the audio DSP, the subsystem eliminates frequent host wakeups, allowing mobile and desktop host platforms to maintain prolonged deep sleep power states ($C10 / D3$).

The architecture standardizes on the industry-proven Cadence Xtensa Audio (XA) API, providing a hardware-abstracted, modular wrapper that interfaces seamlessly with Tensilica HiFi DSPs (HiFi 3, HiFi 4, and HiFi 5). The subsystem supports both compressed media playback (decoding MPEG-1 Layer 3 MP3, Advanced Audio Coding AAC, Ogg Vorbis, Bluetooth SBC, and uncompressed PCM passthrough) and compressed media capture (real-time MP3 encoding and compressed feature streaming), complemented by third-party post-processing codecs such as DTS Interactive audio.

Foundations of DSP Compress-Offload & Low-Power Audio #

The Energy Bottleneck in Traditional Audio Playback #

In conventional Pulse Code Modulation (PCM) audio pipelines, the host CPU decodes compressed media files (e.g., MP3 or AAC bitstreams) in user space and feeds raw uncompressed PCM samples to the audio device driver. Because uncompressed PCM data streams consume high memory bandwidth (typically 1.411 Mbps for standard 44.1 kHz 16-bit stereo), host Direct Memory Access (DMA) ring buffers can buffer only a few milliseconds of audio (typically 1 ms to 20 ms).

This architectural constraint forces the host CPU to wake up dozens or hundreds of times per second to replenish DMA ring buffers. In battery-powered mobile devices and modern laptops, these recurring wakeups prevent the application processor and its system-on-chip (SoC) power planes from entering ultra-low-power residency states ($C8/C10$ CPU package states and $D3$ device states), burning tens to hundreds of milliwatts of unnecessary battery power.

ALSA Compress-Offload Mechanics #

The Sound Open Firmware Media Codec subsystem resolves this bottleneck through ALSA Compress-Offload (snd_compress_ops). Rather than decoding audio on the host CPU:

Massive Host Transfer Chunks: The host operating system offloads raw, compressed bitstreams to the DSP in massive chunks (spanning 10 to 30 seconds of compressed playback per transfer).
Deep-Sleep Host Residency: After bursting the compressed bitstream across the host interface via deep-buffer DMA, the host CPU immediately enters a deep C-state ($C10$). The host remains completely asleep while the DSP executes autonomous decoding.
Autonomous DSP Streaming: The DSP receives the bitstream in local SRAM, executes frame-by-frame bitstream parsing and synthesis, writes synthesized PCM samples into internal pipeline ring buffers, applies post-processing (sample rate conversion, channel mixing, and volume adjustment), and streams the final samples to the Digital Audio Interface (DAI) without host intervention.
Asynchronous Replenishment: Only when the DSP input ring buffer approaches an empty threshold does the DSP emit an interrupt or IPC message to wake the host CPU for the next bitstream burst.

Architectural Comparison: Streaming Paradigms #

Table 28 Architectural Comparison: Audio Playback Paradigms#
Architectural Vector	Traditional Host PCM Stream	DSP Fast-Decode Streaming	DSP Compress-Offload
Host CPU State	High-frequency wakeups (1 ms - 10 ms ticks; C0/C1)	Intermittent wakeups (every 100 ms to 500 ms)	Extended deep sleep (C10 package state 10s-30s)
Data Transferred	Uncompressed PCM (1.411 Mbps to 9.2 Mbps)	Partially decoded frames (variable bandwidth)	Raw compressed bitstream (128 kbps to 320 kbps)
Host DMA Bursts	Continuous trickle DMA (sub-millisecond intervals)	Periodic medium bursts (100 ms buffer chunks)	High-throughput deep burst (2 MB to 8 MB every 30s)
Decoding Engine	Host CPU (SW user space)	Host or DSP co-processor	DSP Tensilica HiFi Core (Cadence NatureDSP / XA)
DSP Memory RAM	Minimal (1 KB - 4 KB ring)	Moderate (8 KB - 16 KB)	High (16 KB - 64 KB SRAM) (Bitstream and State)
System Power	High (150 mW - 350 mW)	Moderate (80 mW - 150 mW)	Ultra-Low (< 25 mW - 45 mW)

Figure 203 SOF Compress-Offload Architecture: Host CPU Power-Down Timeline, Deep Buffer DMA, and DSP Autonomous Decoding Core#

Cadence Xtensa Audio (XA) API Standard & State Machine #

NatureDSP Abstraction Architecture #

Cadence Tensilica HiFi DSPs execute proprietary, highly vectorized audio codec libraries optimized with hand-crafted SIMD assembly. To prevent tight coupling between the SOF audio infrastructure and vendor-specific codec binaries, SOF adopts the standardized Cadence Xtensa Audio (XA) API (xa_codec_func_t).

The XA standard enforces a unified function prototype across every codec family:

\[\text{XA\_ERRORCODE}\quad \text{api\_func}(\text{xa\_codec\_handle\_t}\; \text{handle},\; \text{WORD32}\; \text{cmd},\; \text{WORD32}\; \text{idx},\; \text{pVOID}\; \text{value})\]

This abstraction guarantees that the SOF module adapter (cadence.c, cadence_ipc3.c, cadence_ipc4.c) interacts with every decoder and encoder through a clean, uniform command protocol regardless of internal algorithm complexity.

Standardized Lifecycle Commands & Protocol Execution #

The XA execution lifecycle progresses through four deterministic phases:

Size Query & Identification: - XA_API_CMD_GET_API_SIZE: Returns the exact byte count required for the persistent codec instance object (cd->self). - XA_API_CMD_GET_LIB_ID_STRINGS (with sub-command XA_CMD_TYPE_LIB_NAME): Queries the human-readable ASCII name of the underlying library for logging and diagnostics.
Pre-Configuration & Memory Table Negotiation: - XA_API_CMD_INIT (sub-command XA_CMD_TYPE_INIT_API_PRE_CONFIG_PARAMS): Initializes internal codec state variables to compile-time defaults. - XA_API_CMD_INIT (sub-command XA_CMD_TYPE_INIT_API_POST_CONFIG_PARAMS): Calculates the required sizes and alignment constraints of all external memory tables. - XA_API_CMD_GET_N_MEMTABS: Queries the total number of distinct memory tables required by the codec algorithm. - XA_API_CMD_GET_MEM_INFO_TYPE / SIZE / ALIGNMENT: Iterates across all memory tables to inspect usage types and alignment boundaries. - XA_API_CMD_SET_MEM_PTR: Binds allocated physical DSP SRAM blocks back to the codec handle.
Runtime Configuration & Process Initialization: - XA_API_CMD_SET_CONFIG_PARAM: Configures bitstream properties (e.g., bit depth, sampling frequency, channel count, and bitstream format such as ADTS). - XA_API_CMD_SET_INPUT_BYTES: Informs the codec of the exact number of valid encoded bytes staged in the input buffer. - XA_API_CMD_INIT (sub-command XA_CMD_TYPE_INIT_PROCESS): Consumes the initial bitstream header (e.g., ID3 tags, ADTS headers, or sync words) to initialize the parsing engine. - XA_API_CMD_INIT (sub-command XA_CMD_TYPE_INIT_DONE_QUERY): Queries whether the codec has completed stream synchronization and is prepared to output synthesized audio.
Execution & End-of-Stream Handling: - XA_API_CMD_EXECUTE (sub-command XA_CMD_TYPE_DO_EXECUTE): Executes the primary mathematical decoding/encoding transform over one audio frame. - XA_API_CMD_EXECUTE (sub-command XA_CMD_TYPE_DONE_QUERY): Verifies whether the current frame processing completed successfully. - XA_API_CMD_GET_OUTPUT_BYTES: Queries the count of valid uncompressed PCM bytes generated in the output buffer. - XA_API_CMD_GET_CURIDX_INPUT_BUF: Queries the byte offset in the input buffer indicating how many encoded bytes were consumed. - XA_API_CMD_INPUT_OVER: Explicitly signals to the codec that the upstream stream has ended, enabling proper flushing of synthesis filterbanks without truncation.

Figure 204 Cadence Xtensa Audio (XA) Codec Lifecycle State Machine & Execution Handshake#

Standard Memory Management & Buffer Partitioning #

The Four XA Memory Classes #

To achieve deterministic memory safety and eliminate run-time heap allocations in real-time execution, Cadence XA codecs categorize all required memory blocks into four standardized usage classes:

Table 29 Cadence Xtensa Audio Memory Classes#
Memory Class Macro	Storage Scope	Architectural Purpose & Lifetime
`XA_MEMTYPE_PERSIST`	Persistent DSP Memory	Holds internal filterbank delay lines, Huffman decode trees, quantization tables, and channel inter-frame state. Must remain untouched across consecutive frame processing calls.
`XA_MEMTYPE_SCRATCH`	Scratchpad Working RAM	Temporary calculation workspace used during FFTs, IMDCTs, subband filter evaluations, and bitstream unpacking. Reused safely by other modules when this codec is not executing.
`XA_MEMTYPE_INPUT`	Bitstream Input Staging	Contiguous linear memory block holding incoming compressed audio bytes presented to the codec parser.
`XA_MEMTYPE_OUTPUT`	Synthesized PCM Output	Contiguous linear memory block where the codec writes raw reconstructed PCM sample words before commitment to sink.

Two-Phase Dynamic Memory Allocation #

During component initialization in cadence_codec_init_memory_tables(), SOF executes a strict two-phase memory negotiation:

Table Metadata Query: The component queries XA_API_CMD_GET_N_MEMTABS, allocates an array of tracking pointers (cd->mem_to_be_freed), and iterates through each table index:

API_CALL(cd, XA_API_CMD_GET_MEM_INFO_TYPE, i, &mem_type, ret);
API_CALL(cd, XA_API_CMD_GET_MEM_INFO_SIZE, i, &mem_size, ret);
API_CALL(cd, XA_API_CMD_GET_MEM_INFO_ALIGNMENT, i, &mem_alignment, ret);

Aligned Allocation & Binding: Memory is allocated via SOF’s aligned allocator (mod_alloc_align()), ensuring strict SIMD data alignment (typically 8-byte, 16-byte, or 64-byte boundaries for 128-bit Tensilica vector loads). The allocated pointer is then assigned back to the codec:
```
ptr = mod_alloc_align(mod, mem_size, mem_alignment);
API_CALL(cd, XA_API_CMD_SET_MEM_PTR, i, ptr, ret);
```

Circular Buffer Boundary Resolution (Linearization)#

The Sound Open Firmware audio pipeline operates natively on circular ring buffers (sof_audio_buffer), where read and write pointers advance modulo the buffer boundary. However, external codec binaries (such as MP3 and AAC decoders) require strictly linear contiguous buffers for bitstream parsing and PCM generation.

To resolve this impedance mismatch without expensive heap allocations or copying overhead, SOF implements split-copy linearization functions (cadence_copy_data_from_buffer() and cadence_copy_data_to_buffer()):

\[\text{bytes\_to\_end} = \text{buffer\_start} + \text{buffer\_size} - \text{buffer\_ptr}\]

Non-Wrapping Case ($\text{bytes\_to\_end} \ge \text{bytes\_to\_copy}$): The entire quantum is transferred in a single direct contiguous copy (memcpy_s()).
Wrapping Case ($\text{bytes\_to\_end} < \text{bytes\_to\_copy}$): The transfer is segmented into two sub-copies: 1. Transfer $\text{bytes\_to\_end}$ from the current pointer up to the ring buffer boundary. 2. Transfer the remaining $\text{bytes\_to\_copy} - \text{bytes\_to\_end}$ from the base address of the ring buffer.

This guarantees that external codec engines always observe linear contiguous input and output arrays while preserving zero copy-buffer fragmentation across the SOF circular audio graph.

Figure 205 Cadence Codec Memory Architecture: Four-Class Allocation Tables & Circular Buffer Linearization Engine#

Supported Codecs, Encoders & In-Tree Reference Modules #

Codec Family Dispatch Architecture #

The SOF Media Codec subsystem uses a unified registry table (cadence_api_table[] of cadence_api) mapping ALSA compression codec identifiers (SND_AUDIOCODEC_*) and direction flags to concrete NatureDSP API dispatch pointers:

Table 30 Supported Codec Matrix & Framing Specifications#
Codec Standard	API Identifier	Direction	Frame Size (Samples)	Algorithmic Characteristics & Bitstream Formatting
MPEG-1 Layer 3 (MP3 Decoder)	`MP3_DEC_ID` (`0x06`)	Playback (Decoding)	1152 samples / frame (at 44.1/48 kHz)	Subband hybrid filterbank (32 bands), MDCT, Huffman coding, bit reservoir, 16/24-bit PCM output.
MPEG-1 Layer 3 (MP3 Encoder)	`MP3_ENC_ID` (`0x0A`)	Capture (Encoding)	1152 samples / frame	Real-time psychoacoustic masking model, bit reservoir, configurable bitrates (default 320 kbps), 16-bit PCM input.
Advanced Audio Coding (AAC)	`AAC_DEC_ID` (`0x02`)	Playback (Decoding)	1024 samples / frame (960 in LD mode)	MPEG-4 Audio Data Transport Stream (ADTS) bitstream format, temporal noise shaping (TNS), spectral band replication.
Ogg Vorbis (Vorbis Decoder)	`VORBIS_DEC_ID` (`0x08`)	Playback (Decoding)	Dynamic block sizes (64 to 8192 samples)	Variable Bitrate (VBR), MDCT filterbanks, vector quantization codebooks packed in bitstream headers.
Bluetooth SBC (SBC Decoder)	`SBC_DEC_ID` (`0x07`)	Playback (Decoding)	4, 8, 12, 16 blocks (up to 128 samples)	Subband coding, 4 or 8 subbands, loudness/SNR bit allocation for A2DP Bluetooth audio sinks.
PCM Reference (Passthrough Dec)	`PCM_DEC_ID` (`0xC0`)	Playback (Decoding)	Configurable buffer (up to 16 KB output)	In-tree open-source reference module implementing Cadence XA API for uncompressed compress-offload & CI regression.
DTS Interactive (DTS Virtual:X)	Dedicated UUID (`0x4fc3...`)	Playback (Effect / Proc)	Frame aligned (2048-byte byte-ctl)	Multi-channel surround virtualization, dynamic dialog enhancement, and psychoacoustic speaker tuning.

In-Tree Open-Source PCM Decoder Reference (`xa_pcm_dec.c`)#

To allow development, continuous integration (CI) testing, and automated unit testing without requiring proprietary NatureDSP static binary blobs, SOF includes a reference in-tree implementation of the Cadence XA API: PCM Decoder (xa_pcm_dec.c).

The PCM decoder advertises complete conformance to the XA command standard: - Implements xa_pcm_dec() responding to all commands (GET_API_SIZE, INIT, EXECUTE, SET_CONFIG_PARAM). - Manages an internal state machine (struct xa_pcm_dec_state) with 16 KB input and output buffers (PCM_DEC_IN_BUF_SIZE = 16384). - Implements a dedicated End-of-Stream Safety Counter (PCM_DEC_EOS_FULL_BUF_COUNT = 12): Because raw uncompressed PCM bitstreams contain no internal syntactic markers (such as MP3 frame syncs or AAC ADTS headers) to denote the end of valid data, the fallback counter detects trailing repeated buffers following an input_over command, preventing infinite decode loops and cleanly triggering pipeline EOS termination.

Third-Party Audio Codec Integration: DTS Audio (`dts.c`)#

Beyond standard lossy bitstream decoders, the SOF codec subsystem integrates specialized post-processing and spatializer codecs, exemplified by the DTS Audio Processing module (src/audio/codec/dts/dts.c).

The DTS integration adheres to the module adapter framework: - Wraps the vendor interface (DtsSofInterface) with standard SOF component callbacks (dts_effect_init(), dts_effect_prepare(), dts_effect_process()). - Operates as an audio effect widget (dts.conf, UUID 4f:c3:5f:d9:0f:37:c7:4a:bc:86:bf:dc:5b:e2:41:e6). - Exposes a 2048-byte runtime byte control (extctl, get/put handler 258) for dynamic sound profile switching, virtual surround configuration, and speaker calibration parameters. - Supports both static compilation and dynamic relocatable module packaging via Zephyr Loadable Linkable Extensions (LLEXT).

Figure 206 Codec Engine Architecture: Multi-Format Dispatcher, Frame Sizing & In-Tree PCM Reference Wrapper#

Control Plane Integration (IPC3 vs IPC4) & Asynchronous Notifications #

IPC3 Compress Interface Model #

In the legacy SOF IPC3 protocol, compressed audio parameters are delivered during stream initialization via the stream configuration blob (sof_ipc_stream_params). The extended data payload (stream_params->ext_data) conveys the raw Linux snd_codec structure:

Codec ID selection occurs statically during stream preparation (cadence_codec_resolve_api()).
IPC3 compress streaming is restricted exclusively to playback directions (SOF_IPC_STREAM_PLAYBACK).
Control adjustments (volume, mute) are handled by separate downstream volume components rather than direct codec parameter updates.

IPC4 Unified Module Architecture #

Under the modern Intel IPC4 architecture, media codecs are treated as first-class processing modules adhering to the unified IPC4 lifecycle:

Initialization Payload: The host passes initialization metadata via module_ext_init_data. The payload packs the complete snd_codec structure immediately followed by a 32-bit stream direction word (cd->direction).
Direction Flexibility: Full support for both playback (SOF_IPC_STREAM_PLAYBACK) and capture (SOF_IPC_STREAM_CAPTURE), enabling real-time on-DSP encoding pipelines.
Runtime Parameter Updates: Runtime bitrate or channel mode updates are delivered via Large Config Set messages, parsed and dispatched through cadence_codec_apply_params().
Data Processing (DP) Scheduling Domain: To ensure that computationally heavy decompression does not jitter ultra-low-latency real-time pipeline tasks (such as microphone beamforming), decoders are scheduled within the Data Processing ("DP") domain, running cooperatively on secondary DSP cores or lower thread priorities.

Asynchronous End-of-Stream (EOS) Notification Model #

A critical challenge in compressed playback is determining when the stream has terminated. In PCM streams, the host driver tracks exact sample playback positions. In compressed streams, however, because frame byte lengths vary dynamically, the host CPU cannot know when the last bitstream packet has been decoded without continuous polling.

To solve this, SOF implements an Asynchronous Unsolicited Notification Pipeline:

Pre-Allocated Notification Template: During module initialization (cadence_codec_notification_init()), SOF pre-allocates an IPC message container:

primary.r.notif_type = SOF_IPC4_MODULE_NOTIFICATION;
primary.r.type       = SOF_IPC4_GLB_NOTIFICATION;
primary.r.msg_tgt    = SOF_IPC4_MESSAGE_TARGET_FW_GEN_MSG;

Event Magic Value: The message payload binds the unique component ID with the compressed audio termination event:
```
msg_module_data->event_id = SOF_IPC4_NOTIFY_MODULE_EVENTID_COMPR_MAGIC_VAL;
```
Autonomous Firing: When the pipeline flags dev->pipeline->expect_eos and the codec signals completion (either via codec->mpd.produced == 0 or XA_API_CMD_EXECUTE_DONE_QUERY), SOF transmits the notification asynchronously (ipc_msg_send()).
Pipeline EOS Propagation: Simultaneously, SOF asserts the end-of-stream flag on the downstream sink buffer (audio_buffer_set_eos()), ensuring trailing samples flush through downstream SRC, volume, and mixer components without truncation or underrun clicks.

Figure 207 IPC4 Control Architecture, Codec Configuration Dispatch & Asynchronous EOS Event Pipeline#

ALSA Topology 2 Integration & Deep Buffer Playback Pipeline #

Topology 2 Widget Definitions #

ALSA Topology 2 modularizes codec components through dedicated Class.Widget definitions:

Decoder Widget (tools/topology/topology2/include/components/decoder.conf): Declares the primary decompression block with type "decoder" and UUID 43:84:21:d8:f3:5f:4c:4a:b3:88:6c:fe:07:b9:56:aa. Configures 1 input pin and 1 output pin, disabling dynamic power management (no_pm "true") to preserve persistent state.
Encoder Widget (tools/topology/topology2/include/components/encoder.conf): Declares the real-time compression block with type "encoder", sharing the Cadence codec UUID to invoke the capture path.
DTS Codec Widget (tools/topology/topology2/include/components/dts.conf): Declares the DTS post-processing engine (UUID 4f:c3:5f:d9:0f:37:c7:4a:bc:86:bf:dc:5b:e2:41:e6), binding external byte controls with handler ID 258.

Low-Power Deep-Buffer Pipeline Architecture #

In production topologies (such as tools/topology/topology2/include/pipelines/cavs/compr-playback.conf and platform/intel/compr.conf), the decoder is assembled into a specialized multi-stage, low-power playback graph:

Host Copier Ingress: Configured with deep-buffer DMA ($COMPR_DEEPBUFFER_MS, typically 2000 ms to 4000 ms), accommodating massive compressed bitstream bursts.
Decoder Engine: Bound to the Data Processing ("DP") scheduling domain and assigned to secondary DSP Core 1, isolating high-compute decompression from latency-critical audio mixing.
Module Copier (Format Adaptor): Normalizes output PCM samples into standard 32-bit signed containers ($S32\_LE$).
Sample Rate Converter (SRC): Resamples variable decoded rates (e.g. 44.1 kHz CD audio) to the system-wide fixed hardware mixing frequency (48 kHz or 96 kHz).
Channel Selector / Matrix: Remaps audio channels or executes stereo/mono up/downmixing (stereo_endpoint_playback_updownmix).
Pre-Mixer Volume / Gain: Applies individual stream attenuation before merging into the main mixer.
Mixin Endpoint: Ingests the decoded, volume-scaled stream into the primary mixing pipeline (lp_mode 1), where it combines with standard system sounds, alerts, and notifications.

Figure 208 ALSA Topology 2 Deep-Buffer Compressed Playback Pipeline Graph#

Factory Bringup, User-Space Offload & Verification Runbook #

This runbook outlines procedures to verify compressed audio offload pipelines, test standalone decoders, query capabilities, and measure host power savings.

1. Capabilities Query via ALSA Compress-Offload #

Verify that the kernel and DSP firmware correctly advertise compressed codec support:

# Step 1: Query ALSA compress device nodes
ls -la /dev/snd/compr*

# Step 2: Query supported codecs and formats via tinycompress utility
cplay -k -d 0 -c 1

# Expected Output:
# Number of codecs supported: 3
# Codec 0: ID 2 (SND_AUDIOCODEC_MP3)
#   Sample Rates: 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 Hz
#   Bitrates: 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 kbps
# Codec 1: ID 6 (SND_AUDIOCODEC_AAC)
#   Bitstream Formats: ADTS (MPEG-4)
# Codec 2: ID 1 (SND_AUDIOCODEC_PCM)

2. Compressed Playback Streaming via tinycompress #

Stream an encoded MP3 or AAC file directly to the DSP offload hardware:

# Step 1: Play MP3 audio via ALSA compress offload
cplay -d 0 -c 1 /usr/share/sounds/test_audio_44k_320kbps.mp3

# Step 2: Verify live DSP log traces via mtrace or probe server
# Look for Cadence XA initialization and frame consumption:
# [DSP] cadence_codec_init() done
# [DSP] cadence_codec_prepare() period set to 24000 usec
# [DSP] cadence_codec_process() decoded 1152 samples, consumed 1045 bytes

3. Compressed Capture & Encoding Validation #

Validate real-time compressed capture offload using the MP3 encoder:

# Step 1: Record 10 seconds of compressed MP3 capture from microphone
crecord -d 0 -c 2 -b 320 -s 48000 -r 10 /tmp/dsp_encoded_capture.mp3

# Step 2: Validate the generated MP3 bitstream integrity
ffprobe /tmp/dsp_encoded_capture.mp3

# Expected:
# Input #0, mp3, from '/tmp/dsp_encoded_capture.mp3':
#   Duration: 00:00:10.00, bitrate: 320 kb/s
#   Stream #0:0: Audio: mp3, 48000 Hz, stereo, fltp, 320 kb/s

4. Power Telemetry & Host Deep-Sleep Verification #

Measure the host CPU power residency during compressed offload versus standard PCM playback to confirm the power-saving benefit:

# Step 1: Monitor CPU Package C-State residency using turbostat
sudo turbostat --quiet --interval 5 --show Pkg_%pc10,PkgWatt

# Test Case A: Standard PCM Playback (aplay -D plughw:0,0 test.wav)
# Pkg_%pc10: 12.4% | PkgWatt: 2.85 W (High host wakeup overhead)

# Test Case B: Compress-Offload Playback (cplay -d 0 -c 1 test.mp3)
# Pkg_%pc10: 94.8% | PkgWatt: 0.38 W (Near-complete host C10 residency)

5. Standalone Testbench Loopback & Bit-Exactness Testing #

Run the SOF standalone testbench to verify decoding linearity without hardware:

# Run testbench with reference PCM decoder
sof-testbench -p -i test_input.raw -o pcm_decoded_output.raw \
  -t tools/topology/topology2/build/topology1/compr_playback_test.tplg

# Validate output against reference golden vector
diff -q pcm_decoded_output.raw test_golden_reference.raw

Figure 209 Comprehensive Verification & Bringup Workflow: tinycompress Offload, DSP Decoding & Power Telemetry#