enricobuehler
bf913c5706
ci / bun-nix (pull_request) Successful in 36s
ci / web (pull_request) Successful in 1m22s
apple / swift (pull_request) Successful in 1m39s
apple / screenshots (pull_request) Skipped
ci / docs-site (pull_request) Successful in 1m40s
ci / rust-arm64 (pull_request) Successful in 2m53s
ci / rust (pull_request) Failing after 9m43s
Field report, macOS client, host-independent: start a stream with AirPods in, take them
out — nothing on the speakers; put them back in — nothing in the AirPods either. Only
restarting the whole stream brought audio back.
An AVAudioEngine does not follow the audio hardware. When the output device changes under
a running engine, its IO unit sees the new hardware, THE ENGINE STOPS ITSELF, and it posts
AVAudioEngineConfigurationChange. It stays stopped until somebody starts it again, and
nothing here ever did — no error, no log line, just a session rendering silence from that
moment on. Putting the AirPods back in is a second stop, not a recovery, which is exactly
why that half of the report looked so strange.
Measured on the client's own playback topology (source node -> main mixer, 48 kHz stereo)
by moving the default output device programmatically: render callbacks go from ~94/s to
zero the instant the device changes, and both restarting the same engine and building a
fresh one resume them.
The fix watches the hardware and rebuilds the topology the session was started with, on
whatever device is there now. Three triggers, because no single one covers the ground:
- the engine's own configuration-change notification, every platform — the direct
signal, but it can only be posted BY an engine, so it cannot report a rebuild that
failed to start;
- a CoreAudio HAL default-output-device listener on macOS — independent of any engine
and of the engine's topology. This is what makes the recovery work for the
voice-processing engine, which is the DEFAULT macOS configuration (mic and echo
cancellation both default on) and whose notification behaviour could not be verified:
no Mac in the fleet can initialize VPIO at all;
- route-change and media-services-reset on iOS/tvOS, where the session rather than the
device is what moves. The route observer is now installed for mic-off (.playback)
sessions and on tvOS too — it used to be iOS-and-mic-only, for the earpiece steer,
but every platform has engines a route change can stop.
They collapse into one debounced rebuild (one switch produces a burst), with a floor
between rebuilds so a device that renegotiates in a loop cannot spin the session, and a
short retry ladder for a device caught mid-transition — a rebuild that fails leaves no
engine to post the next notification, so that path must not simply give up. The ring is
deliberately carried across: the drain thread keeps decoding through the switch, and the
ring's overflow policy has already dropped whatever went stale while the engine was down.
A rebuild is only ever done when it concerns us. A healthy engine that followed the change
on its own is left alone, and somebody changing the system default while this session is
pinned to a named speaker is none of our business — rebuilding for that would cost an
audible gap for nothing.
The trigger wiring is split into AudioDeviceWatcher for one reason: an end-to-end test of
the recovery needs a live session, which needs a host, and punktfunk-host does not build
on macOS — so the part where a silent failure costs the session ALL of its audio would
otherwise ship unverified. On its own the watcher is pointed at the real hardware from a
unit test: a real default-output-device move must reach the owner, our engine's
notification must get through, a foreign engine's must not. Neutralizing the wiring fails
both positive tests and neither negative one.
AudioDeviceSwitchTests drives the real SessionAudio through the out-and-back switch
against the loopback host; it skips wherever that fixture cannot run (which is every Mac,
today) and the open host's frame budget is raised so it outlives the switch.
68 lines
3.3 KiB
Bash
Executable File
68 lines
3.3 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# Loopback integration: real punktfunk/1 hosts (synthetic source — pure protocol, runs fine on
|
|
# macOS) on 127.0.0.1, then the Swift integration tests against them through the xcframework.
|
|
# Three hosts: an OPEN one (--allow-tofu; the anonymous stream round trip — bare punktfunk1-host
|
|
# now defaults to require-pairing), one armed with --require-pairing (the PIN ceremony + pairing
|
|
# gate — its random PIN is parsed out of its log), and a GUESS host whose one-shot arming window
|
|
# the wrong-PIN test deliberately burns (a pairing attempt — right or wrong — consumes the armed
|
|
# PIN, the SPAKE2 "one online guess", so the real ceremony needs a window of its own).
|
|
set -euo pipefail
|
|
cd "$(dirname "$0")/../.."
|
|
|
|
PORT="${PUNKTFUNK_LOOPBACK_PORT:-19778}"
|
|
PAIR_PORT="${PUNKTFUNK_PAIRING_PORT:-19779}"
|
|
GUESS_PORT="${PUNKTFUNK_GUESS_PORT:-19780}"
|
|
|
|
cargo build --release -p punktfunk-host
|
|
|
|
# Each host gets a throwaway config home: the pairing hosts persist a trust store
|
|
# (punktfunk1-paired.json, resolved from $HOME) and all mint an identity cert on first
|
|
# run — none of that belongs in the user's real ~/.config/punktfunk, and separate homes
|
|
# also keep the first runs from racing on the same cert.pem.
|
|
CFG="$(mktemp -d "${TMPDIR:-/tmp}/punktfunk-loopback.XXXXXX")"
|
|
PAIR_LOG="$CFG/pairing-host.log"
|
|
GUESS_LOG="$CFG/guess-host.log"
|
|
mkdir -p "$CFG/open" "$CFG/paired" "$CFG/guess"
|
|
trap 'kill "${HOST_PID:-}" "${PAIR_PID:-}" "${GUESS_PID:-}" 2>/dev/null || true' EXIT
|
|
# The open host also scripts a feedback burst (rumble + DualSense hidout) right after the
|
|
# handshake, so the Swift test can assert the host→client feedback planes end to end.
|
|
# The open host outlives the others on purpose: AudioDeviceSwitchTests connects to it and then
|
|
# spends tens of seconds moving the system's output device around, long after the 300 frames the
|
|
# round-trip test needs.
|
|
HOME="$CFG/open" XDG_CONFIG_HOME="$CFG/open/.config" PUNKTFUNK_TEST_FEEDBACK=1 \
|
|
target/release/punktfunk-host punktfunk1-host --port "$PORT" --source synthetic --frames 12000 \
|
|
--allow-tofu &
|
|
HOST_PID=$!
|
|
HOME="$CFG/paired" XDG_CONFIG_HOME="$CFG/paired/.config" \
|
|
target/release/punktfunk-host punktfunk1-host --port "$PAIR_PORT" --source synthetic --frames 300 \
|
|
--require-pairing >"$PAIR_LOG" 2>&1 &
|
|
PAIR_PID=$!
|
|
HOME="$CFG/guess" XDG_CONFIG_HOME="$CFG/guess/.config" \
|
|
target/release/punktfunk-host punktfunk1-host --port "$GUESS_PORT" --source synthetic --frames 300 \
|
|
--require-pairing >"$GUESS_LOG" 2>&1 &
|
|
GUESS_PID=$!
|
|
sleep 1
|
|
|
|
# Parse each pairing host's random arming PIN out of its startup log.
|
|
pin_from_log() {
|
|
local log="$1" pin=""
|
|
for _ in $(seq 50); do
|
|
pin="$(grep -oE 'pair: [0-9]+' "$log" | head -1 | cut -d' ' -f2 || true)"
|
|
[ -n "$pin" ] && break
|
|
sleep 0.2
|
|
done
|
|
if [ -z "$pin" ]; then
|
|
echo "no arming PIN in the pairing host's log ($log)" >&2
|
|
exit 1
|
|
fi
|
|
echo "$pin"
|
|
}
|
|
PIN="$(pin_from_log "$PAIR_LOG")"
|
|
GUESS_PIN="$(pin_from_log "$GUESS_LOG")"
|
|
|
|
cd clients/apple
|
|
PUNKTFUNK_LOOPBACK_PORT="$PORT" PUNKTFUNK_PAIRING_PORT="$PAIR_PORT" PUNKTFUNK_PAIRING_PIN="$PIN" \
|
|
PUNKTFUNK_GUESS_PORT="$GUESS_PORT" PUNKTFUNK_GUESS_PIN="$GUESS_PIN" \
|
|
PUNKTFUNK_TEST_FEEDBACK=1 \
|
|
swift test --filter 'LoopbackIntegrationTests|AudioDeviceSwitchTests'
|