From 056aa1d5c7bd05d227aa3935364c2a54b366eaaf Mon Sep 17 00:00:00 2001 From: maxjivi05 Date: Tue, 6 Oct 2026 12:58:02 -0400 Subject: [PATCH] Build the DirectAudio relay from source The relay helper shipped as a prebuilt libdirectaudiorelay.so with no source in the repo. Its source (The412Banner/directaudio @ 3548a4a, the commit the bundled driver names in version.txt) now lives in tools/directaudio-relay, unmodified, and CI and build_local.sh compile it into jniLibs the way proot is built. It shares da_relay_proto.h with the PulseAudio sink, which is byte-identical to its own copy. --- .github/workflows/build-aaudio-sink.yml | 2 + .github/workflows/build.yml | 5 + .gitignore | 1 + .../jniLibs/arm64-v8a/libdirectaudiorelay.so | Bin 28112 -> 0 bytes tools/build_local.sh | 1 + tools/directaudio-relay/build.sh | 40 + tools/directaudio-relay/directaudio-relay.c | 1073 +++++++++++++++++ 7 files changed, 1122 insertions(+) delete mode 100644 app/src/main/jniLibs/arm64-v8a/libdirectaudiorelay.so create mode 100755 tools/directaudio-relay/build.sh create mode 100644 tools/directaudio-relay/directaudio-relay.c diff --git a/.github/workflows/build-aaudio-sink.yml b/.github/workflows/build-aaudio-sink.yml index 63133e545..b4140934a 100644 --- a/.github/workflows/build-aaudio-sink.yml +++ b/.github/workflows/build-aaudio-sink.yml @@ -6,6 +6,7 @@ on: push: paths: - 'tools/aaudio-sink/**' + - 'tools/directaudio-relay/**' - '.github/workflows/build-aaudio-sink.yml' workflow_dispatch: @@ -25,6 +26,7 @@ jobs: set -euo pipefail export NDK="${ANDROID_NDK_LATEST_HOME:-${ANDROID_NDK_HOME:-$ANDROID_NDK_ROOT}}" tools/aaudio-sink/build.sh "$PWD/pa13" "$PWD/out" + tools/directaudio-relay/build.sh "$PWD/out" - uses: actions/upload-artifact@v4 with: name: audio-sink-modules diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3c0dac30d..8f335d224 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -325,6 +325,11 @@ jobs: mv pulseaudio.tzst app/src/main/assets/pulseaudio.tzst tar --use-compress-program=unzstd -tf app/src/main/assets/pulseaudio.tzst | grep -c '\.so$' rm -rf pa-bundle sink-out + - name: Build the DirectAudio relay + run: | + set -euo pipefail + export NDK="${ANDROID_NDK_LATEST_HOME:-${ANDROID_NDK_HOME:-$ANDROID_NDK_ROOT}}" + tools/directaudio-relay/build.sh app/src/main/jniLibs/arm64-v8a - name: Cache proot id: proot diff --git a/.gitignore b/.gitignore index 41551eec3..7601e9a43 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,7 @@ app/src/main/assets/linuxfs/ app/src/main/jniLibs/arm64-v8a/libproot.so app/src/main/jniLibs/arm64-v8a/.proot-inputs app/src/main/jniLibs/arm64-v8a/libproot-loader.so +app/src/main/jniLibs/arm64-v8a/libdirectaudiorelay.so app/src/main/assets/droiddeck-esync/ # Kotlin compiler session files (build-tool state, never source). diff --git a/app/src/main/jniLibs/arm64-v8a/libdirectaudiorelay.so b/app/src/main/jniLibs/arm64-v8a/libdirectaudiorelay.so deleted file mode 100644 index d530b848ff722ac830212e25a6028260b675a132..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 28112 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 diff --git a/tools/build_local.sh b/tools/build_local.sh index 2742ac6fc..bda425616 100755 --- a/tools/build_local.sh +++ b/tools/build_local.sh @@ -301,6 +301,7 @@ fi sink_output="${staging_dir}/sink-out" "${repo_root}/tools/aaudio-sink/build.sh" "${pa_source}" "${sink_output}" +"${repo_root}/tools/directaudio-relay/build.sh" "${repo_root}/app/src/main/jniLibs/arm64-v8a" # proot is rebuilt only when its sources (source.env, the patches, the build script) changed since # the libraries in jniLibs were built. proot_out="${repo_root}/app/src/main/jniLibs/arm64-v8a" diff --git a/tools/directaudio-relay/build.sh b/tools/directaudio-relay/build.sh new file mode 100755 index 000000000..be1de8e59 --- /dev/null +++ b/tools/directaudio-relay/build.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +set -euo pipefail +OUTDIR=$1 +mkdir -p "$OUTDIR" +: "${NDK:?set NDK to the Android NDK root}" +API=28 +HERE=$(cd "$(dirname "$0")" && pwd) +REPO=$(cd "$HERE/../.." && pwd) +case "$(uname -s):$(uname -m)" in + Darwin:arm64) NDK_HOST=darwin-arm64 ;; + Darwin:x86_64) NDK_HOST=darwin-x86_64 ;; + Linux:x86_64) NDK_HOST=linux-x86_64 ;; + Linux:aarch64|Linux:arm64) NDK_HOST=linux-aarch64 ;; + *) echo "Unsupported build host: $(uname -s) $(uname -m)" >&2; exit 1 ;; +esac +TOOLCHAIN="$NDK/toolchains/llvm/prebuilt/$NDK_HOST/bin" +if [[ ! -d "$TOOLCHAIN" && "$NDK_HOST" == darwin-arm64 && -d "$NDK/toolchains/llvm/prebuilt/darwin-x86_64/bin" ]]; then + TOOLCHAIN="$NDK/toolchains/llvm/prebuilt/darwin-x86_64/bin" +fi +if [[ ! -d "$TOOLCHAIN" && "$NDK_HOST" == linux-aarch64 && -d "$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin" ]]; then + TOOLCHAIN="$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin" +fi +CC="$TOOLCHAIN/aarch64-linux-android${API}-clang" +if [[ ! -x "$CC" ]]; then + echo "Android NDK toolchain not found at $TOOLCHAIN" >&2 + exit 1 +fi +OUT="$OUTDIR/libdirectaudiorelay.so" +"$CC" -O2 -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -fPIE -pie -Wl,-z,max-page-size=16384 \ + -I"$REPO/tools/aaudio-sink" \ + -o "$OUT" "$HERE/directaudio-relay.c" -laaudio -llog +"$TOOLCHAIN/llvm-strip" --strip-unneeded "$OUT" +NEEDED=$("$TOOLCHAIN/llvm-readelf" -d "$OUT" | sed -n 's/.*NEEDED.*\[\(.*\)\]/\1/p' | tr '\n' ' ') +echo "$(basename "$OUT") NEEDED: $NEEDED" +for lib in $NEEDED; do + case $lib in libaaudio.so|liblog.so|libc.so|libm.so|libdl.so) ;; + *) echo "ERROR: unexpected dependency $lib"; exit 1 ;; + esac +done +ls -l "$OUT" diff --git a/tools/directaudio-relay/directaudio-relay.c b/tools/directaudio-relay/directaudio-relay.c new file mode 100644 index 000000000..f7463f6b4 --- /dev/null +++ b/tools/directaudio-relay/directaudio-relay.c @@ -0,0 +1,1073 @@ +/* DirectAudio relay helper - the AAudio side of the driver, out of process. + * + * Copyright 2026 The412Banner + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * A small bionic process that owns every AAudio stream on behalf of driver + * instances that cannot open one themselves (see da_relay_proto.h for why). It + * listens on a unix socket; each connecting game gets an OUTPUT stream fed from + * a shared render ring and, when asked, an INPUT stream that fills a shared + * capture ring. The per-stream behaviour is the in-process driver's, ported + * line for line where it made sense: LOW_LATENCY by default, adaptive growth on + * xruns with slow decay, rebuild on route change or a stalled callback, and the + * live-config mailbox. What is new is the ring hand-off and its own adaptive + * step: a callback that finds the ring short raises the target the driver keeps + * queued, one burst at a time, up to a ceiling. + * + * The helper must run under the SAME uid as the app that owns the audio + * permissions (RECORD_AUDIO is checked against the calling uid), which in + * practice means the host app spawns it exactly as it spawns its PulseAudio + * daemon today. It exits when its socket is removed or on SIGTERM; a client + * going away (socket EOF) tears down that client's streams only. + * + * directaudio-relay --socket [--log] + * + * Build (NDK r27, API 28, 16 KB-page safe): + * aarch64-linux-android28-clang -O2 -Wl,-z,max-page-size=16384 \ + * directaudio-relay.c -o directaudio-relay -laaudio -llog -pthread + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "da_relay_proto.h" + +/* ---- logging -------------------------------------------------------------- + * Everything goes to logcat (tag "DA-Relay", the same place the in-process + * driver's "DirectAudio" events land) and, when --log is given, to stderr so a + * session log captures it too. Event-level lines are always on: they fire a + * handful of times per session and are what makes a field report actionable. */ +static int g_verbose; + +static void rlog(const char *fmt, ...) +{ + va_list ap; + char buf[512]; + + va_start(ap, fmt); + vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + __android_log_print(ANDROID_LOG_INFO, "DA-Relay", "%s", buf); + if (g_verbose) fprintf(stderr, "DA-Relay: %s\n", buf); +} +#define REVENT(...) rlog(__VA_ARGS__) +#define RLOG(...) do { if (g_verbose) rlog(__VA_ARGS__); } while (0) + +static uint64_t now_ns(void) +{ + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec; +} + +static void futex_wake_all(volatile uint32_t *word) +{ + syscall(SYS_futex, word, FUTEX_WAKE, INT32_MAX, NULL, NULL, 0); +} + +/* ---- tunables (the in-process driver's, same defaults) --------------------- */ +#define DA_KNEE 0.75f +#define DA_DEFAULT_MS 12 +#define DA_DEFAULT_MAX_MS 100 +#define DA_FREEZE_GAP_NS 500000000ull +#define DA_CB_STALL_NS 1000000000ull +#define DA_DECAY_QUIET_NS 10000000000ull +#define DA_DECAY_PUNISH_NS 5000000000ull +#define DA_DECAY_MAX_BACKOFF 32 + +/* ---- live runtime config (mailbox) ---------------------------------------- + * The path arrives in the first client's hello (every client of one host names + * the same file). One watcher thread stats it once a second; on change every + * client's output is rebuilt with the new values, exactly as the in-process + * driver rebuilds its single stream. */ +static char g_rt_path[256]; +static uint64_t g_rt_mtime; +static int g_rt_ms = -1, g_rt_maxms = -1, g_rt_perf = -1; + +static void read_runtime_file(void) +{ + FILE *f; + char line[128]; + + if (!g_rt_path[0] || !(f = fopen(g_rt_path, "r"))) return; + g_rt_ms = g_rt_maxms = g_rt_perf = -1; + while (fgets(line, sizeof(line), f)) + { + char *eq = strchr(line, '='); + int v; + + if (!eq) continue; + *eq = 0; + v = atoi(eq + 1); + if (!strcmp(line, "MS")) g_rt_ms = v > 0 ? v : -1; + else if (!strcmp(line, "MAXMS")) g_rt_maxms = v > 0 ? v : -1; + else if (!strcmp(line, "PERF")) g_rt_perf = (v >= 0 && v <= 2) ? v : -1; + } + fclose(f); +} + +/* ---- a client = one game process --------------------------------------- */ +struct client +{ + struct client *next; + int fd; /* the socket */ + int32_t pid; + char name[64]; + + /* launch config, from the hello */ + aaudio_performance_mode_t perf; + aaudio_sharing_mode_t share; + int adaptive, decay, watchdog, mic; + int32_t target_ms, max_ms, target_frames, max_frames; + uint64_t stall_ns, quiet_ns, punish_ns; + unsigned int max_backoff; + + /* render: ring + the one OUTPUT stream and its adaptive state */ + pthread_mutex_t lock; + int out_fd; + struct da_ring *out; + AAudioStream *aq; + int32_t last_xrun; + uint64_t last_cb_ns, last_xrun_ns, last_decay_ns, wd_last_tick_ns; + int32_t base_buf_frames, decay_floor; + unsigned int decay_backoff, cb_count, wd_last_cb; + int reopen_running, reopen_redo; + int32_t ring_max_target; /* ceiling for the ring's own adaptive step */ + + /* capture: ring + the one INPUT stream */ + int in_fd; + struct da_ring *in; + AAudioStream *cq; + int32_t in_rate, in_channels; + aaudio_format_t in_format; + int mic_started; /* requestStart issued on the current input */ + int cap_reopen_running, cap_reopen_redo; + unsigned int cap_cb_count; + + volatile int dead; +}; + +static pthread_mutex_t g_clients_lock = PTHREAD_MUTEX_INITIALIZER; +static struct client *g_clients; + +/* ---- rings --------------------------------------------------------------- */ +static int ring_create(uint32_t cap_frames, uint32_t rate, struct da_ring **out, int *fd_out) +{ + size_t bytes = da_ring_bytes(cap_frames); + int fd = (int)syscall(SYS_memfd_create, "da_ring", 0); + struct da_ring *r; + + if (fd < 0) { REVENT("memfd_create failed: %d", errno); return -1; } + if (ftruncate(fd, (off_t)bytes) != 0) { REVENT("ftruncate failed: %d", errno); close(fd); return -1; } + r = mmap(NULL, bytes, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (r == MAP_FAILED) { REVENT("mmap ring failed: %d", errno); close(fd); return -1; } + memset(r, 0, sizeof(*r)); + r->magic = DA_RING_MAGIC; + r->version = DA_RELAY_VERSION; + r->cap_frames = cap_frames; + r->rate = rate; + r->channels = DA_RING_CHANNELS; + *out = r; + *fd_out = fd; + return 0; +} + +static void ring_destroy(struct da_ring *r, int fd) +{ + if (r) + { + __atomic_store_n(&r->quit, 1, __ATOMIC_SEQ_CST); + futex_wake_all(&r->wake); + munmap(r, da_ring_bytes(r->cap_frames)); + } + if (fd >= 0) close(fd); +} + +/* ---- OUTPUT stream ------------------------------------------------------- */ +static void request_reopen(struct client *c, const char *why); + +/* The AAudio data callback: pull one block from the render ring. This is the + * in-process mixer_cb with the mixing replaced by a ring read; the bookkeeping + * after the copy (liveness, adaptive growth, decay) is ported as-is. */ +static aaudio_data_callback_result_t out_cb(AAudioStream *aq, void *user, + void *audioData, int32_t numFrames) +{ + struct client *c = user; + struct da_ring *r = c->out; + float *out = audioData; + uint32_t cap = r->cap_frames; + uint32_t ridx = __atomic_load_n(&r->ridx, __ATOMIC_ACQUIRE); + uint32_t avail = __atomic_load_n(&r->widx, __ATOMIC_ACQUIRE) - ridx; + uint32_t n = (uint32_t)numFrames < avail ? (uint32_t)numFrames : avail; + uint32_t i, first, slot = ridx % cap; + uint64_t now; + + /* Copy out, at most two memcpy's around the wrap. The soft-knee limiter ran + * in the game before the samples were queued, so this is a straight copy. */ + first = cap - slot < n ? cap - slot : n; + memcpy(out, &r->data[(size_t)slot * DA_RING_CHANNELS], (size_t)first * DA_RING_CHANNELS * sizeof(float)); + if (n > first) + memcpy(out + (size_t)first * DA_RING_CHANNELS, r->data, (size_t)(n - first) * DA_RING_CHANNELS * sizeof(float)); + for (i = n * DA_RING_CHANNELS; i < (uint32_t)numFrames * DA_RING_CHANNELS; i++) out[i] = 0.0f; + + __atomic_store_n(&r->ridx, ridx + n, __ATOMIC_RELEASE); + __atomic_add_fetch(&r->wake, 1, __ATOMIC_RELEASE); + futex_wake_all(&r->wake); + + /* Only the live, promoted stream owns the state below (same guard as the + * in-process build: an outgoing stream still gets a callback or two). */ + if (aq != __atomic_load_n(&c->aq, __ATOMIC_SEQ_CST) && __atomic_load_n(&c->aq, __ATOMIC_SEQ_CST)) + return AAUDIO_CALLBACK_RESULT_CONTINUE; + + now = now_ns(); + { + uint64_t prev = __atomic_exchange_n(&c->last_cb_ns, now, __ATOMIC_SEQ_CST); + if (prev && now - prev > DA_FREEZE_GAP_NS) + { + c->last_xrun = AAudioStream_getXRunCount(aq); + c->last_xrun_ns = now; + } + } + __atomic_add_fetch(&c->cb_count, 1, __ATOMIC_SEQ_CST); + __atomic_store_n(&r->cb_count, c->cb_count, __ATOMIC_RELAXED); + + /* The ring's own adaptive step. A short ring means the game's pump thread + * did not get scheduled in time - the equivalent of an xrun one stage + * earlier - so ask it to keep one more burst queued. Only grows; the AAudio + * buffer below is where decay lives, and the ring stays a small fixed cost + * on top of it. */ + if (n < (uint32_t)numFrames) + { + __atomic_add_fetch(&r->underruns, 1, __ATOMIC_RELAXED); + if (c->adaptive) + { + int32_t burst = AAudioStream_getFramesPerBurst(aq); + int32_t cur = __atomic_load_n(&r->target_frames, __ATOMIC_RELAXED); + int32_t want = cur + (burst > 0 ? burst : numFrames); + + if (want > c->ring_max_target) want = c->ring_max_target; + if (want > cur) + { + __atomic_store_n(&r->target_frames, want, __ATOMIC_RELEASE); + RLOG("[%d] ring grow: target %d -> %d frames (short by %u)", c->pid, cur, want, + (uint32_t)numFrames - n); + } + } + } + + if (c->adaptive) + { + int32_t xruns = AAudioStream_getXRunCount(aq); + int32_t burst = AAudioStream_getFramesPerBurst(aq); + int32_t cur = AAudioStream_getBufferSizeInFrames(aq); + + if (xruns > c->last_xrun) + { + int32_t capf = AAudioStream_getBufferCapacityInFrames(aq); + int32_t want = cur + (burst > 0 ? burst : 1); + + if (c->max_frames > 0 && want > c->max_frames) want = c->max_frames; + if (want > capf) want = capf; + if (want > cur) AAudioStream_setBufferSizeInFrames(aq, want); + + if (c->decay && c->last_decay_ns && now - c->last_decay_ns < c->punish_ns) + { + if (want > c->decay_floor) + { + c->decay_floor = want; + REVENT("[%d] decay floor: %d frames (%d ms) - not probing below it", + c->pid, want, want * 1000 / DA_RING_RATE); + } + if (c->decay_backoff < c->max_backoff) c->decay_backoff *= 2; + } + else RLOG("[%d] grow: buf %d -> %d frames (xruns %d)", c->pid, cur, want, xruns); + c->last_xrun = xruns; + c->last_xrun_ns = now; + __atomic_store_n(&r->hw_buf_frames, AAudioStream_getBufferSizeInFrames(aq), __ATOMIC_RELAXED); + } + else if (c->decay && burst > 0) + { + uint64_t quiet = c->quiet_ns * c->decay_backoff; + int32_t floor = c->base_buf_frames; + + if (c->decay_floor > floor) floor = c->decay_floor; + if (cur > floor && c->last_xrun_ns && now - c->last_xrun_ns > quiet && + (!c->last_decay_ns || now - c->last_decay_ns > quiet)) + { + int32_t want = cur - burst; + + if (want < floor) want = floor; + if (want < cur) + { + AAudioStream_setBufferSizeInFrames(aq, want); + c->last_decay_ns = now; + __atomic_store_n(&r->hw_buf_frames, AAudioStream_getBufferSizeInFrames(aq), __ATOMIC_RELAXED); + RLOG("[%d] decay: buf %d -> %d frames (floor %d)", c->pid, cur, want, floor); + } + } + } + } + + if (g_verbose && !(c->cb_count % 1000)) + RLOG("[%d] hb: cb=%u buf=%d cap=%d xruns=%d ring=%u/%d under=%u", c->pid, c->cb_count, + AAudioStream_getBufferSizeInFrames(aq), AAudioStream_getBufferCapacityInFrames(aq), + AAudioStream_getXRunCount(aq), avail, r->target_frames, r->underruns); + + return AAUDIO_CALLBACK_RESULT_CONTINUE; +} + +static void out_error_cb(AAudioStream *aq, void *user, aaudio_result_t error) +{ + struct client *c = user; + + if (aq != __atomic_load_n(&c->aq, __ATOMIC_SEQ_CST)) return; + if (error != AAUDIO_ERROR_DISCONNECTED && + error != AAUDIO_ERROR_INVALID_STATE && + error != AAUDIO_ERROR_INVALID_HANDLE && + error != AAUDIO_ERROR_TIMEOUT) + return; + request_reopen(c, "stream error"); +} + +static void apply_runtime_overrides(struct client *c) +{ + if (g_rt_ms >= 0) { c->target_ms = g_rt_ms; c->target_frames = 0; } + if (g_rt_maxms > 0) c->max_frames = g_rt_maxms * DA_RING_RATE / 1000; + if (g_rt_perf == 0) c->perf = AAUDIO_PERFORMANCE_MODE_NONE; + else if (g_rt_perf == 1) c->perf = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY; + else if (g_rt_perf == 2) c->perf = AAUDIO_PERFORMANCE_MODE_POWER_SAVING; +} + +/* Port of mixer_open_stream: 48 kHz / float / stereo, buffer from the ms or + * frame form rounded up to a burst, capacity from the ceiling. */ +static aaudio_result_t open_output(struct client *c, AAudioStream **out) +{ + AAudioStreamBuilder *builder = NULL; + AAudioStream *aq = NULL; + aaudio_result_t r; + + apply_runtime_overrides(c); + r = AAudio_createStreamBuilder(&builder); + if (r != AAUDIO_OK || !builder) return r != AAUDIO_OK ? r : AAUDIO_ERROR_NO_MEMORY; + + AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_OUTPUT); + AAudioStreamBuilder_setSharingMode(builder, c->share); + AAudioStreamBuilder_setPerformanceMode(builder, c->perf); + AAudioStreamBuilder_setUsage(builder, AAUDIO_USAGE_GAME); + AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_FLOAT); + AAudioStreamBuilder_setChannelCount(builder, DA_RING_CHANNELS); + AAudioStreamBuilder_setSampleRate(builder, DA_RING_RATE); + AAudioStreamBuilder_setDataCallback(builder, out_cb, c); + AAudioStreamBuilder_setErrorCallback(builder, out_error_cb, c); + { + int32_t cap_req = c->max_frames > 0 ? c->max_frames : DA_DEFAULT_MAX_MS * DA_RING_RATE / 1000; + if (cap_req > 0) AAudioStreamBuilder_setBufferCapacityInFrames(builder, cap_req); + } + + r = AAudioStreamBuilder_openStream(builder, &aq); + AAudioStreamBuilder_delete(builder); + if (r != AAUDIO_OK || !aq) return r != AAUDIO_OK ? r : AAUDIO_ERROR_INTERNAL; + + { + int32_t capf = AAudioStream_getBufferCapacityInFrames(aq); + int32_t burst = AAudioStream_getFramesPerBurst(aq); + int32_t want; + + if (c->target_frames > 0 && c->target_ms <= 0) + want = c->target_frames; + else + { + int32_t ms = c->target_ms > 0 ? c->target_ms : DA_DEFAULT_MS; + want = ms * DA_RING_RATE / 1000; + if (burst > 0) + { + int32_t nb = (want + burst - 1) / burst; + want = (nb < 1 ? 1 : nb) * burst; + } + } + if (want > capf) want = capf; + if (want > 0) AAudioStream_setBufferSizeInFrames(aq, want); + + /* The ring's initial target: DA_RING_TARGET_BURSTS bursts of the real + * burst size, ceiling DA_RING_MAX_TARGET_MS. Set on every (re)open so a + * recovered stream starts low again, like the buffer does. */ + if (burst <= 0) burst = 192; + c->ring_max_target = DA_RING_MAX_TARGET_MS * DA_RING_RATE / 1000; + if (c->ring_max_target > (int32_t)c->out->cap_frames) c->ring_max_target = c->out->cap_frames; + __atomic_store_n(&c->out->target_frames, DA_RING_TARGET_BURSTS * burst, __ATOMIC_RELEASE); + __atomic_store_n(&c->out->hw_burst, burst, __ATOMIC_RELAXED); + } + c->last_xrun = AAudioStream_getXRunCount(aq); + c->base_buf_frames = AAudioStream_getBufferSizeInFrames(aq); + c->decay_floor = 0; + c->decay_backoff = 1; + c->last_xrun_ns = now_ns(); + c->last_decay_ns = 0; + __atomic_store_n(&c->out->hw_buf_frames, c->base_buf_frames, __ATOMIC_RELAXED); + + REVENT("[%d] open: buffer %d frames (%d ms) burst %d cap %d perf %d sharing req=%d got=%d" + " ring target %d - device adds its own output latency", + c->pid, c->base_buf_frames, c->base_buf_frames * 1000 / DA_RING_RATE, + AAudioStream_getFramesPerBurst(aq), AAudioStream_getBufferCapacityInFrames(aq), + AAudioStream_getPerformanceMode(aq), c->share, AAudioStream_getSharingMode(aq), + c->out->target_frames); + + r = AAudioStream_requestStart(aq); + if (r != AAUDIO_OK) { AAudioStream_close(aq); return r; } + + __atomic_store_n(&c->last_cb_ns, now_ns(), __ATOMIC_SEQ_CST); + c->wd_last_tick_ns = 0; + __atomic_store_n(&c->out->state, DA_RING_PLAYING, __ATOMIC_RELEASE); + *out = aq; + return AAUDIO_OK; +} + +static void *reopen_thread(void *user) +{ + struct client *c = user; + + for (;;) + { + AAudioStream *old = NULL, *neu = NULL; + int expected = 0; + + __atomic_store_n(&c->reopen_redo, 0, __ATOMIC_SEQ_CST); + if (c->dead) break; + + if (open_output(c, &neu) == AAUDIO_OK) + { + pthread_mutex_lock(&c->lock); + old = c->aq; + __atomic_store_n(&c->aq, neu, __ATOMIC_SEQ_CST); + pthread_mutex_unlock(&c->lock); + } + else REVENT("[%d] reopen failed; keeping old stream", c->pid); + + if (old) + { + AAudioStream_requestStop(old); + AAudioStream_close(old); + RLOG("[%d] reopened output", c->pid); + } + + if (__atomic_load_n(&c->reopen_redo, __ATOMIC_SEQ_CST)) { usleep(20000); continue; } + __atomic_store_n(&c->reopen_running, 0, __ATOMIC_SEQ_CST); + if (!__atomic_load_n(&c->reopen_redo, __ATOMIC_SEQ_CST)) break; + if (!__atomic_compare_exchange_n(&c->reopen_running, &expected, 1, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) + break; + } + return NULL; +} + +static void request_reopen(struct client *c, const char *why) +{ + int expected = 0; + + __atomic_store_n(&c->reopen_redo, 1, __ATOMIC_SEQ_CST); + if (__atomic_compare_exchange_n(&c->reopen_running, &expected, 1, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) + { + pthread_t th; + REVENT("[%d] reopen: %s", c->pid, why); + if (pthread_create(&th, NULL, reopen_thread, c)) + __atomic_store_n(&c->reopen_running, 0, __ATOMIC_SEQ_CST); + else + pthread_detach(th); + } +} + +/* Port of mixer_watchdog, driven from the housekeeping thread once a second + * (the in-process build ticks it per mmdevapi period; the stall threshold is + * one second, so a one-second tick still trips within two). */ +static void watchdog(struct client *c) +{ + uint64_t now = now_ns(), last_cb, prev_tick; + unsigned int cb; + + if (!c->watchdog) return; + if (!__atomic_load_n(&c->aq, __ATOMIC_SEQ_CST)) return; + + prev_tick = c->wd_last_tick_ns; + c->wd_last_tick_ns = now; + cb = __atomic_load_n(&c->cb_count, __ATOMIC_SEQ_CST); + + if (!prev_tick || now - prev_tick > 2 * DA_FREEZE_GAP_NS + 1000000000ull) + { + c->wd_last_cb = cb; + __atomic_store_n(&c->last_cb_ns, now, __ATOMIC_SEQ_CST); + return; + } + if (cb != c->wd_last_cb) { c->wd_last_cb = cb; return; } + + last_cb = __atomic_load_n(&c->last_cb_ns, __ATOMIC_SEQ_CST); + if (!last_cb || now - last_cb < c->stall_ns) return; + + __atomic_store_n(&c->last_cb_ns, now, __ATOMIC_SEQ_CST); + request_reopen(c, "data callback stalled"); +} + +/* ---- INPUT stream (microphone) ------------------------------------------- */ +static void cap_request_reopen(struct client *c, const char *why); + +/* The input callback: convert whatever AAudio granted (float or I16, mono or + * stereo) to float stereo and queue it. The rate is left as granted; the + * driver resamples per voice exactly as the in-process capture_fill_voice does. */ +static aaudio_data_callback_result_t in_cb(AAudioStream *aq, void *user, + void *audioData, int32_t numFrames) +{ + struct client *c = user; + struct da_ring *r = c->in; + uint32_t cap, widx, space, n, i; + + __atomic_add_fetch(&c->cap_cb_count, 1, __ATOMIC_RELAXED); + if (aq != __atomic_load_n(&c->cq, __ATOMIC_SEQ_CST) && __atomic_load_n(&c->cq, __ATOMIC_SEQ_CST)) + return AAUDIO_CALLBACK_RESULT_CONTINUE; + if (!r) return AAUDIO_CALLBACK_RESULT_CONTINUE; + + cap = r->cap_frames; + widx = __atomic_load_n(&r->widx, __ATOMIC_RELAXED); + space = cap - (widx - __atomic_load_n(&r->ridx, __ATOMIC_ACQUIRE)); + n = (uint32_t)numFrames < space ? (uint32_t)numFrames : space; /* overrun: drop the newest */ + + for (i = 0; i < n; i++) + { + uint32_t slot = (widx + i) % cap; + float L, R; + + if (c->in_format == AAUDIO_FORMAT_PCM_I16) + { + const int16_t *p = (const int16_t *)audioData + (size_t)i * c->in_channels; + L = p[0] * (1.0f / 32768.0f); + R = c->in_channels > 1 ? p[1] * (1.0f / 32768.0f) : L; + } + else + { + const float *p = (const float *)audioData + (size_t)i * c->in_channels; + L = p[0]; + R = c->in_channels > 1 ? p[1] : p[0]; + } + r->data[(size_t)slot * 2] = L; + r->data[(size_t)slot * 2 + 1] = R; + } + __atomic_store_n(&r->widx, widx + n, __ATOMIC_RELEASE); + __atomic_add_fetch(&r->wake, 1, __ATOMIC_RELEASE); + futex_wake_all(&r->wake); + if (n < (uint32_t)numFrames) __atomic_add_fetch(&r->underruns, 1, __ATOMIC_RELAXED); + __atomic_store_n(&r->cb_count, c->cap_cb_count, __ATOMIC_RELAXED); + return AAUDIO_CALLBACK_RESULT_CONTINUE; +} + +static void in_error_cb(AAudioStream *aq, void *user, aaudio_result_t error) +{ + struct client *c = user; + + if (aq != __atomic_load_n(&c->cq, __ATOMIC_SEQ_CST)) return; + if (error != AAUDIO_ERROR_DISCONNECTED && + error != AAUDIO_ERROR_INVALID_STATE && + error != AAUDIO_ERROR_INVALID_HANDLE && + error != AAUDIO_ERROR_TIMEOUT) + return; + cap_request_reopen(c, "capture stream error"); +} + +/* Port of capture_open_stream: open (NOT start) 48 kHz / float / stereo with + * the VOICE_COMMUNICATION preset for platform AEC / noise suppression / AGC. */ +static aaudio_result_t open_input(struct client *c, AAudioStream **out) +{ + AAudioStreamBuilder *builder = NULL; + AAudioStream *aq = NULL; + aaudio_result_t r; + + r = AAudio_createStreamBuilder(&builder); + if (r != AAUDIO_OK || !builder) return r != AAUDIO_OK ? r : AAUDIO_ERROR_NO_MEMORY; + + AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_INPUT); + AAudioStreamBuilder_setSharingMode(builder, AAUDIO_SHARING_MODE_SHARED); + AAudioStreamBuilder_setPerformanceMode(builder, c->perf); + AAudioStreamBuilder_setInputPreset(builder, AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION); + AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_FLOAT); + AAudioStreamBuilder_setChannelCount(builder, DA_RING_CHANNELS); + AAudioStreamBuilder_setSampleRate(builder, DA_RING_RATE); + AAudioStreamBuilder_setDataCallback(builder, in_cb, c); + AAudioStreamBuilder_setErrorCallback(builder, in_error_cb, c); + + r = AAudioStreamBuilder_openStream(builder, &aq); + AAudioStreamBuilder_delete(builder); + if (r != AAUDIO_OK || !aq) return r != AAUDIO_OK ? r : AAUDIO_ERROR_INTERNAL; + + REVENT("[%d] capture open: req 48000/float/2ch preset=voicecomm perf=%d - got rate=%d ch=%d fmt=%d", + c->pid, c->perf, AAudioStream_getSampleRate(aq), AAudioStream_getChannelCount(aq), + AAudioStream_getFormat(aq)); + *out = aq; + return AAUDIO_OK; +} + +static void note_input_geometry(struct client *c, AAudioStream *aq) +{ + c->in_rate = AAudioStream_getSampleRate(aq); + c->in_channels = AAudioStream_getChannelCount(aq); + c->in_format = AAudioStream_getFormat(aq); + if (c->in_rate <= 0) c->in_rate = DA_RING_RATE; + if (c->in_channels <= 0) c->in_channels = DA_RING_CHANNELS; +} + +static void *cap_reopen_thread(void *user) +{ + struct client *c = user; + + for (;;) + { + AAudioStream *old = NULL, *neu = NULL; + int expected = 0, want_start; + + __atomic_store_n(&c->cap_reopen_redo, 0, __ATOMIC_SEQ_CST); + if (c->dead) break; + + pthread_mutex_lock(&c->lock); + want_start = c->mic_started; + pthread_mutex_unlock(&c->lock); + + if (open_input(c, &neu) == AAUDIO_OK) + { + pthread_mutex_lock(&c->lock); + old = c->cq; + note_input_geometry(c, neu); + /* The ring's rate is what the driver resamples from. A reopen on a + * different route can change it (a BT headset mic at 16 kHz); the + * driver re-reads the header per block, so publish before promoting. */ + if (c->in) __atomic_store_n(&c->in->rate, (uint32_t)c->in_rate, __ATOMIC_RELEASE); + __atomic_store_n(&c->cq, neu, __ATOMIC_SEQ_CST); + c->mic_started = 0; + pthread_mutex_unlock(&c->lock); + + if (want_start) + { + if (AAudioStream_requestStart(neu) == AAUDIO_OK) + { + pthread_mutex_lock(&c->lock); + c->mic_started = 1; + pthread_mutex_unlock(&c->lock); + } + else REVENT("[%d] capture reopen: requestStart failed", c->pid); + } + } + else REVENT("[%d] capture reopen failed; keeping old stream", c->pid); + + if (old) + { + AAudioStream_requestStop(old); + AAudioStream_close(old); + } + + if (__atomic_load_n(&c->cap_reopen_redo, __ATOMIC_SEQ_CST)) { usleep(20000); continue; } + __atomic_store_n(&c->cap_reopen_running, 0, __ATOMIC_SEQ_CST); + if (!__atomic_load_n(&c->cap_reopen_redo, __ATOMIC_SEQ_CST)) break; + if (!__atomic_compare_exchange_n(&c->cap_reopen_running, &expected, 1, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) + break; + } + return NULL; +} + +static void cap_request_reopen(struct client *c, const char *why) +{ + int expected = 0; + + __atomic_store_n(&c->cap_reopen_redo, 1, __ATOMIC_SEQ_CST); + if (__atomic_compare_exchange_n(&c->cap_reopen_running, &expected, 1, 0, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) + { + pthread_t th; + REVENT("[%d] capture reopen: %s", c->pid, why); + if (pthread_create(&th, NULL, cap_reopen_thread, c)) + __atomic_store_n(&c->cap_reopen_running, 0, __ATOMIC_SEQ_CST); + else + pthread_detach(th); + } +} + +static void mic_start(struct client *c) +{ + AAudioStream *aq = NULL; + + pthread_mutex_lock(&c->lock); + if (c->cq && !c->mic_started) { c->mic_started = 1; aq = c->cq; } + pthread_mutex_unlock(&c->lock); + if (!aq) return; + if (AAudioStream_requestStart(aq) != AAUDIO_OK) + { + REVENT("[%d] capture requestStart failed", c->pid); + pthread_mutex_lock(&c->lock); + c->mic_started = 0; + pthread_mutex_unlock(&c->lock); + } + else REVENT("[%d] capture start", c->pid); +} + +static void mic_stop(struct client *c) +{ + AAudioStream *aq = NULL; + + pthread_mutex_lock(&c->lock); + if (c->cq && c->mic_started) { c->mic_started = 0; aq = c->cq; } + pthread_mutex_unlock(&c->lock); + if (!aq) return; + AAudioStream_requestStop(aq); + REVENT("[%d] capture stop: no voices", c->pid); +} + +/* ---- client lifecycle ---------------------------------------------------- */ +static int read_full(int fd, void *buf, size_t len) +{ + char *p = buf; + while (len) + { + ssize_t n = read(fd, p, len); + if (n < 0) { if (errno == EINTR) continue; return -1; } + if (n == 0) return -1; + p += n; len -= (size_t)n; + } + return 0; +} + +static int send_ack(int sock, const struct da_ack *ack, const int *fds, int nfds) +{ + struct msghdr msg; + struct iovec iov; + char cbuf[CMSG_SPACE(sizeof(int) * 2)]; + struct cmsghdr *cm; + + memset(&msg, 0, sizeof(msg)); + memset(cbuf, 0, sizeof(cbuf)); + iov.iov_base = (void *)ack; + iov.iov_len = sizeof(*ack); + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + if (nfds > 0) + { + msg.msg_control = cbuf; + msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds); + cm = CMSG_FIRSTHDR(&msg); + cm->cmsg_level = SOL_SOCKET; + cm->cmsg_type = SCM_RIGHTS; + cm->cmsg_len = CMSG_LEN(sizeof(int) * nfds); + memcpy(CMSG_DATA(cm), fds, sizeof(int) * nfds); + } + return sendmsg(sock, &msg, MSG_NOSIGNAL) == (ssize_t)sizeof(*ack) ? 0 : -1; +} + +static void client_teardown(struct client *c) +{ + AAudioStream *aq, *cq; + + c->dead = 1; + pthread_mutex_lock(&g_clients_lock); + { + struct client **pp = &g_clients; + while (*pp && *pp != c) pp = &(*pp)->next; + if (*pp) *pp = c->next; + } + pthread_mutex_unlock(&g_clients_lock); + + /* Let any in-flight reopen worker finish with the stream it is holding. */ + while (__atomic_load_n(&c->reopen_running, __ATOMIC_SEQ_CST) || + __atomic_load_n(&c->cap_reopen_running, __ATOMIC_SEQ_CST)) + usleep(10000); + + pthread_mutex_lock(&c->lock); + aq = c->aq; c->aq = NULL; + cq = c->cq; c->cq = NULL; + pthread_mutex_unlock(&c->lock); + if (aq) { AAudioStream_requestStop(aq); AAudioStream_close(aq); } + if (cq) { AAudioStream_requestStop(cq); AAudioStream_close(cq); } + + REVENT("[%d] gone (%s): cb=%u ring underruns=%u", c->pid, c->name, c->cb_count, + c->out ? c->out->underruns : 0u); + ring_destroy(c->out, c->out_fd); + ring_destroy(c->in, c->in_fd); + if (c->fd >= 0) close(c->fd); + pthread_mutex_destroy(&c->lock); + free(c); +} + +static void *client_thread(void *user) +{ + struct client *c = user; + struct da_hello h; + struct da_ack ack; + int fds[2] = { -1, -1 }, nfds = 0; + aaudio_result_t r; + + if (read_full(c->fd, &h, sizeof(h)) != 0 || h.magic != DA_HELLO_MAGIC) + { + /* Usually the driver's test_connect probe: connect, close, no hello. */ + RLOG("connection closed before a hello (probe?)"); + close(c->fd); c->fd = -1; + client_teardown(c); + return NULL; + } + if (h.version != DA_RELAY_VERSION) + { + REVENT("protocol mismatch: driver %u, helper %u - refusing", h.version, DA_RELAY_VERSION); + memset(&ack, 0, sizeof(ack)); + ack.magic = DA_ACK_MAGIC; + ack.status = AAUDIO_ERROR_UNIMPLEMENTED; + send_ack(c->fd, &ack, NULL, 0); + close(c->fd); c->fd = -1; + client_teardown(c); + return NULL; + } + + c->pid = h.pid; + memcpy(c->name, h.name, sizeof(c->name)); + c->name[sizeof(c->name) - 1] = 0; + c->perf = h.perf == 0 ? AAUDIO_PERFORMANCE_MODE_NONE : + h.perf == 2 ? AAUDIO_PERFORMANCE_MODE_POWER_SAVING : AAUDIO_PERFORMANCE_MODE_LOW_LATENCY; + c->share = (h.flags & DA_HELLO_EXCLUSIVE) ? AAUDIO_SHARING_MODE_EXCLUSIVE : AAUDIO_SHARING_MODE_SHARED; + c->adaptive = !!(h.flags & DA_HELLO_ADAPTIVE); + c->decay = !!(h.flags & DA_HELLO_DECAY); + c->watchdog = !!(h.flags & DA_HELLO_WATCHDOG); + c->mic = !!(h.flags & DA_HELLO_MIC); + c->target_ms = h.target_ms; + c->max_ms = h.max_ms; + c->target_frames = h.target_frames; + c->max_frames = h.max_frames; + if (c->max_ms > 0) c->max_frames = c->max_ms * DA_RING_RATE / 1000; + c->stall_ns = h.stall_ms ? (uint64_t)h.stall_ms * 1000000ull : DA_CB_STALL_NS; + c->quiet_ns = h.quiet_ms ? (uint64_t)h.quiet_ms * 1000000ull : DA_DECAY_QUIET_NS; + c->punish_ns = h.punish_ms ? (uint64_t)h.punish_ms * 1000000ull : DA_DECAY_PUNISH_NS; + c->max_backoff = h.max_backoff ? h.max_backoff : DA_DECAY_MAX_BACKOFF; + if (h.log) g_verbose = 1; + if (h.runtime_path[0] && !g_rt_path[0]) + { + memcpy(g_rt_path, h.runtime_path, sizeof(g_rt_path)); + g_rt_path[sizeof(g_rt_path) - 1] = 0; + read_runtime_file(); + } + + REVENT("[%d] hello from %s: perf=%d share=%d adaptive=%d decay=%d watchdog=%d mic=%d" + " ms=%d maxms=%d bf=%d mbf=%d", c->pid, c->name, h.perf, c->share, c->adaptive, + c->decay, c->watchdog, c->mic, c->target_ms, c->max_ms, c->target_frames, c->max_frames); + + memset(&ack, 0, sizeof(ack)); + ack.magic = DA_ACK_MAGIC; + + /* render ring + output stream */ + if (ring_create(DA_RING_CAP_MS * DA_RING_RATE / 1000, DA_RING_RATE, &c->out, &c->out_fd) != 0) + { + ack.status = AAUDIO_ERROR_NO_MEMORY; + goto reply; + } + r = open_output(c, &c->aq); + if (r != AAUDIO_OK) + { + REVENT("[%d] output open failed: %d", c->pid, r); + ack.status = r; + goto reply; + } + ack.rate = AAudioStream_getSampleRate(c->aq); + ack.burst = AAudioStream_getFramesPerBurst(c->aq); + ack.buf_frames = AAudioStream_getBufferSizeInFrames(c->aq); + ack.out_cap_frames = (int32_t)c->out->cap_frames; + fds[nfds++] = c->out_fd; + + /* capture ring + input stream, only when asked. A mic that will not open + * (RECORD_AUDIO not granted to the uid) is reported, not fatal: the game + * gets its output and the driver invalidates its capture endpoint. */ + if (c->mic) + { + r = open_input(c, &c->cq); + if (r != AAUDIO_OK) + { + REVENT("[%d] capture open failed: %d - mic unavailable", c->pid, r); + ack.flags |= DA_ACK_MIC_FAILED; + } + else + { + note_input_geometry(c, c->cq); + if (ring_create((uint32_t)((int64_t)DA_CAPTURE_RING_MS * c->in_rate / 1000), + (uint32_t)c->in_rate, &c->in, &c->in_fd) != 0) + { + AAudioStream_close(c->cq); c->cq = NULL; + ack.flags |= DA_ACK_MIC_FAILED; + } + else + { + ack.in_cap_frames = (int32_t)c->in->cap_frames; + ack.in_rate = c->in_rate; + __atomic_store_n(&c->in->state, DA_RING_PLAYING, __ATOMIC_RELEASE); + fds[nfds++] = c->in_fd; + } + } + } + +reply: + if (send_ack(c->fd, &ack, fds, nfds) != 0 || ack.status != 0) + { + if (ack.status == 0) REVENT("[%d] ack send failed: %d", c->pid, errno); + client_teardown(c); + return NULL; + } + REVENT("[%d] serving: out ring %d frames, in ring %d frames @ %d", c->pid, + ack.out_cap_frames, ack.in_cap_frames, ack.in_rate); + + /* Now just listen: mic start/stop, and EOF when the game exits. */ + for (;;) + { + struct da_msg m; + + if (read_full(c->fd, &m, sizeof(m)) != 0) break; + switch (m.type) + { + case DA_MSG_MIC_START: mic_start(c); break; + case DA_MSG_MIC_STOP: mic_stop(c); break; + case DA_MSG_PING: break; + default: RLOG("[%d] unknown msg %u", c->pid, m.type); break; + } + } + client_teardown(c); + return NULL; +} + +/* ---- housekeeping: watchdog tick + mailbox watch, once a second ------------- */ +static void *housekeeping_thread(void *unused) +{ + struct timespec iv = { 1, 0 }; + + (void)unused; + for (;;) + { + struct client *c; + int reload = 0; + + nanosleep(&iv, NULL); + + if (g_rt_path[0]) + { + struct stat st; + if (stat(g_rt_path, &st) == 0) + { + uint64_t m = (uint64_t)st.st_mtim.tv_sec * 1000000000ull + (uint64_t)st.st_mtim.tv_nsec; + if (m != g_rt_mtime) + { + g_rt_mtime = m; + read_runtime_file(); + REVENT("runtime: reload ms=%d maxms=%d perf=%d", g_rt_ms, g_rt_maxms, g_rt_perf); + reload = 1; + } + } + } + + pthread_mutex_lock(&g_clients_lock); + for (c = g_clients; c; c = c->next) + { + if (c->dead) continue; + watchdog(c); + if (reload && __atomic_load_n(&c->aq, __ATOMIC_SEQ_CST)) + request_reopen(c, "runtime config change"); + } + pthread_mutex_unlock(&g_clients_lock); + } + return NULL; +} + +/* ---- main ---------------------------------------------------------------- */ +static volatile sig_atomic_t g_stop; +static void on_term(int sig) { (void)sig; g_stop = 1; } + +int main(int argc, char **argv) +{ + const char *path = NULL; + struct sockaddr_un addr; + pthread_t th; + int srv, i; + + for (i = 1; i < argc; i++) + { + if (!strcmp(argv[i], "--socket") && i + 1 < argc) path = argv[++i]; + else if (!strcmp(argv[i], "--log")) g_verbose = 1; + else { fprintf(stderr, "usage: directaudio-relay --socket [--log]\n"); return 2; } + } + if (!path) + { + const char *rt = getenv("XDG_RUNTIME_DIR"); + static char def[512]; + if (!rt) { fprintf(stderr, "directaudio-relay: --socket required\n"); return 2; } + snprintf(def, sizeof(def), "%s/%s", rt, DA_RELAY_DEFAULT_NAME); + path = def; + } + if (strlen(path) >= sizeof(addr.sun_path)) { fprintf(stderr, "socket path too long\n"); return 2; } + + signal(SIGPIPE, SIG_IGN); + signal(SIGTERM, on_term); + signal(SIGINT, on_term); + + srv = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); + if (srv < 0) { REVENT("socket: %d", errno); return 1; } + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + strcpy(addr.sun_path, path); + unlink(path); + if (bind(srv, (struct sockaddr *)&addr, sizeof(addr)) != 0) { REVENT("bind %s: %d", path, errno); return 1; } + chmod(path, 0666); + if (listen(srv, 8) != 0) { REVENT("listen: %d", errno); return 1; } + + if (pthread_create(&th, NULL, housekeeping_thread, NULL) == 0) pthread_detach(th); + REVENT("listening on %s (protocol v%d, pid %d)", path, DA_RELAY_VERSION, (int)getpid()); + + while (!g_stop) + { + struct client *c; + int fd = accept4(srv, NULL, NULL, SOCK_CLOEXEC); + + if (fd < 0) + { + if (errno == EINTR) continue; + REVENT("accept: %d", errno); + break; + } + c = calloc(1, sizeof(*c)); + if (!c) { close(fd); continue; } + pthread_mutex_init(&c->lock, NULL); + c->fd = fd; + c->out_fd = c->in_fd = -1; + pthread_mutex_lock(&g_clients_lock); + c->next = g_clients; + g_clients = c; + pthread_mutex_unlock(&g_clients_lock); + if (pthread_create(&th, NULL, client_thread, c) == 0) pthread_detach(th); + else client_teardown(c); + } + + REVENT("exiting"); + close(srv); + unlink(path); + return 0; +}