diff --git a/case-lib/webrtc.sh b/case-lib/webrtc.sh new file mode 100644 index 00000000..56c35c07 --- /dev/null +++ b/case-lib/webrtc.sh @@ -0,0 +1,241 @@ +#!/bin/bash + +# Shared WebRTC test helpers for topology discovery, mixer save/restore, +# and stimulus/capture routing across SSP loopback, local USB audio, and host PC. + +WEBRTC_TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")"/../tools && pwd)" +export PATH="${WEBRTC_TOOLS_DIR}:${PATH}" + +declare -Ag WEBRTC_SAVED_SWITCHES=() + +# Discover WebRTC widgets/kcontrols from topology, falling back to amixer scan +# Args: $1 = tplg path(s), $2 = filter type (hpf|agc|aec|vad|ns|ns2|all) +func_webrtc_discover_controls() +{ + local tplg_files="${1//:/,}" + local target_type="${2:-all}" + local sofcard="${SOFCARD:-0}" + local out="" + + if command -v topo_webrtc_kcontrols.py >/dev/null 2>&1; then + out=$(topo_webrtc_kcontrols.py "$tplg_files" --type "$target_type" 2>/dev/null || true) + fi + + if [ -n "$out" ]; then + printf '%s\n' "$out" + return 0 + fi + + # Fallback on minimal DUTs without python3-construct + local pattern="" + case "$target_type" in + hpf) pattern="HPF Switch" ;; + agc) pattern="AGC Switch" ;; + aec) pattern="AEC (Suppression )?Switch|webrtc-aec\." ;; + *) pattern="(HPF|AGC|AEC (Suppression )?)Switch|webrtc-aec\." ;; + esac + + amixer -c "$sofcard" controls 2>/dev/null | \ + grep -E "name='.*(${pattern})" | \ + sed -n "s/.*name='\([^']*\)'.*/${target_type}|${target_type}|\1|MIXER/p" || true +} + +# Read current integer/boolean switch value from amixer +func_webrtc_get_switch() +{ + local sofcard="$1" + local ctrl="$2" + amixer -c "$sofcard" cget "name=${ctrl}" 2>/dev/null | \ + sed -n 's/^ : values=\([0-9]*\).*/\1/p' | head -n1 +} + +# Save switch state once and set new value (0/1 or off/on) +func_webrtc_set_switch() +{ + local sofcard="$1" + local ctrl="$2" + local val="$3" + + if [ -z "${WEBRTC_SAVED_SWITCHES[$ctrl]+x}" ]; then + local orig + orig=$(func_webrtc_get_switch "$sofcard" "$ctrl" || true) + if [ -n "$orig" ]; then + WEBRTC_SAVED_SWITCHES["$ctrl"]="$orig" + fi + fi + + dlogc "amixer -c $sofcard cset name='${ctrl}' ${val}" + amixer -c "$sofcard" cset "name=${ctrl}" "$val" >/dev/null || + die "Failed to set switch '${ctrl}' to '${val}' on card ${sofcard}" + + local expected="0" + if [ "$val" = "1" ] || [ "$val" = "on" ]; then + expected="1" + fi + local actual + actual=$(func_webrtc_get_switch "$sofcard" "$ctrl" || true) + [ "$actual" = "$expected" ] || + die "Readback mismatch for '${ctrl}': expected ${expected}, got '${actual}'" +} + +func_webrtc_restore_switches() +{ + local sofcard="${SOFCARD:-0}" + local ctrl + for ctrl in "${!WEBRTC_SAVED_SWITCHES[@]}"; do + dlogi "Restoring control '${ctrl}' = ${WEBRTC_SAVED_SWITCHES[$ctrl]}" + amixer -c "$sofcard" cset "name=${ctrl}" "${WEBRTC_SAVED_SWITCHES[$ctrl]}" >/dev/null 2>&1 || true + done +} + +# Resolve non-SOF local USB audio playback/capture PCM (e.g. plughw:1,0) +func_webrtc_detect_usb_pcm() +{ + local explicit_pcm="$1" + local sofcard="${SOFCARD:-0}" + + if [ -n "$explicit_pcm" ]; then + printf '%s\n' "$explicit_pcm" + return 0 + fi + if [ -n "${WEBRTC_USB_PCM:-}" ]; then + printf '%s\n' "$WEBRTC_USB_PCM" + return 0 + fi + + local card_idx + card_idx=$(awk -v sc="$sofcard" ' + /^[[:space:]]*[0-9]+ \[/ { + c = $1 + 0 + line = $0 + if (c != sc && tolower(line) ~ /usb/) { + print c + exit + } + } + ' /proc/asound/cards 2>/dev/null || true) + + [ -n "$card_idx" ] || return 1 + printf 'plughw:%s,0\n' "$card_idx" +} + +# Find first capture pipeline matching optional PCM substring +# Sets globals: WEBRTC_CAP_DEV WEBRTC_CAP_RATE WEBRTC_CAP_FMT WEBRTC_CAP_CH WEBRTC_CAP_PCM +func_webrtc_select_capture_pipeline() +{ + local tplg="$1" + local cap_filter="${2:-type:capture}" + local preferred_pcm="${3:-}" + + func_pipeline_export "$tplg" "$cap_filter" + local chosen=0 idx pcm_name + if [ -n "$preferred_pcm" ]; then + for idx in $(seq 0 $((PIPELINE_COUNT - 1))); do + pcm_name=$(func_pipeline_parse_value "$idx" pcm) + if [[ "$pcm_name" == *"$preferred_pcm"* ]]; then + chosen="$idx" + break + fi + done + fi + + WEBRTC_CAP_DEV=$(func_pipeline_parse_value "$chosen" dev) + WEBRTC_CAP_RATE=$(func_pipeline_parse_value "$chosen" rate) + WEBRTC_CAP_FMT=$(func_pipeline_parse_value "$chosen" fmt) + WEBRTC_CAP_CH=$(func_pipeline_parse_value "$chosen" ch_min) + WEBRTC_CAP_PCM=$(func_pipeline_parse_value "$chosen" pcm) + [ -n "$WEBRTC_CAP_DEV" ] || die "Failed to select capture pipeline" +} + +# Run synchronized stimulus playback + capture for non-AEC profiles +# Args: $1=io_mode (ssp|usb|host), $2=stim_wav, $3=out_wav, $4=dur_sec, +# $5=tplg, $6=usb_pcm, $7=host_cmd +func_webrtc_capture_stimulus() +{ + local io_mode="$1" + local stim_wav="$2" + local out_wav="$3" + local dur_sec="$4" + local tplg="$5" + local usb_pcm="$6" + local host_cmd="$7" + + rm -f "$out_wav" + dlogc "arecord -D $WEBRTC_CAP_DEV -f $WEBRTC_CAP_FMT -r $WEBRTC_CAP_RATE -c $WEBRTC_CAP_CH -d $dur_sec $out_wav" + arecord -D "$WEBRTC_CAP_DEV" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d "$dur_sec" "$out_wav" & + local rec_pid=$! + sleep 0.25 + + local play_rc=0 + case "$io_mode" in + ssp) + local pb_dev="" idx pb_pcm + func_pipeline_export "$tplg" "type:playback" + for idx in $(seq 0 $((PIPELINE_COUNT - 1))); do + pb_pcm=$(func_pipeline_parse_value "$idx" pcm) + if [ "$pb_pcm" = "$WEBRTC_CAP_PCM" ] || [ -z "$pb_dev" ]; then + pb_dev=$(func_pipeline_parse_value "$idx" dev) + [ "$pb_pcm" = "$WEBRTC_CAP_PCM" ] && break + fi + done + [ -n "$pb_dev" ] || { + kill "$rec_pid" 2>/dev/null || true + wait "$rec_pid" 2>/dev/null || true + die "No playback pipeline found for SSP loopback mode" + } + dlogc "aplay -D $pb_dev $stim_wav" + aplay -D "$pb_dev" "$stim_wav" || play_rc=$? + ;; + usb) + local resolved_usb + resolved_usb=$(func_webrtc_detect_usb_pcm "$usb_pcm") || { + kill "$rec_pid" 2>/dev/null || true + wait "$rec_pid" 2>/dev/null || true + skip_test "No USB audio device found (pass -U plughw:N,0)" + } + dlogc "aplay -D $resolved_usb $stim_wav" + aplay -D "$resolved_usb" "$stim_wav" || play_rc=$? + ;; + host) + local cmd_tpl="${host_cmd:-${WEBRTC_HOST_PLAY_CMD:-}}" + [ -n "$cmd_tpl" ] || { + kill "$rec_pid" 2>/dev/null || true + wait "$rec_pid" 2>/dev/null || true + skip_test "Host mode requires -H '' or WEBRTC_HOST_PLAY_CMD" + } + if [[ "$cmd_tpl" == *"{wav}"* ]]; then + local expanded="${cmd_tpl//\{wav\}/\"$stim_wav\"}" + dlogc "$expanded" + eval "$expanded" || play_rc=$? + else + dlogc "$cmd_tpl < $stim_wav" + eval "$cmd_tpl" < "$stim_wav" || play_rc=$? + fi + ;; + *) + kill "$rec_pid" 2>/dev/null || true + wait "$rec_pid" 2>/dev/null || true + die "Unsupported io_mode '$io_mode'" + ;; + esac + + local rec_rc=0 + wait "$rec_pid" || rec_rc=$? + [ "$play_rc" -eq 0 ] || die "Stimulus playback failed (rc=$play_rc, mode=$io_mode)" + [ "$rec_rc" -eq 0 ] || die "DUT capture failed on $WEBRTC_CAP_DEV (rc=$rec_rc)" + [ -s "$out_wav" ] || die "Captured WAV $out_wav is empty" +} + +func_webrtc_on_exit() +{ + local rc="$1" + func_webrtc_restore_switches + func_exit_handler "$rc" +} + +# Preserve lib.sh func_exit_handler while guaranteeing mixer switches restore on exit +func_webrtc_register_cleanup() +{ + trap 'func_webrtc_on_exit "$?"' EXIT SIGTERM +} diff --git a/test-case/check-webrtc-aec.sh b/test-case/check-webrtc-aec.sh new file mode 100755 index 00000000..9edcc040 --- /dev/null +++ b/test-case/check-webrtc-aec.sh @@ -0,0 +1,212 @@ +#!/bin/bash + +set -e + +## +## Case Name: check-webrtc-aec +## Preconditions: +## Topology contains a webrtc-aec widget (nocodec SSP0+SSP2, HDA, or SDW) +## Description: +## 1. Verify capture-only, playback-only, and dynamic mid-stream playback +## attach/detach lifecycle without capture stalls or XRUNs. +## 2. Verify far-end single-talk ERLE and double-talk near-end preservation +## across AEC Switch OFF vs ON (and Suppression Switch where present). +## + +# shellcheck source=case-lib/lib.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/lib.sh +# shellcheck source=case-lib/webrtc.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/webrtc.sh + +OPT_NAME['t']='tplg' OPT_DESC['t']="tplg file, default value is env TPLG" +OPT_HAS_ARG['t']=1 OPT_VAL['t']="$TPLG" +OPT_NAME['m']='io-mode' OPT_DESC['m']='Audio mode: ssp | loopback | usb | host' +OPT_HAS_ARG['m']=1 OPT_VAL['m']='ssp' +OPT_NAME['U']='usb-pcm' OPT_DESC['U']='USB ALSA PCM (for -m usb)' +OPT_HAS_ARG['U']=1 OPT_VAL['U']='' +OPT_NAME['H']='host-cmd' OPT_DESC['H']='Host play command (for -m host)' +OPT_HAS_ARG['H']=1 OPT_VAL['H']='' +OPT_NAME['l']='loop' OPT_DESC['l']='loop count' +OPT_HAS_ARG['l']=1 OPT_VAL['l']=1 +OPT_NAME['s']='sof-logger' OPT_DESC['s']="Open sof-logger trace stored at $LOG_ROOT" +OPT_HAS_ARG['s']=0 OPT_VAL['s']=1 + +func_opt_parse_option "$@" + +tplg=${OPT_VAL['t']} +io_mode=${OPT_VAL['m']} +usb_pcm=${OPT_VAL['U']} +host_cmd=${OPT_VAL['H']} +loop_cnt=${OPT_VAL['l']} + +start_test +func_webrtc_register_cleanup +logger_disabled || func_lib_start_log_collect + +func_webrtc_select_capture_pipeline "$tplg" "type:capture" +sofcard="${SOFCARD:-0}" + +mapfile -t aec_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "aec") +[ ${#aec_rows[@]} -gt 0 ] || skip_test "No webrtc-aec widget in $TPLG_FILES" + +aec_sw="" +aec_sup="" +for row in "${aec_rows[@]}"; do + IFS='|' read -r _ _ ctrl _ <<< "$row" + [ -z "$ctrl" ] && continue + if [[ "$ctrl" == *"Suppression Switch"* ]]; then + aec_sup="$ctrl" + else + aec_sw="$ctrl" + fi +done + +# Discover playback pipeline(s): mic-loopback (PCM 0) and/or echo-ref (PCM 2 / HDA / SDW) +func_pipeline_export "$tplg" "type:playback" +pb_first_dev=$(func_pipeline_parse_value 0 dev) +pb_ref_dev="$pb_first_dev" +pb_mic_dev="$pb_first_dev" +for idx in $(seq 0 $((PIPELINE_COUNT - 1))); do + pcm_name=$(func_pipeline_parse_value "$idx" pcm) + pdev=$(func_pipeline_parse_value "$idx" dev) + if [[ "$pcm_name" == *"SSP2"* ]] || [ "$pdev" != "$pb_mic_dev" ]; then + if [ "$pcm_name" = "$WEBRTC_CAP_PCM" ]; then + pb_mic_dev="$pdev" + else + pb_ref_dev="$pdev" + fi + fi +done +[ -n "$pb_ref_dev" ] || die "No playback pipeline found for AEC reference" + +work_dir="$LOG_ROOT/webrtc-aec" +mkdir -p "$work_dir" + +# Phase 1: Single-source / dynamic ref lifecycle (works on every AEC topology) +dlogi "===== AEC Phase 1: capture-only, playback-only, dynamic mid-stream ref =====" +[ -n "$aec_sw" ] && func_webrtc_set_switch "$sofcard" "$aec_sw" on +[ -n "$aec_sup" ] && func_webrtc_set_switch "$sofcard" "$aec_sup" on + +arecord -D "$WEBRTC_CAP_DEV" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d 2 "${work_dir}/life_cap_only.wav" || + die "AEC capture-only failed" + +aplay -D "$pb_ref_dev" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d 2 /dev/zero || + die "AEC playback-only failed" + +dyn_cap="${work_dir}/life_dynamic_ref.wav" +rm -f "$dyn_cap" +arecord -D "$WEBRTC_CAP_DEV" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d 7 "$dyn_cap" & +dyn_cap_pid=$! +sleep 2 +aplay -D "$pb_ref_dev" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d 3 /dev/zero || { + kill "$dyn_cap_pid" 2>/dev/null || true + wait "$dyn_cap_pid" 2>/dev/null || true + die "Dynamic mid-stream AEC ref playback failed" +} +wait "$dyn_cap_pid" || die "Dynamic mid-stream AEC capture failed" + +min_bytes=$((WEBRTC_CAP_RATE * WEBRTC_CAP_CH * 2 * 6)) +actual_bytes=$(wc -c < "$dyn_cap") +[ "$actual_bytes" -ge "$min_bytes" ] || + die "Dynamic AEC capture stalled: got $actual_bytes bytes (< $min_bytes)" + +# Phase 2: Echo cancellation DSP quality +mic_wav="${work_dir}/stim_aec_mic.wav" +ref_wav="${work_dir}/stim_aec_ref.wav" +sof-webrtc-tool.py generate --profile aec --rate "$WEBRTC_CAP_RATE" \ + --channels "$WEBRTC_CAP_CH" --format "$WEBRTC_CAP_FMT" \ + --out-mic "$mic_wav" --out-ref "$ref_wav" + +run_aec_pass() +{ + local out_wav="$1" + rm -f "$out_wav" + arecord -D "$WEBRTC_CAP_DEV" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d 7 "$out_wav" & + local rec_pid=$! + sleep 0.25 + + aplay -D "$pb_ref_dev" "$ref_wav" & + local ref_pid=$! + + local mic_rc=0 + case "$io_mode" in + ssp) + if [ "$pb_mic_dev" != "$pb_ref_dev" ]; then + aplay -D "$pb_mic_dev" "$mic_wav" || mic_rc=$? + fi + ;; + loopback) + ;; + usb) + local resolved_usb + resolved_usb=$(func_webrtc_detect_usb_pcm "$usb_pcm") || { + kill "$ref_pid" "$rec_pid" 2>/dev/null || true + wait "$ref_pid" "$rec_pid" 2>/dev/null || true + skip_test "No USB audio device found (pass -U plughw:N,0)" + } + aplay -D "$resolved_usb" "$mic_wav" || mic_rc=$? + ;; + host) + local cmd_tpl="${host_cmd:-${WEBRTC_HOST_PLAY_CMD:-}}" + [ -n "$cmd_tpl" ] || { + kill "$ref_pid" "$rec_pid" 2>/dev/null || true + wait "$ref_pid" "$rec_pid" 2>/dev/null || true + skip_test "Host mode requires -H '' or WEBRTC_HOST_PLAY_CMD" + } + if [[ "$cmd_tpl" == *"{wav}"* ]]; then + eval "${cmd_tpl//\{wav\}/\"$mic_wav\"}" || mic_rc=$? + else + eval "$cmd_tpl" < "$mic_wav" || mic_rc=$? + fi + ;; + *) + kill "$ref_pid" "$rec_pid" 2>/dev/null || true + die "Unsupported io_mode '$io_mode'" + ;; + esac + + local ref_rc=0 rec_rc=0 + wait "$ref_pid" || ref_rc=$? + wait "$rec_pid" || rec_rc=$? + if [ "$mic_rc" -ne 0 ] || [ "$ref_rc" -ne 0 ] || [ "$rec_rc" -ne 0 ]; then + die "AEC playback/capture stream failed (mic=$mic_rc ref=$ref_rc rec=$rec_rc)" + fi +} + +single_talk_flag="" +if [ "$io_mode" = "loopback" ] || { [ "$io_mode" = "ssp" ] && [ "$pb_mic_dev" = "$pb_ref_dev" ]; }; then + single_talk_flag="--single-talk-only" +fi + +for iter in $(seq 1 "$loop_cnt"); do + dlogi "===== AEC Phase 2 iteration $iter/$loop_cnt (mode=$io_mode) =====" + off_wav="${work_dir}/cap_aec_off_${iter}.wav" + on_wav="${work_dir}/cap_aec_on_${iter}.wav" + + if [ -n "$aec_sw" ]; then + func_webrtc_set_switch "$sofcard" "$aec_sw" off + [ -n "$aec_sup" ] && func_webrtc_set_switch "$sofcard" "$aec_sup" off + run_aec_pass "$off_wav" + + func_webrtc_set_switch "$sofcard" "$aec_sw" on + [ -n "$aec_sup" ] && func_webrtc_set_switch "$sofcard" "$aec_sup" on + run_aec_pass "$on_wav" + + # shellcheck disable=SC2086 + sof-webrtc-tool.py analyze --profile aec --captured "$on_wav" \ + --baseline "$off_wav" $single_talk_flag || + die "WebRTC AEC A/B ERLE verification failed" + else + run_aec_pass "$on_wav" + # shellcheck disable=SC2086 + sof-webrtc-tool.py analyze --profile aec --captured "$on_wav" $single_talk_flag || + die "WebRTC AEC verification failed" + fi +done + +sof-kernel-log-check.sh "$KERNEL_CHECKPOINT" diff --git a/test-case/check-webrtc-agc.sh b/test-case/check-webrtc-agc.sh new file mode 100755 index 00000000..5f03d0ae --- /dev/null +++ b/test-case/check-webrtc-agc.sh @@ -0,0 +1,73 @@ +#!/bin/bash + +set -e + +## +## Case Name: check-webrtc-agc +## Preconditions: +## Topology contains a webrtc-agc widget and AGC Switch mixer control +## Description: +## Verify WebRTC digital AGC boosts quiet signals and limits near-full-scale +## signals without digital clipping (Switch ON vs OFF A/B). +## + +# shellcheck source=case-lib/lib.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/lib.sh +# shellcheck source=case-lib/webrtc.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/webrtc.sh + +OPT_NAME['t']='tplg' OPT_DESC['t']="tplg file, default value is env TPLG" +OPT_HAS_ARG['t']=1 OPT_VAL['t']="$TPLG" +OPT_NAME['m']='io-mode' OPT_DESC['m']='Audio injection mode: ssp | usb | host' +OPT_HAS_ARG['m']=1 OPT_VAL['m']='ssp' +OPT_NAME['U']='usb-pcm' OPT_DESC['U']='USB ALSA PCM (for -m usb)' +OPT_HAS_ARG['U']=1 OPT_VAL['U']='' +OPT_NAME['H']='host-cmd' OPT_DESC['H']='Host play command (for -m host)' +OPT_HAS_ARG['H']=1 OPT_VAL['H']='' +OPT_NAME['l']='loop' OPT_DESC['l']='loop count' +OPT_HAS_ARG['l']=1 OPT_VAL['l']=1 +OPT_NAME['s']='sof-logger' OPT_DESC['s']="Open sof-logger trace stored at $LOG_ROOT" +OPT_HAS_ARG['s']=0 OPT_VAL['s']=1 + +func_opt_parse_option "$@" + +tplg=${OPT_VAL['t']} +io_mode=${OPT_VAL['m']} +usb_pcm=${OPT_VAL['U']} +host_cmd=${OPT_VAL['H']} +loop_cnt=${OPT_VAL['l']} + +start_test +func_webrtc_register_cleanup +logger_disabled || func_lib_start_log_collect + +func_webrtc_select_capture_pipeline "$tplg" "type:capture" +sofcard="${SOFCARD:-0}" + +mapfile -t agc_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "agc") +[ ${#agc_rows[@]} -gt 0 ] || skip_test "No webrtc-agc widget in $TPLG_FILES" +IFS='|' read -r _ _ agc_ctrl _ <<< "${agc_rows[0]}" +[ -n "$agc_ctrl" ] || skip_test "No AGC Switch control found in $TPLG_FILES" + +work_dir="$LOG_ROOT/webrtc-agc" +mkdir -p "$work_dir" +stim_wav="${work_dir}/stim_agc.wav" +sof-webrtc-tool.py generate --profile agc --rate "$WEBRTC_CAP_RATE" \ + --channels "$WEBRTC_CAP_CH" --format "$WEBRTC_CAP_FMT" --output "$stim_wav" + +for iter in $(seq 1 "$loop_cnt"); do + dlogi "===== check-webrtc-agc iteration $iter/$loop_cnt (mode=$io_mode) =====" + off_wav="${work_dir}/cap_agc_off_${iter}.wav" + on_wav="${work_dir}/cap_agc_on_${iter}.wav" + + func_webrtc_set_switch "$sofcard" "$agc_ctrl" off + func_webrtc_capture_stimulus "$io_mode" "$stim_wav" "$off_wav" 6 "$tplg" "$usb_pcm" "$host_cmd" + + func_webrtc_set_switch "$sofcard" "$agc_ctrl" on + func_webrtc_capture_stimulus "$io_mode" "$stim_wav" "$on_wav" 6 "$tplg" "$usb_pcm" "$host_cmd" + + sof-webrtc-tool.py analyze --profile agc --captured "$on_wav" --baseline "$off_wav" || + die "WebRTC AGC verification failed" +done + +sof-kernel-log-check.sh "$KERNEL_CHECKPOINT" diff --git a/test-case/check-webrtc-hpf.sh b/test-case/check-webrtc-hpf.sh new file mode 100755 index 00000000..433ccc6c --- /dev/null +++ b/test-case/check-webrtc-hpf.sh @@ -0,0 +1,80 @@ +#!/bin/bash + +set -e + +## +## Case Name: check-webrtc-hpf +## Preconditions: +## Topology contains a webrtc-hpf widget and HPF Switch mixer control +## Description: +## Verify WebRTC 2nd-order Butterworth high-pass filter attenuates 40 Hz +## rumble while preserving 1 kHz passband audio (Switch ON vs OFF A/B). +## + +# shellcheck source=case-lib/lib.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/lib.sh +# shellcheck source=case-lib/webrtc.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/webrtc.sh + +OPT_NAME['t']='tplg' OPT_DESC['t']="tplg file, default value is env TPLG" +OPT_HAS_ARG['t']=1 OPT_VAL['t']="$TPLG" +OPT_NAME['m']='io-mode' OPT_DESC['m']='Audio injection mode: ssp | usb | host' +OPT_HAS_ARG['m']=1 OPT_VAL['m']='ssp' +OPT_NAME['U']='usb-pcm' OPT_DESC['U']='USB ALSA PCM (for -m usb)' +OPT_HAS_ARG['U']=1 OPT_VAL['U']='' +OPT_NAME['H']='host-cmd' OPT_DESC['H']='Host play command (for -m host)' +OPT_HAS_ARG['H']=1 OPT_VAL['H']='' +OPT_NAME['l']='loop' OPT_DESC['l']='loop count' +OPT_HAS_ARG['l']=1 OPT_VAL['l']=1 +OPT_NAME['s']='sof-logger' OPT_DESC['s']="Open sof-logger trace stored at $LOG_ROOT" +OPT_HAS_ARG['s']=0 OPT_VAL['s']=1 + +func_opt_parse_option "$@" + +tplg=${OPT_VAL['t']} +io_mode=${OPT_VAL['m']} +usb_pcm=${OPT_VAL['U']} +host_cmd=${OPT_VAL['H']} +loop_cnt=${OPT_VAL['l']} + +start_test +func_webrtc_register_cleanup +logger_disabled || func_lib_start_log_collect + +func_webrtc_select_capture_pipeline "$tplg" "type:capture" +sofcard="${SOFCARD:-0}" + +mapfile -t hpf_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "hpf") +[ ${#hpf_rows[@]} -gt 0 ] || skip_test "No webrtc-hpf widget in $TPLG_FILES" +IFS='|' read -r _ _ hpf_ctrl _ <<< "${hpf_rows[0]}" +[ -n "$hpf_ctrl" ] || skip_test "No HPF Switch control found in $TPLG_FILES" + +# Bypass AGC switch if present so level measurements reflect HPF cleanly +mapfile -t agc_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "agc") +if [ ${#agc_rows[@]} -gt 0 ]; then + IFS='|' read -r _ _ agc_ctrl _ <<< "${agc_rows[0]}" + [ -n "$agc_ctrl" ] && func_webrtc_set_switch "$sofcard" "$agc_ctrl" off +fi + +work_dir="$LOG_ROOT/webrtc-hpf" +mkdir -p "$work_dir" +stim_wav="${work_dir}/stim_hpf.wav" +sof-webrtc-tool.py generate --profile hpf --rate "$WEBRTC_CAP_RATE" \ + --channels "$WEBRTC_CAP_CH" --format "$WEBRTC_CAP_FMT" --output "$stim_wav" + +for iter in $(seq 1 "$loop_cnt"); do + dlogi "===== check-webrtc-hpf iteration $iter/$loop_cnt (mode=$io_mode) =====" + off_wav="${work_dir}/cap_hpf_off_${iter}.wav" + on_wav="${work_dir}/cap_hpf_on_${iter}.wav" + + func_webrtc_set_switch "$sofcard" "$hpf_ctrl" off + func_webrtc_capture_stimulus "$io_mode" "$stim_wav" "$off_wav" 4 "$tplg" "$usb_pcm" "$host_cmd" + + func_webrtc_set_switch "$sofcard" "$hpf_ctrl" on + func_webrtc_capture_stimulus "$io_mode" "$stim_wav" "$on_wav" 4 "$tplg" "$usb_pcm" "$host_cmd" + + sof-webrtc-tool.py analyze --profile hpf --captured "$on_wav" --baseline "$off_wav" || + die "WebRTC HPF verification failed" +done + +sof-kernel-log-check.sh "$KERNEL_CHECKPOINT" diff --git a/test-case/check-webrtc-ns.sh b/test-case/check-webrtc-ns.sh new file mode 100755 index 00000000..ff485af3 --- /dev/null +++ b/test-case/check-webrtc-ns.sh @@ -0,0 +1,86 @@ +#!/bin/bash + +set -e + +## +## Case Name: check-webrtc-ns +## Preconditions: +## Topology contains a webrtc-ns or webrtc-ns2 widget +## Description: +## Verify WebRTC NS (16 kHz) / NS2 RNNoise (48 kHz) attenuates stationary +## noise after convergence while preserving speech-band multitone SNR. +## + +# shellcheck source=case-lib/lib.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/lib.sh +# shellcheck source=case-lib/webrtc.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/webrtc.sh + +OPT_NAME['t']='tplg' OPT_DESC['t']="tplg file, default value is env TPLG" +OPT_HAS_ARG['t']=1 OPT_VAL['t']="$TPLG" +OPT_NAME['m']='io-mode' OPT_DESC['m']='Audio injection mode: ssp | usb | host' +OPT_HAS_ARG['m']=1 OPT_VAL['m']='ssp' +OPT_NAME['U']='usb-pcm' OPT_DESC['U']='USB ALSA PCM (for -m usb)' +OPT_HAS_ARG['U']=1 OPT_VAL['U']='' +OPT_NAME['H']='host-cmd' OPT_DESC['H']='Host play command (for -m host)' +OPT_HAS_ARG['H']=1 OPT_VAL['H']='' +OPT_NAME['l']='loop' OPT_DESC['l']='loop count' +OPT_HAS_ARG['l']=1 OPT_VAL['l']=1 +OPT_NAME['s']='sof-logger' OPT_DESC['s']="Open sof-logger trace stored at $LOG_ROOT" +OPT_HAS_ARG['s']=0 OPT_VAL['s']=1 + +func_opt_parse_option "$@" + +tplg=${OPT_VAL['t']} +io_mode=${OPT_VAL['m']} +usb_pcm=${OPT_VAL['U']} +host_cmd=${OPT_VAL['H']} +loop_cnt=${OPT_VAL['l']} + +start_test +func_webrtc_register_cleanup +logger_disabled || func_lib_start_log_collect + +func_webrtc_select_capture_pipeline "$tplg" "type:capture" +sofcard="${SOFCARD:-0}" + +ns_profile="" +mapfile -t ns2_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "ns2") +if [ ${#ns2_rows[@]} -gt 0 ]; then + ns_profile="ns2" +else + mapfile -t ns_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "ns") + if [ ${#ns_rows[@]} -gt 0 ]; then + ns_profile="ns" + fi +fi +[ -n "$ns_profile" ] || skip_test "No webrtc-ns or webrtc-ns2 widget in $TPLG_FILES" + +# Keep HPF on (removes sub-80Hz bias) and AGC off so NS noise reduction isn't re-amplified +mapfile -t hpf_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "hpf") +if [ ${#hpf_rows[@]} -gt 0 ]; then + IFS='|' read -r _ _ hpf_ctrl _ <<< "${hpf_rows[0]}" + [ -n "$hpf_ctrl" ] && func_webrtc_set_switch "$sofcard" "$hpf_ctrl" on +fi +mapfile -t agc_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "agc") +if [ ${#agc_rows[@]} -gt 0 ]; then + IFS='|' read -r _ _ agc_ctrl _ <<< "${agc_rows[0]}" + [ -n "$agc_ctrl" ] && func_webrtc_set_switch "$sofcard" "$agc_ctrl" off +fi + +work_dir="$LOG_ROOT/webrtc-${ns_profile}" +mkdir -p "$work_dir" +stim_wav="${work_dir}/stim_${ns_profile}.wav" +sof-webrtc-tool.py generate --profile "$ns_profile" --rate "$WEBRTC_CAP_RATE" \ + --channels "$WEBRTC_CAP_CH" --format "$WEBRTC_CAP_FMT" --output "$stim_wav" + +for iter in $(seq 1 "$loop_cnt"); do + dlogi "===== check-webrtc-ns ($ns_profile) iteration $iter/$loop_cnt (mode=$io_mode) =====" + cap_wav="${work_dir}/cap_${ns_profile}_${iter}.wav" + func_webrtc_capture_stimulus "$io_mode" "$stim_wav" "$cap_wav" 6 "$tplg" "$usb_pcm" "$host_cmd" + + sof-webrtc-tool.py analyze --profile "$ns_profile" --captured "$cap_wav" || + die "WebRTC $ns_profile noise suppression check failed" +done + +sof-kernel-log-check.sh "$KERNEL_CHECKPOINT" diff --git a/test-case/check-webrtc-vad.sh b/test-case/check-webrtc-vad.sh new file mode 100755 index 00000000..605ec360 --- /dev/null +++ b/test-case/check-webrtc-vad.sh @@ -0,0 +1,84 @@ +#!/bin/bash + +set -e + +## +## Case Name: check-webrtc-vad +## Preconditions: +## Topology contains a webrtc-vad widget +## Description: +## Verify WebRTC VAD audio transparency across silence/speech segments and +## exercise NOTIFIER_ID_VAD emission across supported PCM formats without +## userspace syscall or MMU faults. +## + +# shellcheck source=case-lib/lib.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/lib.sh +# shellcheck source=case-lib/webrtc.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/webrtc.sh + +OPT_NAME['t']='tplg' OPT_DESC['t']="tplg file, default value is env TPLG" +OPT_HAS_ARG['t']=1 OPT_VAL['t']="$TPLG" +OPT_NAME['m']='io-mode' OPT_DESC['m']='Audio injection mode: ssp | usb | host' +OPT_HAS_ARG['m']=1 OPT_VAL['m']='ssp' +OPT_NAME['U']='usb-pcm' OPT_DESC['U']='USB ALSA PCM (for -m usb)' +OPT_HAS_ARG['U']=1 OPT_VAL['U']='' +OPT_NAME['H']='host-cmd' OPT_DESC['H']='Host play command (for -m host)' +OPT_HAS_ARG['H']=1 OPT_VAL['H']='' +OPT_NAME['l']='loop' OPT_DESC['l']='loop count' +OPT_HAS_ARG['l']=1 OPT_VAL['l']=1 +OPT_NAME['s']='sof-logger' OPT_DESC['s']="Open sof-logger trace stored at $LOG_ROOT" +OPT_HAS_ARG['s']=0 OPT_VAL['s']=1 + +func_opt_parse_option "$@" + +tplg=${OPT_VAL['t']} +io_mode=${OPT_VAL['m']} +usb_pcm=${OPT_VAL['U']} +host_cmd=${OPT_VAL['H']} +loop_cnt=${OPT_VAL['l']} + +start_test +func_webrtc_register_cleanup +logger_disabled || func_lib_start_log_collect + +func_webrtc_select_capture_pipeline "$tplg" "type:capture" +sofcard="${SOFCARD:-0}" + +mapfile -t vad_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "vad") +[ ${#vad_rows[@]} -gt 0 ] || skip_test "No webrtc-vad widget in $TPLG_FILES" + +# Bypass optional inline HPF/AGC switches to check clean VAD pass-through +for kind in hpf agc; do + mapfile -t k_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "$kind") + if [ ${#k_rows[@]} -gt 0 ]; then + IFS='|' read -r _ _ ctrl _ <<< "${k_rows[0]}" + [ -n "$ctrl" ] && func_webrtc_set_switch "$sofcard" "$ctrl" off + fi +done + +fmts=$(func_pipeline_parse_value 0 fmts) +[ -n "$fmts" ] || fmts="$WEBRTC_CAP_FMT" + +work_dir="$LOG_ROOT/webrtc-vad" +mkdir -p "$work_dir" + +for iter in $(seq 1 "$loop_cnt"); do + for fmt in $fmts; do + [ "$fmt" = "S24_LE" ] && continue + WEBRTC_CAP_FMT="$fmt" + stim_wav="${work_dir}/stim_vad_${fmt}.wav" + cap_wav="${work_dir}/cap_vad_${fmt}_${iter}.wav" + + dlogi "===== check-webrtc-vad iter=$iter fmt=$fmt rate=$WEBRTC_CAP_RATE (mode=$io_mode) =====" + sof-webrtc-tool.py generate --profile vad --rate "$WEBRTC_CAP_RATE" \ + --channels "$WEBRTC_CAP_CH" --format "$fmt" --output "$stim_wav" + + func_webrtc_capture_stimulus "$io_mode" "$stim_wav" "$cap_wav" 6 "$tplg" "$usb_pcm" "$host_cmd" + + sof-webrtc-tool.py analyze --profile vad --captured "$cap_wav" || + die "WebRTC VAD pass-through check failed ($fmt)" + done +done + +sof-kernel-log-check.sh "$KERNEL_CHECKPOINT" diff --git a/test-case/verify-webrtc-controls.sh b/test-case/verify-webrtc-controls.sh new file mode 100755 index 00000000..2080d096 --- /dev/null +++ b/test-case/verify-webrtc-controls.sh @@ -0,0 +1,68 @@ +#!/bin/bash + +set -e + +## +## Case Name: verify-webrtc-controls +## Preconditions: +## SOF topology contains one or more WebRTC effect widgets +## Description: +## Validate WebRTC widget presence, Switch kcontrol read/write toggling +## during active PCM streaming, and clean LLEXT load without kernel errors. +## + +# shellcheck source=case-lib/lib.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/lib.sh +# shellcheck source=case-lib/webrtc.sh +source "$(dirname "${BASH_SOURCE[0]}")"/../case-lib/webrtc.sh + +OPT_NAME['t']='tplg' OPT_DESC['t']="tplg file, default value is env TPLG" +OPT_HAS_ARG['t']=1 OPT_VAL['t']="$TPLG" +OPT_NAME['l']='loop' OPT_DESC['l']='toggle loop count' +OPT_HAS_ARG['l']=1 OPT_VAL['l']=2 +OPT_NAME['s']='sof-logger' OPT_DESC['s']="Open sof-logger trace stored at $LOG_ROOT" +OPT_HAS_ARG['s']=0 OPT_VAL['s']=1 + +func_opt_parse_option "$@" + +tplg=${OPT_VAL['t']} +loop_cnt=${OPT_VAL['l']} + +start_test +func_webrtc_register_cleanup +logger_disabled || func_lib_start_log_collect + +func_webrtc_select_capture_pipeline "$tplg" "type:capture" +sofcard="${SOFCARD:-0}" + +mapfile -t ctrl_rows < <(func_webrtc_discover_controls "$TPLG_FILES" "all") +[ ${#ctrl_rows[@]} -gt 0 ] || skip_test "No WebRTC widgets found in topology $TPLG_FILES" + +declare -a switch_ctrls=() +for row in "${ctrl_rows[@]}"; do + IFS='|' read -r mod_type wname kname ktype <<< "$row" + dlogi "Discovered WebRTC widget: type=${mod_type} widget=${wname} ctrl='${kname}' (${ktype})" + if [ -n "$kname" ] && { [ "$ktype" = "MIXER" ] || [ -z "$ktype" ]; }; then + switch_ctrls+=("$kname") + fi +done + +# Start background capture so DSP loads WebRTC pipeline/LLEXT while toggling +dlogc "arecord -D $WEBRTC_CAP_DEV -f $WEBRTC_CAP_FMT -r $WEBRTC_CAP_RATE -c $WEBRTC_CAP_CH -d $((loop_cnt * 2 + 2)) /dev/null" +arecord -D "$WEBRTC_CAP_DEV" -f "$WEBRTC_CAP_FMT" -r "$WEBRTC_CAP_RATE" \ + -c "$WEBRTC_CAP_CH" -d "$((loop_cnt * 2 + 2))" /dev/null & +cap_pid=$! +sleep 1 + +for iter in $(seq 1 "$loop_cnt"); do + dlogi "===== Control toggle iteration $iter/$loop_cnt =====" + for ctrl in "${switch_ctrls[@]}"; do + func_webrtc_set_switch "$sofcard" "$ctrl" off + func_webrtc_set_switch "$sofcard" "$ctrl" on + func_webrtc_set_switch "$sofcard" "$ctrl" off + done + sleep 1 +done + +wait "$cap_pid" || die "Capture stream failed during WebRTC control verification" +sof-kernel-log-check.sh "$KERNEL_CHECKPOINT" diff --git a/tools/sof-webrtc-tool.py b/tools/sof-webrtc-tool.py new file mode 100755 index 00000000..f2af1eef --- /dev/null +++ b/tools/sof-webrtc-tool.py @@ -0,0 +1,666 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: BSD-3-Clause + +"""Stimulus generator and DSP verification analyzer for WebRTC sof-test cases.""" + +import argparse +import array +import math +import os +import random +import struct +import sys +import wave + +try: + import numpy as np +except ImportError: + np = None + +SYNC_PRE_SEC = 0.15 +SYNC_CHIRP_SEC = 0.30 +SYNC_POST_SEC = 0.25 +SYNC_HEADER_SEC = SYNC_PRE_SEC + SYNC_CHIRP_SEC + SYNC_POST_SEC +CHIRP_F0_HZ = 450.0 +CHIRP_F1_HZ = 2800.0 +PRNG_SEED = 42 + + +def db_to_amp(db_val): + """Convert dBFS value to linear peak amplitude in [0, 1].""" + return 10.0 ** (db_val / 20.0) + + +def rms_db(samples): + """Compute RMS level in dBFS for normalized floats in [-1.0, 1.0].""" + if len(samples) == 0: + return -120.0 + if np is not None: + arr = np.asarray(samples, dtype=np.float64) + mean_sq = float(np.mean(arr * arr)) + else: + mean_sq = sum(x * x for x in samples) / len(samples) + if mean_sq <= 1e-12: + return -120.0 + return 10.0 * math.log10(mean_sq) + + +def peak_db(samples): + """Compute peak magnitude in dBFS for normalized floats in [-1.0, 1.0].""" + if len(samples) == 0: + return -120.0 + if np is not None: + peak = float(np.max(np.abs(samples))) + else: + peak = max(abs(x) for x in samples) + if peak <= 1e-9: + return -120.0 + return 20.0 * math.log10(peak) + + +def _goertzel_mag_sq_numpy(samples, rate, freq_hz): + """Compute single-bin Goertzel squared magnitude using numpy.""" + arr = np.asarray(samples, dtype=np.float64) + ang = 2.0 * math.pi * freq_hz / rate + idx = np.arange(len(arr), dtype=np.float64) + c_sum = float(np.dot(arr, np.cos(ang * idx))) + s_sum = float(np.dot(arr, np.sin(ang * idx))) + return 2.0 * (c_sum * c_sum + s_sum * s_sum) / (len(arr) * len(arr)) + + +def _goertzel_mag_sq_py(samples, rate, freq_hz): + """Compute single-bin Goertzel squared magnitude using pure Python.""" + coeff = 2.0 * math.cos(2.0 * math.pi * freq_hz / rate) + q1 = 0.0 + q2 = 0.0 + for x in samples: + q0 = coeff * q1 - q2 + x + q2 = q1 + q1 = q0 + power = q1 * q1 + q2 * q2 - coeff * q1 * q2 + return 2.0 * max(power, 0.0) / (len(samples) * len(samples)) + + +def goertzel_power_db(samples, rate, freq_hz): + """Measure single-frequency RMS tone level in dBFS via Goertzel filter.""" + if len(samples) == 0: + return -120.0 + if np is not None: + mag_sq = _goertzel_mag_sq_numpy(samples, rate, freq_hz) + else: + mag_sq = _goertzel_mag_sq_py(samples, rate, freq_hz) + if mag_sq <= 1e-12: + return -120.0 + return 10.0 * math.log10(mag_sq) + + +def make_chirp(rate): + """Generate deterministic log sync chirp normalized to [-1.0, 1.0].""" + n_chirp = int(round(SYNC_CHIRP_SEC * rate)) + amp = db_to_amp(-8.0) + k = math.log(CHIRP_F1_HZ / CHIRP_F0_HZ) / SYNC_CHIRP_SEC + out = [0.0] * n_chirp + fade = max(1, int(0.01 * rate)) + for i in range(n_chirp): + t = i / rate + phase = 2.0 * math.pi * CHIRP_F0_HZ * (math.exp(k * t) - 1.0) / k + env = 1.0 + if i < fade: + env = i / fade + elif i >= n_chirp - fade: + env = (n_chirp - 1 - i) / fade + out[i] = amp * env * math.sin(phase) + return out + + +def make_sine(rate, dur_sec, freq_hz, level_dbfs): + """Generate sine wave normalized to [-1.0, 1.0].""" + n = int(round(dur_sec * rate)) + amp = db_to_amp(level_dbfs) + omega = 2.0 * math.pi * freq_hz / rate + return [amp * math.sin(omega * i) for i in range(n)] + + +def make_multitone(rate, dur_sec, freqs_hz, level_dbfs): + """Generate equal-amplitude harmonic-free speech-proxy multitone.""" + n = int(round(dur_sec * rate)) + per_tone = db_to_amp(level_dbfs) / math.sqrt(len(freqs_hz)) + omegas = [2.0 * math.pi * f / rate for f in freqs_hz] + phases = [0.7 * idx for idx in range(len(freqs_hz))] + return [ + per_tone * sum(math.sin(w * i + ph) for w, ph in zip(omegas, phases)) + for i in range(n) + ] + + +def make_noise(rate, dur_sec, rms_dbfs, rng): + """Generate deterministic stationary broadband noise at target RMS dBFS.""" + n = int(round(dur_sec * rate)) + raw = [rng.gauss(0.0, 1.0) for _ in range(n)] + cur_rms = math.sqrt(sum(x * x for x in raw) / max(n, 1)) + scale = db_to_amp(rms_dbfs) / max(cur_rms, 1e-9) + return [max(-0.99, min(0.99, x * scale)) for x in raw] + + +def _encode_pcm_frames(mono_samples, channels, sampwidth): + """Pack normalized [-1, 1] mono floats into interleaved PCM bytes.""" + max_pos = 2147483647 if sampwidth == 4 else 32767 + min_neg = -2147483648 if sampwidth == 4 else -32768 + + if np is not None: + dtype = np.int32 if sampwidth == 4 else np.int16 + arr = np.clip(np.asarray(mono_samples, dtype=np.float64), -1.0, 1.0) + ints = np.clip(np.rint(arr * max_pos), min_neg, max_pos).astype(dtype) + if channels > 1: + ints = np.repeat(ints[:, None], channels, axis=1) + return ints.tobytes() + + packed = bytearray() + pack_fmt = "= delay_samples else 0.0 + for i in range(len(ref_full)) + ] + + near_start = int(round((SYNC_HEADER_SEC + 2.5) * rate)) + for i, val in enumerate(make_sine(rate, 2.5, 997.0, -14.0)): + idx = near_start + i + if idx < len(mic_full): + mic_full[idx] = max(-0.999, min(0.999, mic_full[idx] + val)) + + # Include un-delayed sync chirp in mic too for SSP loopback alignment. + chirp_start = int(round(SYNC_PRE_SEC * rate)) + for i, val in enumerate(make_chirp(rate)): + idx = chirp_start + i + if idx < len(mic_full): + mic_full[idx] = max(-0.999, min(0.999, val)) + + write_wav(args.out_mic, mic_full, rate, args.channels, args.format) + write_wav(args.out_ref, ref_full, rate, args.channels, args.format) + + +def generate_profile(args): + """Generate labeled stimulus WAV(s) for requested WebRTC profile.""" + profile = args.profile + rate = args.rate + rng = random.Random(PRNG_SEED) + header = build_sync_header(rate) + + if profile == "hpf": + payload = mix_signals( + make_sine(rate, args.duration, 40.0, -8.0), + make_sine(rate, args.duration, 1000.0, -14.0), + ) + write_wav(args.output, header + payload, rate, args.channels, args.format) + return + + if profile in ("ns", "ns2"): + noise_seg = make_noise(rate, 2.5, -20.0, rng) + speech_seg = mix_signals( + make_multitone(rate, 2.0, (350.0, 1000.0, 2200.0), -10.0), + make_noise(rate, 2.0, -24.0, rng), + ) + write_wav( + args.output, + header + noise_seg + speech_seg, + rate, + args.channels, + args.format, + ) + return + + if profile == "agc": + payload = make_sine(rate, 2.0, 1000.0, -34.0) + make_sine(rate, 2.0, 1000.0, -1.0) + write_wav(args.output, header + payload, rate, args.channels, args.format) + return + + if profile == "vad": + sil1 = [0.0] * int(round(1.2 * rate)) + sp1 = make_multitone(rate, 1.2, (450.0, 1000.0, 1900.0), -12.0) + sil2 = [0.0] * int(round(1.0 * rate)) + sp2 = mix_signals( + make_multitone(rate, 1.0, (450.0, 1000.0), -14.0), + make_noise(rate, 1.0, -28.0, rng), + ) + write_wav( + args.output, + header + sil1 + sp1 + sil2 + sp2, + rate, + args.channels, + args.format, + ) + return + + if profile == "aec": + _generate_aec_pair(args, rng, header) + return + + raise ValueError(f"Unsupported profile {profile}") + + +def _refine_chirp_window(sig_slice, pat, lo_idx, hi_idx, use_numpy): + """Exact sample-level normalized cross-correlation inside [lo_idx, hi_idx].""" + pat_e = sum(x * x for x in pat) + best_pos = lo_idx + best_score = -1.0 + for pos in range(lo_idx, hi_idx + 1): + seg = sig_slice[pos : pos + len(pat)] + if use_numpy: + dot = float(np.dot(seg, pat)) + seg_e = float(np.dot(seg, seg)) + else: + dot = sum(a * b for a, b in zip(seg, pat)) + seg_e = sum(a * a for a in seg) + score = dot / math.sqrt(max(seg_e * pat_e, 1e-12)) + if score > best_score: + best_score = score + best_pos = pos + return best_pos, best_score + + +def _find_chirp_numpy(samples, chirp, search_end): + """Coarse-to-fine sync chirp search backed by numpy.""" + sig = np.asarray(samples[:search_end], dtype=np.float64) + pat = np.asarray(chirp, dtype=np.float64) + step = 4 + sig_d = sig[::step] + pat_d = pat[::step] + corr = np.correlate(sig_d, pat_d, mode="valid") + sig_sq = np.convolve(sig_d * sig_d, np.ones(len(pat_d)), mode="valid") + denom = np.sqrt(np.maximum(sig_sq * float(np.dot(pat_d, pat_d)), 1e-12)) + coarse_idx = int(np.argmax(corr / denom)) * step + return _refine_chirp_window( + sig, pat, max(0, coarse_idx - 32), min(search_end - len(pat), coarse_idx + 32), True + ) + + +def _find_chirp_py(samples, chirp, search_end): + """Coarse-to-fine sync chirp search in pure Python.""" + dec = 8 + pat_d = chirp[::dec] + pat_e = sum(x * x for x in pat_d) + sig_d = samples[:search_end:dec] + best_coarse = 0 + best_val = -1.0 + for pos in range(0, max(1, len(sig_d) - len(pat_d)), 2): + seg = sig_d[pos : pos + len(pat_d)] + dot = sum(a * b for a, b in zip(seg, pat_d)) + seg_e = sum(a * a for a in seg) + score = dot / math.sqrt(max(seg_e * pat_e, 1e-12)) + if score > best_val: + best_val = score + best_coarse = pos * dec + return _refine_chirp_window( + samples, + chirp, + max(0, best_coarse - 32), + min(search_end - len(chirp), best_coarse + 32), + False, + ) + + +def find_chirp_offset(samples, rate, max_search_sec=5.0): + """Locate sync chirp start sample using normalized cross-correlation.""" + chirp = make_chirp(rate) + search_end = min(len(samples), int(round(max_search_sec * rate))) + if search_end <= len(chirp) + 16: + raise RuntimeError( + f"Captured audio too short ({len(samples)} samples) to locate sync chirp" + ) + if np is not None: + return _find_chirp_numpy(samples, chirp, search_end) + return _find_chirp_py(samples, chirp, search_end) + + +def slice_after_header(samples, rate, start_sec, dur_sec): + """Locate sync chirp and slice payload window relative to payload start.""" + chirp_idx, score = find_chirp_offset(samples, rate) + if score < 0.25: + raise RuntimeError( + f"Sync chirp correlation too weak ({score:.3f} < 0.25); check audio path" + ) + payload_start = chirp_idx + int(round((SYNC_CHIRP_SEC + SYNC_POST_SEC) * rate)) + s0 = payload_start + int(round(start_sec * rate)) + s1 = payload_start + int(round((start_sec + dur_sec) * rate)) + if s1 > len(samples): + raise RuntimeError( + f"Capture truncated: need sample {s1} ({s1 / rate:.2f}s), got {len(samples)}" + ) + return samples[s0:s1], score + + +def check_no_dropouts(samples, rate, label): + """Verify active segment contains no unexpected 20ms digital-zero dropouts.""" + win = max(1, int(0.02 * rate)) + overall = rms_db(samples) + if overall < -60.0: + return + silent_frames = 0 + total_frames = len(samples) // win + for idx in range(total_frames): + sub = samples[idx * win : (idx + 1) * win] + if rms_db(sub) < overall - 30.0: + silent_frames += 1 + if silent_frames > 1: + raise RuntimeError( + f"Detected {silent_frames}/{total_frames} dropout frames in '{label}'" + ) + + +def analyze_hpf(cap, rate, base, args): + """Verify >= 12 dB attenuation at 40 Hz and <= 2.5 dB passband loss at 1 kHz.""" + seg, score = slice_after_header(cap, rate, 0.3, args.duration - 0.5) + check_no_dropouts(seg, rate, "hpf") + p40 = goertzel_power_db(seg, rate, 40.0) + p1k = goertzel_power_db(seg, rate, 1000.0) + + if base is not None: + bseg, bscore = slice_after_header(base, rate, 0.3, args.duration - 0.5) + b40 = goertzel_power_db(bseg, rate, 40.0) + b1k = goertzel_power_db(bseg, rate, 1000.0) + atten_40 = b40 - p40 + pass_delta = p1k - b1k + print( + f"HPF sync={score:.3f}/{bscore:.3f} p40={p40:.2f}dB (off {b40:.2f}dB) " + f"atten_40Hz={atten_40:.2f}dB p1k_delta={pass_delta:+.2f}dB" + ) + if atten_40 < args.min_hpf_atten_db: + raise RuntimeError( + f"40 Hz attenuation {atten_40:.2f} dB < {args.min_hpf_atten_db:.1f} dB" + ) + if abs(pass_delta) > 2.5: + raise RuntimeError(f"1 kHz passband drift {pass_delta:+.2f} dB > 2.5 dB") + else: + rel_rej = p1k - p40 + print( + f"HPF sync={score:.3f} p40={p40:.2f}dB p1k={p1k:.2f}dB (1k-40={rel_rej:.2f}dB)" + ) + if rel_rej < args.min_hpf_atten_db: + raise RuntimeError( + f"HPF relative rejection (1kHz-40Hz) {rel_rej:.2f} dB < {args.min_hpf_atten_db:.1f} dB" + ) + + +def analyze_ns(cap, rate, args): + """Verify noise attenuation after convergence while preserving speech tones.""" + early_noise, score = slice_after_header(cap, rate, 0.05, 0.25) + steady_noise, _ = slice_after_header(cap, rate, 1.4, 1.0) + speech_seg, _ = slice_after_header(cap, rate, 2.8, 1.4) + check_no_dropouts(speech_seg, rate, args.profile) + + early_db = rms_db(early_noise) + noise_db = rms_db(steady_noise) + tone_1k_db = goertzel_power_db(speech_seg, rate, 1000.0) + snr_gain_db = tone_1k_db - noise_db + print( + f"{args.profile.upper()} sync={score:.3f} early_noise={early_db:.2f}dB " + f"steady_noise={noise_db:.2f}dB tone_1k={tone_1k_db:.2f}dB " + f"SNR={snr_gain_db:.2f}dB" + ) + if snr_gain_db < args.min_snr_gain_db: + raise RuntimeError( + f"NS speech-to-noise ratio {snr_gain_db:.2f} dB < {args.min_snr_gain_db:.1f} dB" + ) + if tone_1k_db < -40.0: + raise RuntimeError(f"NS speech tone collapsed ({tone_1k_db:.2f} dB)") + + +def _agc_segment_levels(samples, rate): + """Extract sync score, quiet RMS, loud RMS, and loud peak dBFS for AGC.""" + quiet_seg, score = slice_after_header(samples, rate, 0.5, 1.2) + loud_seg, _ = slice_after_header(samples, rate, 2.5, 1.2) + check_no_dropouts(quiet_seg, rate, "agc_quiet") + check_no_dropouts(loud_seg, rate, "agc_loud") + return score, rms_db(quiet_seg), rms_db(loud_seg), peak_db(loud_seg) + + +def analyze_agc(cap, rate, base, args): + """Verify AGC quiet-signal boost and loud-signal peak limiting.""" + score, q_on_db, l_on_db, l_peak_db = _agc_segment_levels(cap, rate) + dyn_on = l_on_db - q_on_db + + if base is not None: + bscore, q_off_db, l_off_db, _ = _agc_segment_levels(base, rate) + comp_db = (l_off_db - q_off_db) - dyn_on + print( + f"AGC sync={score:.3f}/{bscore:.3f} quiet={q_on_db:.2f}dB(off {q_off_db:.2f}dB) " + f"loud={l_on_db:.2f}dB(off {l_off_db:.2f}dB) peak={l_peak_db:.2f}dBFS " + f"compression={comp_db:.2f}dB" + ) + if comp_db < args.min_agc_comp_db: + raise RuntimeError( + f"AGC dynamic compression {comp_db:.2f} dB < {args.min_agc_comp_db:.1f} dB" + ) + else: + print( + f"AGC sync={score:.3f} quiet={q_on_db:.2f}dB loud={l_on_db:.2f}dB " + f"peak={l_peak_db:.2f}dBFS span={dyn_on:.2f}dB" + ) + if dyn_on > 26.0: + raise RuntimeError(f"AGC dynamic span {dyn_on:.2f} dB too wide (>26 dB)") + + if l_peak_db > -0.05: + raise RuntimeError(f"AGC loud segment clipped (peak {l_peak_db:.2f} dBFS)") + + +def analyze_vad(cap, rate): + """Verify VAD transparency between silence and speech bursts.""" + sil1, score = slice_after_header(cap, rate, 0.15, 0.9) + sp1, _ = slice_after_header(cap, rate, 1.35, 0.9) + sil2, _ = slice_after_header(cap, rate, 2.55, 0.7) + sp2, _ = slice_after_header(cap, rate, 3.55, 0.7) + check_no_dropouts(sp1, rate, "vad_speech1") + check_no_dropouts(sp2, rate, "vad_speech2") + + sil_max = max(rms_db(sil1), rms_db(sil2)) + sp_min = min(rms_db(sp1), rms_db(sp2)) + contrast = sp_min - sil_max + print( + f"VAD sync={score:.3f} silence_max={sil_max:.2f}dB " + f"speech_min={sp_min:.2f}dB contrast={contrast:.2f}dB" + ) + if contrast < 20.0: + raise RuntimeError(f"VAD silence/speech contrast {contrast:.2f} dB < 20.0 dB") + + +def _aec_segment_levels(samples, rate): + """Extract sync score, single-talk far-end RMS, and double-talk 997 Hz power.""" + far_seg, score = slice_after_header(samples, rate, 0.8, 1.5) + dt_seg, _ = slice_after_header(samples, rate, 2.8, 2.0) + check_no_dropouts(dt_seg, rate, "aec_double_talk") + return score, rms_db(far_seg), goertzel_power_db(dt_seg, rate, 997.0) + + +def analyze_aec(cap, rate, base, args): + """Verify single-talk ERLE and double-talk near-end preservation.""" + score, far_on_db, near_on_997 = _aec_segment_levels(cap, rate) + + if base is not None: + bscore, far_off_db, near_off_997 = _aec_segment_levels(base, rate) + erle_db = far_off_db - far_on_db + near_delta = near_on_997 - near_off_997 + print( + f"AEC sync={score:.3f}/{bscore:.3f} far_on={far_on_db:.2f}dB " + f"(off {far_off_db:.2f}dB) ERLE={erle_db:.2f}dB " + f"near_997_delta={near_delta:+.2f}dB" + ) + if erle_db < args.min_erle_db: + raise RuntimeError(f"AEC ERLE {erle_db:.2f} dB < {args.min_erle_db:.1f} dB") + if not args.single_talk_only and near_delta < -6.0: + raise RuntimeError( + f"AEC attenuated near-end double-talk by {-near_delta:.2f} dB (> 6.0 dB)" + ) + else: + if args.single_talk_only: + print( + f"AEC sync={score:.3f} far_on={far_on_db:.2f}dB (single-talk baseline missing)" + ) + return + ratio = near_on_997 - far_on_db + print( + f"AEC sync={score:.3f} far_on={far_on_db:.2f}dB " + f"near_997={near_on_997:.2f}dB near_to_echo={ratio:.2f}dB" + ) + if ratio < args.min_erle_db: + raise RuntimeError( + f"AEC near-to-residual-echo ratio {ratio:.2f} dB < {args.min_erle_db:.1f} dB" + ) + + +def analyze_profile(args): + """Run profile-specific verification on captured WAV.""" + cap, rate, _, _ = read_wav(args.captured) + base = None + if args.baseline: + base, b_rate, _, _ = read_wav(args.baseline) + if b_rate != rate: + raise RuntimeError(f"Sample rate mismatch: captured={rate}, baseline={b_rate}") + + if args.profile == "hpf": + analyze_hpf(cap, rate, base, args) + elif args.profile in ("ns", "ns2"): + analyze_ns(cap, rate, args) + elif args.profile == "agc": + analyze_agc(cap, rate, base, args) + elif args.profile == "vad": + analyze_vad(cap, rate) + elif args.profile == "aec": + analyze_aec(cap, rate, base, args) + else: + raise ValueError(f"Unsupported profile {args.profile}") + + +def parse_args(): + """Parse CLI subcommands.""" + parser = argparse.ArgumentParser(description="WebRTC sof-test stimulus & analysis tool") + sub = parser.add_subparsers(dest="cmd", required=True) + + gen = sub.add_parser("generate", help="Generate deterministic WebRTC test WAV(s)") + gen.add_argument("--profile", required=True, choices=("hpf", "ns", "ns2", "agc", "vad", "aec")) + gen.add_argument("--rate", type=int, default=16000) + gen.add_argument("--channels", type=int, default=2) + gen.add_argument("--format", default="S16_LE", choices=("S16_LE", "S32_LE")) + gen.add_argument("--duration", type=float, default=2.0) + gen.add_argument("--echo-delay-ms", type=float, default=20.0) + gen.add_argument("--echo-gain-db", type=float, default=-6.0) + gen.add_argument("--output", help="Output WAV path (for non-aec profiles)") + gen.add_argument("--out-mic", help="Output mic WAV path (for aec profile)") + gen.add_argument("--out-ref", help="Output echo-ref WAV path (for aec profile)") + + ana = sub.add_parser("analyze", help="Analyze captured WebRTC WAV against expectations") + ana.add_argument("--profile", required=True, choices=("hpf", "ns", "ns2", "agc", "vad", "aec")) + ana.add_argument("--captured", required=True, help="Captured WAV with feature active") + ana.add_argument("--baseline", help="Optional baseline WAV captured with switch OFF") + ana.add_argument("--duration", type=float, default=2.0) + ana.add_argument("--min-hpf-atten-db", type=float, default=12.0) + ana.add_argument("--min-snr-gain-db", type=float, default=8.0) + ana.add_argument("--min-agc-comp-db", type=float, default=6.0) + ana.add_argument("--min-erle-db", type=float, default=10.0) + ana.add_argument( + "--single-talk-only", + action="store_true", + help="For AEC loopback without external near-end injection, skip double-talk near-end check", + ) + + return parser.parse_args() + + +def main(): + """Entry point.""" + args = parse_args() + if args.cmd == "generate": + if args.profile == "aec": + if not args.out_mic or not args.out_ref: + raise SystemExit("--out-mic and --out-ref are required for aec profile") + elif not args.output: + raise SystemExit("--output is required for non-aec profiles") + generate_profile(args) + return 0 + + analyze_profile(args) + return 0 + + +if __name__ == "__main__": + try: + sys.exit(main()) + except RuntimeError as exc: + print(f"FAIL: {exc}", file=sys.stderr) + sys.exit(1) diff --git a/tools/topo_webrtc_kcontrols.py b/tools/topo_webrtc_kcontrols.py new file mode 100755 index 00000000..69c970de --- /dev/null +++ b/tools/topo_webrtc_kcontrols.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: BSD-3-Clause + +"""Inspect compiled SOF .tplg files for WebRTC effect widgets and controls.""" + +import argparse +import os +import sys + +from tplgtool2 import DapmType, TplgBinaryFormat, TplgType + +WEBRTC_TYPES = ("hpf", "vad", "ns2", "ns", "agc", "aec") + + +def parse_args(): + """Parse CLI options.""" + parser = argparse.ArgumentParser( + description="List WebRTC widgets and mixer kcontrols from .tplg binary." + ) + parser.add_argument( + "tplg", + help="Path(s) to compiled topology file(s), separated by comma or colon", + ) + parser.add_argument( + "--type", + choices=("all",) + WEBRTC_TYPES, + default="all", + help="Filter to a specific WebRTC module type (default: all)", + ) + return parser.parse_args() + + +def detect_webrtc_type(widget_name): + """Return canonical WebRTC module type string for a widget name, or None.""" + if not widget_name.startswith("webrtc-"): + return None + for mod_type in WEBRTC_TYPES: + prefix = f"webrtc-{mod_type}" + if widget_name == prefix or widget_name.startswith(prefix + "."): + return mod_type + return None + + +def iter_webrtc_controls(tplg_paths, target_type="all"): + """Yield (mod_type, widget_name, kctrl_name, kctrl_type) tuples.""" + tplg_format = TplgBinaryFormat() + seen = set() + + for path in tplg_paths: + if not path: + continue + parsed = tplg_format.parse_file(path) + for item in parsed: + if item.header.type != TplgType.DAPM_WIDGET.name: + continue + for block in item.blocks: + if block.widget.id != DapmType.EFFECT.name: + continue + mod_type = detect_webrtc_type(block.widget.name) + if not mod_type or target_type not in ("all", mod_type): + continue + kcontrols = getattr(block, "kcontrols", []) or [] + if not kcontrols: + entry = (mod_type, block.widget.name, "", "") + if entry not in seen: + seen.add(entry) + yield entry + continue + for kc in kcontrols: + kc_type = str(kc.hdr.type) + entry = (mod_type, block.widget.name, kc.hdr.name, kc_type) + if entry not in seen: + seen.add(entry) + yield entry + + +def main(): + """Entry point.""" + args = parse_args() + raw_paths = args.tplg.replace(":", ",").split(",") + tplg_paths = [os.path.abspath(p.strip()) for p in raw_paths if p.strip()] + + for mod_type, wname, kname, ktype in iter_webrtc_controls(tplg_paths, args.type): + print(f"{mod_type}|{wname}|{kname}|{ktype}") + return 0 + + +if __name__ == "__main__": + sys.exit(main())