Mirrors/totk-pc-recomp
1
0 Fork 0
mirror of https://github.com/valentderah/totk-pc-recomp.git synced 2026-11-11 01:41:02 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
totk-pc-recomp/runtime/audren.c
T

502 lines
23 KiB
C
Raw Permalink Blame History

// Adapted from MacNativeGames games/totk/runtime/audio_renderer.c @ b75be8c (MIT, Copyright (c) 2026
// MacNativeGames contributors). Its voice lifetime (play state, wave buffer release, flush) is ported from
// Ryujinx.Audio VoiceInfo / DataSourceHelper (MIT, Copyright (c) Ryujinx Team and Contributors).
// 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 (Ryujinx VoiceInfo.UpdatePlayState): 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 (Ryujinx VoiceInfo.UpdateParametersForCommandGeneration): 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];
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 (TOTK_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 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
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);
}
}
Reference in new issue View Git Blame Copy Permalink