mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 21:29:58 -04:00
- An audio_prefill_ms of 180 or more asked for more queued audio than the renderer ever fills the ring to (half of it), so the output never started and stayed silent. The prefill is now held to that target; nx2navi.ini.example says so. - An infinite or huge pitch or sample rate from the game kept the per-sample loops going for good under the renderer's lock, which then blocked the game's RequestUpdate. The step is held to 64 source samples per output sample. - An endless loop buffer with no samples (start equal to end), which the voice keeps as the DSP does, made advance_voice go round for good; it now starves the voice as intended. - A NaN sample or effect state reached the device, where it plays as full scale; it now plays as silence. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
519 lines
23 KiB
C
519 lines
23 KiB
C
// Contains code Copyright (c) 2026 MacNativeGames contributors, Copyright (c) Ryujinx Team and Contributors (MIT; see
|
|
// THIRD_PARTY_NOTICES.md).
|
|
// audren:u. The SDK's nn::audio client builds RequestUpdate input unchanged; this
|
|
// service validates every section against the header, keeps server-side voice state, advances it in real time (one
|
|
// frame of sample_count / sample_rate seconds per render tick, signalling the renderer's event) and writes the output
|
|
// status the client expects. The mixer behind it is audio_mixer.c.
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "audren.h"
|
|
#include "host.h"
|
|
#include "ipc.h"
|
|
#include "platform/platform.h"
|
|
|
|
static volatile int32_t g_live;
|
|
|
|
long audren_renderers_live(void) { return plat_cas32(&g_live, 0, 0); }
|
|
|
|
static int revision_number(uint32_t rev) { return (int)(rev >> 24) - '0'; }
|
|
|
|
static void need(int ok, const char *what) {
|
|
if (ok) return;
|
|
ipc_backtrace();
|
|
rt_fatal("audren: %s", what);
|
|
}
|
|
|
|
static AudioRenderer *renderer_new(const AudrenParameter *p) {
|
|
need(p->sample_rate == 48000 || p->sample_rate == 32000, "unsupported output rate");
|
|
need(p->sample_count > 0 && p->sample_count <= 4800, "sample count");
|
|
need(p->voice_count > 0 && p->voice_count <= 1024 && p->sink_count > 0 && p->sink_count <= 256 &&
|
|
p->effect_count >= 0 && p->effect_count <= 4096 && p->submix_count >= 0 && p->submix_count < 256,
|
|
"renderer counts");
|
|
AudioRenderer *r = calloc(1, sizeof *r);
|
|
need(r != NULL, "renderer allocation");
|
|
r->param = *p;
|
|
r->revision = p->revision;
|
|
r->voices = calloc((size_t)p->voice_count, sizeof *r->voices);
|
|
r->pools = calloc((size_t)p->effect_count + 4u * (size_t)p->voice_count, sizeof *r->pools);
|
|
r->mixes = calloc((size_t)p->submix_count + 1, sizeof *r->mixes);
|
|
r->sinks = calloc((size_t)p->sink_count, sizeof *r->sinks);
|
|
r->effects = calloc((size_t)(p->effect_count ? p->effect_count : 1), sizeof *r->effects);
|
|
r->channels = calloc((size_t)p->voice_count * 6, sizeof *r->channels);
|
|
need(r->voices && r->pools && r->mixes && r->sinks && r->effects && r->channels, "renderer tables");
|
|
plat_mutex_init(&r->lock);
|
|
r->event = kern_event_new();
|
|
r->state = 1; // stopped
|
|
return r;
|
|
}
|
|
|
|
static void renderer_free(AudioRenderer *r) {
|
|
free(r->voices);
|
|
free(r->pools);
|
|
free(r->mixes);
|
|
free(r->sinks);
|
|
free(r->effects);
|
|
free(r->channels);
|
|
free(r);
|
|
}
|
|
|
|
// ---- RequestUpdate
|
|
typedef struct { const uint8_t *p, *end; } Reader;
|
|
|
|
static const uint8_t *take(Reader *in, uint32_t n, const char *what) {
|
|
if ((size_t)(in->end - in->p) < n) {
|
|
rt_log("audren: input section %s (%u bytes) overruns the request", what, n);
|
|
need(0, "update input section size");
|
|
}
|
|
const uint8_t *p = in->p;
|
|
in->p += n;
|
|
return p;
|
|
}
|
|
|
|
static void voice_reset(ServerVoice *v) {
|
|
memset(v->valid, 0, sizeof v->valid);
|
|
memset(v->pending, 0, sizeof v->pending);
|
|
v->state = SV_STOPPED;
|
|
v->flush = v->flush_from = 0;
|
|
v->index = 0;
|
|
v->offset = 0;
|
|
v->fraction = 0;
|
|
v->played = 0;
|
|
v->consumed = 0;
|
|
v->loops_done = 0;
|
|
memset(&v->adpcm, 0, sizeof v->adpcm);
|
|
memset(v->biquad_state, 0, sizeof v->biquad_state);
|
|
}
|
|
|
|
static void update_voice(AudioRenderer *r, const AudrenVoiceIn *in) {
|
|
need(in->id < (uint32_t)r->param.voice_count, "voice id out of range");
|
|
ServerVoice *v = &r->voices[in->id];
|
|
if (in->is_new || !in->in_use) voice_reset(v);
|
|
v->in = *in;
|
|
v->use_float_biquads = 0;
|
|
if (!in->in_use) return;
|
|
need(in->wave_buffer_index < 4, "wave buffer index");
|
|
// The play state as the DSP keeps it: Stop on a voice that is not stopped
|
|
// becomes Stopping, which the next render frame turns into Stopped after giving back every queued buffer.
|
|
if (in->play_state == PLAY_STARTED) v->state = SV_STARTED;
|
|
else if (in->play_state == PLAY_PAUSED) v->state = SV_PAUSED;
|
|
else if (v->state != SV_STOPPED) v->state = SV_STOPPING;
|
|
for (unsigned i = 0; i < 4; i++) { // a new buffer waits until a render frame finds the voice playing
|
|
const AudrenWaveBuffer *w = &in->wave_buffers[i];
|
|
if (!w->sent) {
|
|
v->buffers[i] = *w;
|
|
v->pending[i] = 1;
|
|
}
|
|
}
|
|
v->flush += in->flush_wave_buffer_count;
|
|
v->flush_from = in->wave_buffer_index;
|
|
if (in->clear_voice_drop) v->drops = 0;
|
|
}
|
|
|
|
// No samples (no memory, no size or an empty range): the DSP counts the buffer as played when it reaches it, so a
|
|
// stream's empty last buffer does not hold up the buffers queued behind it.
|
|
int audio_buffer_empty(const AudrenWaveBuffer *b) { return !b->address || !b->size || b->end <= b->start; }
|
|
|
|
static void skip_empty(AudioRenderer *r, ServerVoice *v) {
|
|
while (v->valid[v->index] && audio_buffer_empty(&v->buffers[v->index])) {
|
|
const AudrenWaveBuffer *b = &v->buffers[v->index];
|
|
if (b->loop && b->loop_count < 0) break; // an endless empty loop starves the voice, as on the DSP
|
|
v->valid[v->index] = 0;
|
|
v->consumed++;
|
|
v->offset = 0;
|
|
v->loops_done = 0;
|
|
v->index = (v->index + 1) & 3;
|
|
r->empty_played++;
|
|
if (b->end_of_stream) {
|
|
v->played = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Each render frame, before mixing: flush, stop, start.
|
|
static void voices_prepare(AudioRenderer *r) {
|
|
for (int k = 0; k < r->param.voice_count; k++) {
|
|
ServerVoice *v = &r->voices[k];
|
|
if (!v->in.in_use) continue;
|
|
if (v->flush) { // FlushWaveBuffers: from the client's current buffer, the queued ones count as played
|
|
unsigned i = v->flush_from & 3;
|
|
for (uint32_t n = v->flush; n; n--, i = (i + 1) & 3) {
|
|
v->pending[i] = 0;
|
|
if (v->valid[i]) {
|
|
v->valid[i] = 0;
|
|
v->consumed++;
|
|
v->index = (v->index + 1) & 3;
|
|
v->offset = 0;
|
|
v->loops_done = 0;
|
|
r->flushed++;
|
|
}
|
|
}
|
|
v->flush = 0;
|
|
}
|
|
if (v->state == SV_STOPPING) { // every queued buffer counts as played; unsent ones are dropped
|
|
for (int i = 0; i < 4; i++) {
|
|
if (v->valid[i]) {
|
|
v->consumed++;
|
|
v->index = (v->index + 1) & 3;
|
|
r->stop_released++;
|
|
}
|
|
v->valid[i] = 0;
|
|
v->pending[i] = 0;
|
|
}
|
|
v->offset = 0;
|
|
v->played = 0;
|
|
v->fraction = 0;
|
|
v->loops_done = 0;
|
|
v->state = SV_STOPPED;
|
|
continue;
|
|
}
|
|
if (v->state == SV_STARTED) {
|
|
for (int i = 0; i < 4; i++)
|
|
if (v->pending[i]) {
|
|
v->pending[i] = 0;
|
|
v->valid[i] = 1;
|
|
if ((unsigned)i == v->index) {
|
|
v->offset = 0;
|
|
v->loops_done = 0;
|
|
}
|
|
}
|
|
skip_empty(r, v);
|
|
}
|
|
}
|
|
}
|
|
|
|
static uint32_t effect_out_bytes(const AudioRenderer *r) { return revision_number(r->revision) >= 9 ? 0x90u : 0x10u; }
|
|
|
|
static void request_update(AudioRenderer *r, const uint8_t *input, uint64_t in_size, uint8_t *output,
|
|
uint64_t out_size, uint64_t perf_size) {
|
|
need(in_size >= sizeof(AudrenHeader), "update input too small");
|
|
AudrenHeader h;
|
|
memcpy(&h, input, sizeof h);
|
|
need(h.total <= in_size, "update total size");
|
|
Reader in = {input + sizeof h, input + h.total};
|
|
plat_mutex_lock(&r->lock);
|
|
r->revision = h.revision;
|
|
const int vc = r->param.voice_count, ec = r->param.effect_count, sc = r->param.sink_count,
|
|
mc = r->param.submix_count + 1;
|
|
const uint32_t npools = (uint32_t)ec + 4u * (uint32_t)vc;
|
|
if (!r->logged) {
|
|
r->logged = 1;
|
|
rt_log("audren: update REV%d sizes behavior=%u pools=%u voices=%u channels=%u effects=%u mixes=%u sinks=%u "
|
|
"perf=%u splitters=%u render=%u total=%u out=%llu perf_out=%llu",
|
|
revision_number(h.revision), h.behavior, h.memory_pools, h.voices, h.voice_resources, h.effects,
|
|
h.mixes, h.sinks, h.performance, h.splitters, h.render_info, h.total, (unsigned long long)out_size,
|
|
(unsigned long long)perf_size);
|
|
}
|
|
need(h.behavior == 0x10, "behavior section size");
|
|
const uint8_t *behavior = take(&in, h.behavior, "behavior");
|
|
memcpy(&r->behavior_flags, behavior + 8, 8);
|
|
need(h.memory_pools == npools * sizeof(AudrenPoolIn), "memory pool section size");
|
|
const AudrenPoolIn *pools = (const AudrenPoolIn *)take(&in, h.memory_pools, "memory pools");
|
|
need(h.voice_resources % sizeof(AudrenChannelIn) == 0 &&
|
|
h.voice_resources / sizeof(AudrenChannelIn) <= (uint32_t)vc * 6,
|
|
"voice channel section size");
|
|
const AudrenChannelIn *chans = (const AudrenChannelIn *)take(&in, h.voice_resources, "voice channels");
|
|
const int float_voices = revision_number(h.revision) >= 15;
|
|
const size_t voice_stride = float_voices ? sizeof(AudrenVoiceInV2) : sizeof(AudrenVoiceIn);
|
|
need(h.voices == (uint32_t)vc * voice_stride, "voice section size");
|
|
const uint8_t *voices = take(&in, h.voices, "voices");
|
|
need(h.effects == (uint32_t)ec * sizeof(AudrenEffectIn), "effect section size");
|
|
const AudrenEffectIn *effects = (const AudrenEffectIn *)take(&in, h.effects, "effects");
|
|
const uint8_t *splitters = take(&in, h.splitters, "splitters");
|
|
const uint8_t *mixes = take(&in, h.mixes, "mixes");
|
|
need(h.sinks == (uint32_t)sc * sizeof(AudrenSinkIn), "sink section size");
|
|
const AudrenSinkIn *sinks = (const AudrenSinkIn *)take(&in, h.sinks, "sinks");
|
|
take(&in, h.performance, "performance");
|
|
take(&in, h.render_info, "render info");
|
|
need(in.p == in.end, "unconsumed update input");
|
|
|
|
for (uint32_t i = 0; i < h.voice_resources / sizeof(AudrenChannelIn); i++) {
|
|
need(chans[i].id < (uint32_t)vc * 6, "channel resource id");
|
|
r->channels[chans[i].id] = chans[i];
|
|
}
|
|
for (int i = 0; i < vc; i++) {
|
|
AudrenVoiceIn v;
|
|
AudrenVoiceInV2 v2;
|
|
if (float_voices) {
|
|
memcpy(&v2, voices + i * voice_stride, sizeof v2);
|
|
memset(&v, 0, sizeof v);
|
|
memcpy(&v, v2.prefix, sizeof v2.prefix);
|
|
memcpy((uint8_t *)&v + 0x3c, v2.tail, sizeof v2.tail);
|
|
for (unsigned f = 0; f < 2; f++) {
|
|
v.biquads[f].enable = v2.biquads[f].enable;
|
|
if (!v.biquads[f].enable) continue;
|
|
for (unsigned c = 0; c < 3; c++) need(isfinite(v2.biquads[f].numerator[c]), "voice biquad numerator");
|
|
for (unsigned c = 0; c < 2; c++)
|
|
need(isfinite(v2.biquads[f].denominator[c]), "voice biquad denominator");
|
|
}
|
|
} else
|
|
memcpy(&v, voices + i * voice_stride, sizeof v);
|
|
update_voice(r, &v);
|
|
ServerVoice *server = &r->voices[v.id];
|
|
server->use_float_biquads = (uint8_t)float_voices;
|
|
if (float_voices) memcpy(server->float_biquads, v2.biquads, sizeof v2.biquads);
|
|
}
|
|
for (int i = 0; i < ec; i++) r->effects[i] = effects[i];
|
|
audio_mixer_update_effects(r);
|
|
audio_mixer_update_routing(r, splitters, h.splitters, mixes, h.mixes, mc);
|
|
for (int i = 0; i < sc; i++) r->sinks[i] = sinks[i];
|
|
|
|
// ---- output
|
|
const uint32_t eo = effect_out_bytes(r);
|
|
AudrenHeader o = {0};
|
|
o.revision = AUDREN_REV(revision_number(h.revision) >= 1 ? revision_number(h.revision) : 1);
|
|
o.memory_pools = npools * sizeof(AudrenPoolOut);
|
|
o.voices = (uint32_t)vc * sizeof(AudrenVoiceOut);
|
|
o.effects = (uint32_t)ec * eo;
|
|
o.sinks = (uint32_t)sc * sizeof(AudrenSinkOut);
|
|
o.performance = 0x10;
|
|
o.behavior = AUDREN_BEHAVIOR_OUT;
|
|
o.render_info = AUDREN_RENDER_INFO_OUT;
|
|
o.total = (uint32_t)sizeof o + o.memory_pools + o.voices + o.effects + o.sinks + o.performance + o.behavior +
|
|
o.render_info;
|
|
if (o.total > out_size) {
|
|
rt_log("audren: output needs %u bytes, the client gave %llu (effect out %u)", o.total,
|
|
(unsigned long long)out_size, eo);
|
|
need(0, "update output size");
|
|
}
|
|
memset(output, 0, out_size);
|
|
uint8_t *w = output;
|
|
memcpy(w, &o, sizeof o);
|
|
w += sizeof o;
|
|
for (uint32_t i = 0; i < npools; i++) {
|
|
uint32_t s = pools[i].state;
|
|
if (s == POOL_REQUEST_ATTACH) s = POOL_ATTACHED;
|
|
else if (s == POOL_REQUEST_DETACH) s = POOL_DETACHED;
|
|
r->pools[i] = pools[i];
|
|
r->pools[i].state = s;
|
|
AudrenPoolOut po = {s, {0}};
|
|
memcpy(w, &po, sizeof po);
|
|
w += sizeof po;
|
|
}
|
|
for (int i = 0; i < vc; i++) {
|
|
AudrenVoiceOut vo = {r->voices[i].played, r->voices[i].consumed, r->voices[i].drops};
|
|
memcpy(w, &vo, sizeof vo);
|
|
w += sizeof vo;
|
|
}
|
|
for (int i = 0; i < ec; i++) { // EffectStatus Enabled 3 / Disabled 4
|
|
w[0] = effects[i].enabled ? 3 : 4;
|
|
if (eo > 16) audio_mixer_effect_result(r, i, w + 16, eo - 16);
|
|
w += eo;
|
|
}
|
|
for (int i = 0; i < sc; i++) {
|
|
AudrenSinkOut so = {0};
|
|
if (r->sinks[i].type == SINK_CIRCULAR) so.last_written_offset = audio_mixer_sink_written(r, i);
|
|
memcpy(w, &so, sizeof so);
|
|
w += sizeof so;
|
|
}
|
|
w += 0x10; // performance: nothing written
|
|
w += AUDREN_BEHAVIOR_OUT; // behavior: no errors
|
|
memcpy(w, &r->elapsed_frames, 8);
|
|
plat_mutex_unlock(&r->lock);
|
|
}
|
|
|
|
// ---- render tick: one frame each time the output device has taken the ring below its target (audio_mixer_pace_ns),
|
|
// or every sample_count / sample_rate seconds of the host clock without a device, while stopped or while it stalls
|
|
static void advance_voice(AudioRenderer *r, ServerVoice *v) {
|
|
if (!v->in.in_use || v->state != SV_STARTED || !v->in.sample_rate) return;
|
|
uint64_t samples = audio_voice_consumed(r, v, (int)r->param.sample_count);
|
|
while (samples && v->valid[v->index]) {
|
|
AudrenWaveBuffer *b = &v->buffers[v->index];
|
|
if (audio_buffer_empty(b)) break; // an endless empty loop skip_empty kept: it starves the voice, and its
|
|
// zero length would make the loop below go round for good
|
|
uint64_t length = (uint64_t)(b->end - b->start), left = length - v->offset;
|
|
uint64_t step = samples < left ? samples : left;
|
|
v->offset += step;
|
|
v->played += step;
|
|
samples -= step;
|
|
if (v->offset < length) break;
|
|
if (b->loop && (b->loop_count < 0 || v->loops_done < b->loop_count)) {
|
|
v->loops_done++;
|
|
v->offset = b->loop_start > b->start && b->loop_start < b->end ? (uint64_t)(b->loop_start - b->start) : 0;
|
|
continue;
|
|
}
|
|
v->valid[v->index] = 0;
|
|
v->consumed++;
|
|
v->offset = 0;
|
|
v->loops_done = 0;
|
|
v->index = (v->index + 1) & 3;
|
|
if (b->end_of_stream) {
|
|
v->played = 0;
|
|
break;
|
|
}
|
|
skip_empty(r, v);
|
|
}
|
|
}
|
|
|
|
static void render_thread(void *p) {
|
|
AudioRenderer *r = p;
|
|
plat_thread_priority(PLAT_PRIO_HIGHEST);
|
|
const uint64_t frame_ns = (uint64_t)r->param.sample_count * 1000000000ull / (uint64_t)r->param.sample_rate;
|
|
const double frame = (double)r->param.sample_count / r->param.sample_rate;
|
|
// When the device pulls a period (1024 samples on PipeWire, 4-5 frames) the ring drops below its target
|
|
// and the frames would otherwise render back to back. On hardware the DSP renders one frame every 5 ms and
|
|
// the game's audio thread works in between; AUX effects need that time to fill the return ring, or mix_aux
|
|
// reads stale samples and the frame clicks at its seams. Device-paced frames stay at least 4/5 of a frame
|
|
// apart, which still refills a period well before the device drains it. Linux only: on Windows SDL pulls
|
|
// 480-sample periods, and a sink dump (NX2NAVI_AUDIO_DUMP) of the bursts there showed no more seam spikes than
|
|
// chance, so a wait on this thread buys nothing.
|
|
#ifdef __linux__
|
|
const uint64_t gap_ns = frame_ns * 4 / 5;
|
|
#else
|
|
const uint64_t gap_ns = 0;
|
|
#endif
|
|
uint64_t next = kern_now_ns(), last = 0;
|
|
while (plat_cas32(&r->running, 0, 0)) {
|
|
uint64_t now = kern_now_ns();
|
|
int64_t pace = audio_mixer_pace_ns(r, now);
|
|
if (pace > 0) {
|
|
plat_wait_ns((uint64_t)pace);
|
|
continue;
|
|
}
|
|
if (pace == 0 && last && now - last < gap_ns) {
|
|
plat_wait_ns(gap_ns - (now - last));
|
|
continue;
|
|
}
|
|
if (pace == 0) {
|
|
next = now + frame_ns; // where the timer goes on if the device stops pacing
|
|
} else {
|
|
if (next > now) plat_wait_ns(next - now);
|
|
else if (now - next > 100000000ull) next = now; // fell far behind (debugger, sleep): resynchronise
|
|
next += frame_ns;
|
|
}
|
|
last = kern_now_ns();
|
|
plat_mutex_lock(&r->lock);
|
|
if (r->state == 0) {
|
|
voices_prepare(r);
|
|
audio_mixer_render(r, frame);
|
|
for (int i = 0; i < r->param.voice_count; i++) advance_voice(r, &r->voices[i]);
|
|
r->elapsed_frames++;
|
|
uint64_t given = r->stop_released + r->empty_played + r->flushed;
|
|
if ((rt_trace & RT_TRACE_IPC) && given != r->logged_released && r->elapsed_frames % 1000 == 0) {
|
|
r->logged_released = given;
|
|
rt_log("audren: wave buffers given back: %llu by stopped voices, %llu without samples, %llu flushed",
|
|
(unsigned long long)r->stop_released, (unsigned long long)r->empty_played,
|
|
(unsigned long long)r->flushed);
|
|
}
|
|
}
|
|
plat_mutex_unlock(&r->lock);
|
|
kern_event_signal(r->event);
|
|
}
|
|
}
|
|
|
|
// ---- IAudioRenderer
|
|
static IpcBuffer pick(const IpcBuffer *a, unsigned na, const IpcBuffer *b, unsigned nb, unsigned i) {
|
|
IpcBuffer x = i < na ? a[i] : (IpcBuffer){0}, y = i < nb ? b[i] : (IpcBuffer){0};
|
|
return x.size ? x : y;
|
|
}
|
|
|
|
static uint32_t voice_drop_bits = 0x3f800000u; // SetVoiceDropParameter's float (1.0 until set)
|
|
|
|
static void renderer_handler(IpcSession *s, const IpcRequest *rq, IpcResponse *rs) {
|
|
AudioRenderer *r = s->state;
|
|
switch (rq->cmd) {
|
|
case 0: { int32_t v = r->param.sample_rate; IPC_OUT(rs, v); return; } // GetSampleRate
|
|
case 1: { int32_t v = r->param.sample_count; IPC_OUT(rs, v); return; } // GetSampleCount
|
|
case 2: { int32_t v = r->param.mix_buffer_count; IPC_OUT(rs, v); return; } // GetMixBufferCount
|
|
case 3: { uint32_t v = r->state; IPC_OUT(rs, v); return; } // GetState
|
|
case 4: case 10: { // RequestUpdate(Auto): out(output), out(performance), in(input)
|
|
IpcBuffer in = pick(rq->a, rq->na, rq->x, rq->nx, 0);
|
|
IpcBuffer out = pick(rq->b, rq->nb, rq->c, rq->nc, 0), perf = pick(rq->b, rq->nb, rq->c, rq->nc, 1);
|
|
if (!r->logged)
|
|
rt_log("audren: RequestUpdate cmd %u in=%#llx+%#llx out=%#llx+%#llx perf=%#llx+%#llx (a%u b%u x%u c%u)",
|
|
rq->cmd, (unsigned long long)in.addr, (unsigned long long)in.size, (unsigned long long)out.addr,
|
|
(unsigned long long)out.size, (unsigned long long)perf.addr, (unsigned long long)perf.size, rq->na,
|
|
rq->nb, rq->nx, rq->nc);
|
|
need(in.size && out.size, "RequestUpdate buffers");
|
|
request_update(r, ipc_guest(in.addr, in.size), in.size, ipc_guest(out.addr, out.size), out.size, perf.size);
|
|
for (unsigned i = 0; i < rq->nc && rq->cmd == 10; i++)
|
|
if (rq->c[i].size && (i >= rq->nb || !rq->b[i].size))
|
|
rs->xout[rs->nxout++] = (IpcBuffer){rq->c[i].addr, rq->c[i].size, i};
|
|
return;
|
|
}
|
|
case 5: // Start
|
|
plat_mutex_lock(&r->lock);
|
|
r->state = 0;
|
|
audio_mixer_set_running(r, 1);
|
|
plat_mutex_unlock(&r->lock);
|
|
return;
|
|
case 6: // Stop
|
|
plat_mutex_lock(&r->lock);
|
|
r->state = 1;
|
|
audio_mixer_set_running(r, 0);
|
|
plat_mutex_unlock(&r->lock);
|
|
return;
|
|
case 7: rs->copy[rs->ncopy++] = kern_event_readable(r->event); return; // QuerySystemEvent
|
|
case 8: r->time_limit = IPC_ARG(rq, uint32_t, 0); return; // SetRenderingTimeLimit
|
|
case 9: { uint32_t v = r->time_limit ? r->time_limit : 100; IPC_OUT(rs, v); return; } // GetRenderingTimeLimit
|
|
// 15.0.0+ Set/GetVoiceDropParameter (the system's audio renderer service): the factor the DSP uses to drop
|
|
// voices when a frame overruns its time. The host mixer renders every voice, so the value is only kept.
|
|
case 12: {
|
|
float v = IPC_ARG(rq, float, 0);
|
|
__atomic_store_n(&voice_drop_bits, isfinite(v) ? *(uint32_t *)&v : 0x3f800000u, __ATOMIC_RELAXED);
|
|
return;
|
|
}
|
|
case 13: {
|
|
uint32_t bits = __atomic_load_n(&voice_drop_bits, __ATOMIC_RELAXED);
|
|
float v;
|
|
memcpy(&v, &bits, sizeof v);
|
|
IPC_OUT(rs, v);
|
|
return;
|
|
}
|
|
default: ipc_unimplemented(s, rq);
|
|
}
|
|
}
|
|
|
|
static void renderer_close(void *p) {
|
|
AudioRenderer *r = p;
|
|
plat_xchg32(&r->running, 0);
|
|
int away = kern_core_away();
|
|
plat_thread_join(r->thread);
|
|
kern_core_back(&away);
|
|
plat_dec32(&g_live);
|
|
audio_mixer_close(r);
|
|
kern_handle_close(r->event);
|
|
rt_log("audren: renderer closed after %llu frames", (unsigned long long)r->elapsed_frames);
|
|
renderer_free(r);
|
|
}
|
|
|
|
// ---- IAudioRendererManager
|
|
void audren_manager_handler(IpcSession *s, const IpcRequest *rq, IpcResponse *rs) {
|
|
switch (rq->cmd) {
|
|
case 0: { // OpenAudioRenderer(param, pad, work size, aruid; copy tmem, process; pid)
|
|
AudrenParameter p = IPC_ARG(rq, AudrenParameter, 0);
|
|
uint64_t work = IPC_ARG(rq, uint64_t, 0x38);
|
|
need(rq->ncopy >= 1, "OpenAudioRenderer without a transfer memory handle");
|
|
IpcTransferMemory *tm = kern_handle_get(rq->copy[0], KERN_TMEM);
|
|
need(tm && tm->size >= work, "OpenAudioRenderer work buffer is not a transfer memory of the stated size");
|
|
AudioRenderer *r = renderer_new(&p);
|
|
r->running = 1;
|
|
audio_mixer_open(r);
|
|
r->thread = plat_thread_new(render_thread, r, "audren");
|
|
if (!r->thread) rt_fatal("audren: cannot start the render thread");
|
|
plat_inc32(&g_live);
|
|
rt_log("audren: renderer open %d Hz x%d, mix buffers %d, voices %d, effects %d, submixes %d, sinks %d, "
|
|
"splitters %d/%d, REV%d, work buffer %#llx+%#llx",
|
|
p.sample_rate, p.sample_count, p.mix_buffer_count, p.voice_count, p.effect_count, p.submix_count,
|
|
p.sink_count, p.splitter_count, p.splitter_destination_count, revision_number(p.revision),
|
|
(unsigned long long)tm->addr, (unsigned long long)work);
|
|
rs->move[rs->nmove++] = ipc_session_new("IAudioRenderer", renderer_handler, r, renderer_close);
|
|
return;
|
|
}
|
|
case 1: { // GetWorkBufferSize(param) -> u64
|
|
AudrenParameter p = IPC_ARG(rq, AudrenParameter, 0);
|
|
need(p.sample_rate == 48000 || p.sample_rate == 32000, "GetWorkBufferSize: unsupported output rate");
|
|
uint64_t v = AUDREN_WORK_BUFFER_BYTES;
|
|
IPC_OUT(rs, v);
|
|
return;
|
|
}
|
|
case 2: case 4: // GetAudioDeviceService(aruid), GetAudioDeviceServiceWithRevisionInfo(revision, aruid)
|
|
rs->move[rs->nmove++] = ipc_session_new("IAudioDevice", audio_device_handler, NULL, NULL);
|
|
return;
|
|
default: ipc_unimplemented(s, rq);
|
|
}
|
|
}
|