2 Commits
Author SHA1 Message Date
YourWishesandClaude Sonnet 5 ac8023d50f Rework PSP audio into a single output thread + main-thread top-up
The reader+player two-thread design (previous commit) still crackled -
both threads shared the same elevated real-time priority and could
contend for the PSP's single core right at the moment the player thread
needed to resume after its blocking output call returned, worse the
bigger the hardware chunk. Confirmed fixed on real hardware (Memory Stick
and pspsh) by removing the second real-time thread entirely.

PCM data now lives in a ring buffer topped up from the MAIN thread once
per engine Update(), mirroring dusklinux's own already-working
audioStreamLinuxFeed()/IsFinished() pattern (same lead/window sizing)
instead of a bespoke second thread. The sole remaining PSP-specific
thread only drains the ring and calls sceAudioOutputPannedBlocking(),
never touching the asset/PCM layer. Loop wraps are now just a transparent
seek-and-continue while filling the ring (it holds one seamless sample
stream, no per-chunk splicing needed) - a small FIFO of loop markers is
the only thing still needed to fire onLoop at the correct audible moment.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
2026-08-31 20:09:15 -05:00
YourWishesandClaude Sonnet 5 769f2f5702 Split PSP audio feeder into reader + player threads to fix crackle
sceAudioOutputPannedBlocking() occupies the calling thread for the full
duration of the chunk it just submitted. That was fine while PCM chunks
came out of a fully-resident buffer (a near-instant memcpy), but now that
they're read from the asset on demand, that same read happens in between
output calls on the same thread - any read slower than a memcpy opens a
real gap in the hardware channel, heard as crackle.

Split the single feeder thread in two: a reader thread that does all PCM
I/O (seek/read, loop-wrap, fade prep) ahead of playback into a small
3-slot queue, and a player thread that only pulls ready chunks off the
queue and outputs them. This overlaps I/O with hardware playback instead
of serializing them.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
2026-08-31 19:38:50 -05:00
2 changed files with 367 additions and 164 deletions

No files matched your search

+232 -134
View File
@@ -15,14 +15,15 @@
// Matches pspaudiolib's own PSP_NUM_AUDIO_SAMPLES convention - PSP audio
// hardware is meant to be fed small chunks continuously, not one large
// buffer per call.
// buffer per call. This is purely an output granularity now - see
// audioStreamPSPTopUp() for how much it reads per call.
#define AUDIO_PSP_CHUNK_FRAMES 1024
// PSP priorities are inverted (lower = higher priority). This project's
// main thread runs at the PSPSDK default of 32 (PSP_MAIN_THREAD_PRIORITY
// is never overridden). A pthread created with default attributes runs at
// 60 - LOWER priority than the main/render thread - so under load the
// feeder thread starves and the hardware channel underruns, heard as
// output thread would starve and the hardware channel underruns, heard as
// jitter/crackle that gets worse the busier (lower-fps) a frame is. Raise
// it above main so audio feeding always wins scheduling contention.
#define AUDIO_PSP_THREAD_PRIORITY 18
@@ -33,10 +34,9 @@
// just stopping outright on an exact-multiple-length one).
#define AUDIO_PSP_FADE_FRAMES 32
// How long the persistent feeder thread sleeps between checks for a new
// play request while idle. Cheap compared to spawning a whole new OS
// thread per play (what this replaced) - worst case this is the latency
// added between one playback pass finishing and the next one starting.
// How long the persistent output thread sleeps between checks - both for
// a new play request while idle, and for the ring buffer to have a full
// chunk ready while active.
#define AUDIO_PSP_IDLE_POLL_MICROS 500
errorret_t audioStreamPSPInit(audiostream_t *stream) {
@@ -73,6 +73,13 @@ errorret_t audioStreamPSPInit(audiostream_t *stream) {
stream->platform.channel = channel;
stream->platform.finished = false;
stream->platform.playRequested = false;
const size_t ringSize =
AUDIO_PSP_RING_FRAMES * stream->pcm.channels * sizeof(int16_t);
stream->platform.ring = memoryAllocate(ringSize);
stream->platform.scratch = memoryAllocate(ringSize);
threadMutexInit(&stream->platform.ringLock);
threadInit(&stream->platform.thread, audioStreamPSPThreadFeed);
stream->platform.thread.data = stream;
threadStartRequest(&stream->platform.thread);
@@ -86,6 +93,12 @@ errorret_t audioStreamPSPDispose(audiostream_t *stream) {
threadStop(&stream->platform.thread);
sceAudioChRelease(stream->platform.channel);
memoryFree(stream->platform.ring);
stream->platform.ring = NULL;
memoryFree(stream->platform.scratch);
stream->platform.scratch = NULL;
threadMutexDispose(&stream->platform.ringLock);
errorOk();
}
@@ -93,17 +106,149 @@ errorret_t audioStreamPSPBuffer(audiostream_t *stream) {
assertNotNull(stream, "Stream cannot be NULL.");
stream->platform.finished = false;
stream->platform.startFrame = stream->startFrame;
stream->platform.readReachedEnd = false;
stream->platform.readFailed = false;
stream->platform.totalFrames = audioStreamPcmGetTotalFrames(stream);
// loopEndFrame/loopToFrame define the loop segment [loopToFrame,
// loopEndFrame) that a looping pass wraps within, once it's reached -
// defaulting to the whole clip (loopStart == -1, loopTo == 0) so
// behaviour is unchanged when no explicit loop points are configured.
stream->platform.loopEndFrame = stream->loopStart >= 0
? mathMin(
(size_t) (stream->loopStart * stream->pcm.sampleRate),
stream->platform.totalFrames
)
: stream->platform.totalFrames;
stream->platform.loopToFrame = mathMin(
(size_t) (stream->loopTo * stream->pcm.sampleRate),
stream->platform.loopEndFrame
);
const size_t startFrame = mathMin(stream->startFrame, stream->platform.totalFrames);
stream->startFrame = 0;
stream->seeking = false;
errorChain(audioStreamPcmSeek(stream, startFrame));
stream->platform.readPosition = startFrame;
threadMutexLock(&stream->platform.ringLock);
stream->platform.ringReadPos = 0;
stream->platform.ringWritePos = 0;
stream->platform.ringFilled = 0;
stream->platform.framesEnqueued = 0;
stream->platform.loopMarkerHead = 0;
stream->platform.loopMarkerCount = 0;
threadMutexUnlock(&stream->platform.ringLock);
stream->platform.framesOutput = 0;
stream->platform.playRequested = true;
errorOk();
}
void audioStreamPSPTopUp(audiostream_t *stream) {
assertNotNull(stream, "Stream cannot be NULL.");
if(stream->platform.readReachedEnd || stream->platform.readFailed) return;
threadMutexLock(&stream->platform.ringLock);
const size_t filled = stream->platform.ringFilled;
threadMutexUnlock(&stream->platform.ringLock);
if(filled >= AUDIO_PSP_LEAD_FRAMES) return;
const size_t channels = stream->pcm.channels;
const size_t frameSize = channels * sizeof(int16_t);
// Fill however much room the ring actually has in this one call, not
// just a small fixed step - otherwise a temporary engine frame-rate dip
// (below roughly one hardware chunk's worth of playback time per frame)
// would let production permanently fall behind consumption, since a
// fixed-size top-up per call can never make up lost ground. Bounded by
// the ring's own physical capacity, and by loopEndFrame (the loop
// segment's end) - except a seek can legitimately land past it (e.g.
// into an outro after the loop point), in which case read out to the
// true end of the clip once instead of underflowing
// framesRemainingInSegment.
const size_t room = AUDIO_PSP_RING_FRAMES - filled;
const size_t currentEndFrame = stream->platform.readPosition < stream->platform.loopEndFrame
? stream->platform.loopEndFrame
: stream->platform.totalFrames;
const size_t framesRemainingInSegment = currentEndFrame - stream->platform.readPosition;
const size_t framesToRead = mathMin(room, framesRemainingInSegment);
const bool_t reachesSegmentEnd = framesToRead == framesRemainingInSegment;
const bool_t willLoop = reachesSegmentEnd &&
(stream->state & AUDIO_STREAM_STATE_LOOPING);
if(framesToRead > 0) {
int16_t *scratch = stream->platform.scratch;
size_t framesRead = 0;
if(errorIsNotOk(
audioStreamPcmRead(stream, scratch, framesToRead, &framesRead)
)) {
stream->platform.readFailed = true;
return;
}
if(framesRead < framesToRead) {
// The asset is shorter than its declared header size (corrupt or
// truncated) - pad what's missing with silence.
memoryZero(
scratch + (framesRead * channels), (framesToRead - framesRead) * frameSize
);
}
threadMutexLock(&stream->platform.ringLock);
for(size_t i = 0; i < framesToRead; i++) {
const size_t writeIndex = (stream->platform.ringWritePos + i) % AUDIO_PSP_RING_FRAMES;
memoryCopy(
stream->platform.ring + (writeIndex * channels),
scratch + (i * channels),
frameSize
);
}
stream->platform.ringWritePos =
(stream->platform.ringWritePos + framesToRead) % AUDIO_PSP_RING_FRAMES;
stream->platform.ringFilled += framesToRead;
stream->platform.framesEnqueued += framesToRead;
threadMutexUnlock(&stream->platform.ringLock);
stream->platform.readPosition += framesToRead;
}
if(reachesSegmentEnd) {
if(willLoop) {
if(errorIsNotOk(audioStreamPcmSeek(stream, stream->platform.loopToFrame))) {
stream->platform.readFailed = true;
return;
}
stream->platform.readPosition = stream->platform.loopToFrame;
threadMutexLock(&stream->platform.ringLock);
if(stream->platform.loopMarkerCount < AUDIO_PSP_LOOP_MARKER_MAX) {
const size_t index = (
stream->platform.loopMarkerHead + stream->platform.loopMarkerCount
) % AUDIO_PSP_LOOP_MARKER_MAX;
stream->platform.loopMarkerFrames[index] = stream->platform.framesEnqueued;
stream->platform.loopMarkerCount++;
}
threadMutexUnlock(&stream->platform.ringLock);
} else {
stream->platform.readReachedEnd = true;
}
}
}
bool_t audioStreamPSPIsFinished(audiostream_t *stream) {
assertNotNull(stream, "Stream cannot be NULL.");
// Only ever called while this stream is actively playing (see
// audioStreamUpdate()) - piggybacking the per-frame top-up here mirrors
// dusklinux's own audioStreamLinuxIsFinished()/audioStreamLinuxFeed()
// pattern, rather than needing a dedicated thread to do PCM I/O.
audioStreamPSPTopUp(stream);
return stream->platform.finished;
}
@@ -115,8 +260,7 @@ void audioStreamPSPThreadFeed(thread_t *thread) {
audiostream_t *stream = (audiostream_t *) thread->data;
const size_t channels = stream->pcm.channels;
const size_t frameSize = channels * sizeof(int16_t);
const size_t chunkSize = AUDIO_PSP_CHUNK_FRAMES * frameSize;
int16_t *chunk = memoryAllocate(chunkSize);
int16_t *chunk = memoryAllocate(AUDIO_PSP_CHUNK_FRAMES * frameSize);
// Runs for the stream's whole lifetime - idles here between plays rather
// than exiting, so a loop restart (or any replay) is just a flag flip
@@ -128,129 +272,76 @@ void audioStreamPSPThreadFeed(thread_t *thread) {
}
stream->platform.playRequested = false;
const size_t totalFrames = audioStreamPcmGetTotalFrames(stream);
// loopEndFrame/loopToFrame define the loop segment [loopToFrame,
// loopEndFrame) that a looping pass wraps within, once it's reached -
// defaulting to the whole buffer (loopStart == -1, loopTo == 0) so
// behaviour is unchanged when no explicit loop points are configured.
const size_t loopEndFrame = stream->loopStart >= 0
? mathMin((size_t) (stream->loopStart * stream->pcm.sampleRate), totalFrames)
: totalFrames;
const size_t loopToFrame = mathMin(
(size_t) (stream->loopTo * stream->pcm.sampleRate), loopEndFrame
);
// Only the very first pass honors an explicit seek (audioStreamSetPosition,
// captured into platform.startFrame by audioStreamPSPBuffer()) - every
// subsequent loop wraps to loopToFrame instead.
size_t position = stream->platform.startFrame;
bool_t reachedEnd = false;
// Samples are read on demand from the asset (via audioStreamPcmRead(),
// sequentially, plus an explicit audioStreamPcmSeek() whenever jumping
// backward for a loop wrap) rather than indexed out of a fully
// resident buffer - a read/seek failure here (a corrupt or truncated
// asset, an I/O error) stops playback cleanly instead of crashing the
// thread on bad data.
bool_t readFailed = errorIsNotOk(audioStreamPcmSeek(stream, position));
// Every call always sends a full, constant-size AUDIO_PSP_CHUNK_FRAMES
// buffer - the channel is never re-declared to a different length, to
// avoid relying on sceAudioSetChannelDataLen's undocumented behavior
// mid-stream (the likely real cause of an earlier click). Loops
// internally (rather than going idle and waiting for the engine's
// once-per-frame Update() to notice finished and re-trigger Buffer())
// so a looping stream never has a detection-latency gap - the generic
// engine's finished+looping path is designed for platforms with no
// better option (see audiostream.c), but here the thread can just
// keep going and call onLoop itself instead.
while(!readFailed && !threadShouldStop(thread) && !reachedEnd) {
// Normally bounded by loopEndFrame (the loop segment's end), but a
// seek can legitimately land past it (e.g. into an outro after the
// loop point) - in that case play out to the true end of the buffer
// once instead of underflowing framesRemaining.
const size_t currentEndFrame = position < loopEndFrame
? loopEndFrame
: totalFrames;
const size_t framesRemaining = currentEndFrame - position;
const size_t framesThisChunk = framesRemaining < AUDIO_PSP_CHUNK_FRAMES
? framesRemaining
: AUDIO_PSP_CHUNK_FRAMES;
const bool_t reachesEndThisChunk = framesThisChunk == framesRemaining;
const bool_t willLoop = reachesEndThisChunk &&
(stream->state & AUDIO_STREAM_STATE_LOOPING);
// mid-stream. Loops internally (rather than going idle and waiting for
// the engine's once-per-frame Update() to notice finished and
// re-trigger Buffer()) so a looping stream never has a
// detection-latency gap.
while(!threadShouldStop(thread) && !reachedEnd) {
// Wait until either a full hardware chunk is ready in the ring, or
// the main thread has stopped producing (a genuine end or a read
// failure) and whatever's left (0..one chunk) is all there'll ever
// be - the pass's final, possibly-partial chunk.
size_t available = 0;
bool_t stopRequested = false;
for(;;) {
threadMutexLock(&stream->platform.ringLock);
available = stream->platform.ringFilled;
threadMutexUnlock(&stream->platform.ringLock);
size_t framesRead = 0;
if(errorIsNotOk(
audioStreamPcmRead(stream, chunk, framesThisChunk, &framesRead)
)) {
readFailed = true;
break;
if(available >= AUDIO_PSP_CHUNK_FRAMES) break;
if(stream->platform.readReachedEnd || stream->platform.readFailed) break;
if(threadShouldStop(thread)) {
stopRequested = true;
break;
}
sceKernelDelayThread(AUDIO_PSP_IDLE_POLL_MICROS);
}
if(framesRead < framesThisChunk) {
// The asset is shorter than its declared header size (corrupt or
// truncated) - pad what's missing with silence rather than play
// whatever was left in `chunk` from a previous pass.
if(stopRequested) break;
// Production has stopped and what's left fits in one chunk (0 up to
// AUDIO_PSP_CHUNK_FRAMES - it can never be more, since production
// never adds more once readReachedEnd/readFailed is set) - this is
// the pass's last chunk.
const bool_t isFinalChunk =
(stream->platform.readReachedEnd || stream->platform.readFailed) &&
available <= AUDIO_PSP_CHUNK_FRAMES;
const size_t framesThisChunk = isFinalChunk
? available
: AUDIO_PSP_CHUNK_FRAMES;
threadMutexLock(&stream->platform.ringLock);
for(size_t i = 0; i < framesThisChunk; i++) {
const size_t readIndex = (stream->platform.ringReadPos + i) % AUDIO_PSP_RING_FRAMES;
memoryCopy(
chunk + (i * channels),
stream->platform.ring + (readIndex * channels),
frameSize
);
}
stream->platform.ringReadPos =
(stream->platform.ringReadPos + framesThisChunk) % AUDIO_PSP_RING_FRAMES;
stream->platform.ringFilled -= framesThisChunk;
threadMutexUnlock(&stream->platform.ringLock);
if(framesThisChunk < AUDIO_PSP_CHUNK_FRAMES) {
// True final chunk is shorter than a full hardware chunk - pad the
// rest with silence rather than play whatever was left in `chunk`
// from a previous pass.
memoryZero(
chunk + (framesRead * channels),
(framesThisChunk - framesRead) * frameSize
chunk + (framesThisChunk * channels),
(AUDIO_PSP_CHUNK_FRAMES - framesThisChunk) * frameSize
);
}
const size_t remainderFrames = AUDIO_PSP_CHUNK_FRAMES - framesThisChunk;
size_t wrapFrames = 0;
if(reachesEndThisChunk && willLoop) {
// Instead of padding the rest of this constant-size chunk with
// silence, fill it with the start of the loop segment (loopToFrame)
// - a looping stream should never have dead air baked into its
// output at all. Not faded (unlike the true-end case below): a wrap
// only sounds seamless if the source data already loops cleanly
// (true for the shared test tone, deliberately authored at 441Hz
// for exactly this), matching the same assumption Dolphin's native
// hardware looping makes - imperfectly-authored loop content will
// still click here.
//
// NOTE: if the loop segment (loopEndFrame - loopToFrame) is shorter
// than one hardware chunk (AUDIO_PSP_CHUNK_FRAMES, ~23ms @ 44100Hz),
// only a single copy of it fills the remainder here rather than
// repeating it to fill the whole chunk - any leftover space is
// zero-padded (a brief, audible gap) and loopCount still only
// increments once per hardware chunk, not once per actual loop
// repeat. Not hit by anything in this codebase today (the shared
// test tone's default whole-buffer loop is 1 second), but a future
// short music-loop tail would need this generalized to a
// repeat-fill instead.
const size_t loopSegmentFrames = loopEndFrame - loopToFrame;
wrapFrames = remainderFrames < loopSegmentFrames
? remainderFrames
: loopSegmentFrames;
if(errorIsNotOk(audioStreamPcmSeek(stream, loopToFrame))) {
readFailed = true;
break;
}
size_t wrapRead = 0;
if(errorIsNotOk(audioStreamPcmRead(
stream, chunk + (framesThisChunk * channels), wrapFrames, &wrapRead
))) {
readFailed = true;
break;
}
if(wrapRead < remainderFrames) {
memoryZero(
chunk + ((framesThisChunk + wrapRead) * channels),
(remainderFrames - wrapRead) * frameSize
);
}
} else if(reachesEndThisChunk) {
// True final chunk (not looping again) - pad with silence and fade
// the real tail down to zero so the waveform never stops (or meets
// that padding) at a non-zero amplitude, which is what was heard
if(isFinalChunk) {
// Fade the real tail down to zero so the waveform never stops (or
// meets padding) at a non-zero amplitude, which is what was heard
// as a click at the end of playback.
memoryZero(chunk + (framesThisChunk * channels), remainderFrames * frameSize);
const size_t fadeFrames = framesThisChunk < AUDIO_PSP_FADE_FRAMES
? framesThisChunk
: AUDIO_PSP_FADE_FRAMES;
@@ -277,21 +368,28 @@ void audioStreamPSPThreadFeed(thread_t *thread) {
stream->platform.channel, leftVolume, rightVolume, chunk
);
if(reachesEndThisChunk) {
if(willLoop) {
// Never call stream->onLoop directly from this thread - it may do
// arbitrary, possibly-slow work (this is exactly what caused a
// loud crackle: onLoop console-printing took long enough to
// starve the next chunk). audioStreamUpdate() picks this up and
// fires onLoop safely from the main thread instead.
stream->loopCount++;
position = loopToFrame + wrapFrames;
} else {
reachedEnd = true;
}
} else {
position += framesThisChunk;
stream->platform.framesOutput += framesThisChunk;
// Fire any loop markers this chunk just played past - never call
// stream->onLoop directly from this thread, since it may do
// arbitrary, possibly-slow work (this is exactly what caused a loud
// crackle in the past: onLoop console-printing took long enough to
// starve the next chunk). audioStreamUpdate() picks up loopCount
// changes and fires onLoop safely from the main thread instead.
threadMutexLock(&stream->platform.ringLock);
while(
stream->platform.loopMarkerCount > 0 &&
stream->platform.loopMarkerFrames[stream->platform.loopMarkerHead] <=
stream->platform.framesOutput
) {
stream->platform.loopMarkerHead =
(stream->platform.loopMarkerHead + 1) % AUDIO_PSP_LOOP_MARKER_MAX;
stream->platform.loopMarkerCount--;
stream->loopCount++;
}
threadMutexUnlock(&stream->platform.ringLock);
if(isFinalChunk) reachedEnd = true;
}
stream->platform.finished = true;
+135 -30
View File
@@ -11,34 +11,117 @@
typedef struct audiostream_s audiostream_t;
// How far ahead of hardware playback the ring buffer is allowed to hold
// already-decoded PCM - mirrors dusklinux's AUDIO_LINUX_WINDOW_FRAMES.
// Physical capacity of the ring; must comfortably exceed
// AUDIO_PSP_LEAD_FRAMES plus one top-up step so a single top-up call can
// never overwrite data the output thread hasn't consumed yet.
#define AUDIO_PSP_RING_FRAMES 16384
// Top-up threshold - audioStreamPSPTopUp() (called once per engine
// Update(), see audioStreamPSPIsFinished()) only reads more data once the
// ring drops below this, same trigger dusklinux uses for its own lead
// margin.
#define AUDIO_PSP_LEAD_FRAMES 4096
// Max number of pending loop-wrap events (see audiostreampsploopmarker_t
// below) the ring can remember at once. Sized generously relative to how
// many loop wraps could conceivably be produced ahead of playback within
// one ring's worth of lookahead; a loop shorter than
// AUDIO_PSP_RING_FRAMES / AUDIO_PSP_LOOP_MARKER_MAX frames could in theory
// overflow this, in which case onLoop simply won't fire for the excess
// wraps until the queue drains - not hit by anything in this codebase
// today (the shared test tone's loop is the whole 1-second clip).
#define AUDIO_PSP_LOOP_MARKER_MAX 8
typedef struct {
// Reserved hardware output channel, from sceAudioChReserve. Reserved with
// a small fixed chunk size (AUDIO_PSP_CHUNK_FRAMES) - PSP audio hardware
// expects continuous small-chunk feeding, not one large buffer per call.
int channel;
// Persistent thread, created once in Init and alive for the stream's
// whole lifetime - feeds the channel chunk-by-chunk for the duration of
// playback, independent of the engine's frame rate. Re-spawning a
// thread on every Buffer() call (e.g. every loop restart) was real,
// avoidable overhead - a plain OS thread creation, on top of everything
// else - heard as a small gap between loops; this thread just idles
// (polling playRequested) between plays instead of exiting.
// Sole persistent thread, created once in Init and alive for the
// stream's whole lifetime - the only thing that ever calls
// sceAudioOutputPannedBlocking(). Never touches the asset/PCM layer
// itself; only ever drains the ring buffer below in fixed
// AUDIO_PSP_CHUNK_FRAMES chunks, so hardware output timing is never at
// the mercy of a Memory Stick/zip read. Idles (polling playRequested)
// between plays instead of exiting, same reasoning as before.
thread_t thread;
// Set by audioStreamPSPBuffer() to wake the idling thread into feeding
// a pass; cleared by the thread once it picks it up.
// Set by audioStreamPSPBuffer() to wake the idling thread into a new
// pass; cleared by the thread once it picks it up.
volatile bool_t playRequested;
// Frame offset the next pass should start from - captured synchronously
// from audiostream_t.startFrame by audioStreamPSPBuffer() (which also
// resets that field to 0) rather than read directly by the feeder thread,
// since the thread only wakes up asynchronously and audiostream_t's
// shared field may already have moved on to a different value by then.
size_t startFrame;
// Set by the thread once it has fed the last chunk of a pass.
// Set by the thread once it has output the last chunk of a pass.
volatile bool_t finished;
// Ring buffer of already-decoded, contiguous PCM. Filled by
// audioStreamPSPTopUp() (runs on the MAIN thread, called once per engine
// Update() while playing - see audioStreamPSPIsFinished(), same pattern
// dusklinux uses for audioStreamLinuxFeed()) and drained by the output
// thread above. A loop wrap is just a seek back to loopToFrame partway
// through filling - the ring itself holds one seamless, contiguous
// stream of samples with no seams to splice, unlike the old per-hardware
// -chunk design; the output thread doesn't need to know where a loop
// boundary falls, only when it has *played past* one (see the loop
// marker fields below).
//
// ringReadPos/ringWritePos/ringFilled are the only fields touched by
// both the main thread (producer) and the output thread (consumer);
// both must hold ringLock to touch any of them.
int16_t *ring; // AUDIO_PSP_RING_FRAMES * channels * sizeof(int16_t) bytes
size_t ringReadPos; // next frame index the output thread reads (wraps)
size_t ringWritePos; // next frame index the main thread writes (wraps)
size_t ringFilled; // valid frames currently in the ring
threadmutex_t ringLock;
// Scratch buffer audioStreamPcmRead() decodes into before it's copied
// into the ring - sized to the ring's full capacity since a single
// top-up call can need to fill the entire thing at once (e.g. right at
// pass start, or after a frame-rate dip let the ring run dry). Main-
// thread-only, like the rest of the top-up state below.
int16_t *scratch;
// Total frames ever written into the ring this pass (monotonic, unlike
// ringWritePos which wraps) - what loopMarkerFrames[] values are
// expressed in, so they stay comparable to framesOutput below regardless
// of how many times the physical ring has wrapped around.
size_t framesEnqueued;
// FIFO of pending loop-wrap events: audioStreamPSPTopUp() records
// framesEnqueued's value at the moment it seeks back to loopToFrame:
// once the output thread's own running framesOutput reaches that value,
// it has just played the last sample before the wrap and bumps
// loopCount (never calls onLoop directly - see the loop over these in
// audiostreampsp.c for why). Guarded by ringLock, same as the ring
// itself.
size_t loopMarkerFrames[AUDIO_PSP_LOOP_MARKER_MAX];
size_t loopMarkerHead;
size_t loopMarkerCount;
// Running count of frames the output thread has sent to hardware since
// the current pass started - what loopMarkerFrames[] positions are
// compared against.
size_t framesOutput;
// Main-thread-only sequencing state for the current pass (loop points,
// read position) - only ever touched by audioStreamPSPBuffer()/
// audioStreamPSPTopUp(), both of which only ever run on the main thread,
// so none of this needs locking.
size_t totalFrames;
size_t loopEndFrame;
size_t loopToFrame;
size_t readPosition;
// Set by audioStreamPSPTopUp() once it has written the pass's true final
// frame (not a loop wrap - a genuine, non-looping end or a read/seek
// failure) - it stops reading further once either is set. The output
// thread treats "readReachedEnd (or readFailed) and the ring holds at
// most one hardware chunk" as its cue that whatever's left is the
// pass's last, possibly-partial chunk.
bool_t readReachedEnd;
bool_t readFailed;
} audiostreampsp_t;
/**
@@ -52,7 +135,7 @@ errorret_t audioStreamPSPInit(audiostream_t *stream);
/**
* Disposes the PSP-specific playback state of an audio stream, stopping its
* feeder thread and releasing its hardware output channel.
* output thread and releasing its hardware output channel.
*
* @param stream The audio stream to dispose.
* @return Error state if any.
@@ -60,9 +143,11 @@ errorret_t audioStreamPSPInit(audiostream_t *stream);
errorret_t audioStreamPSPDispose(audiostream_t *stream);
/**
* Wakes the stream's persistent feeder thread to stream PCM data (read on
* demand from the stream's asset via audioStreamPcmRead()) to its reserved
* hardware output channel in small chunks until exhausted.
* Starts a new playback pass: resets the ring buffer and loop-point
* bookkeeping, seeks the asset to the pass's start frame, and wakes the
* persistent output thread. Actual PCM reading happens afterward, driven
* by audioStreamPSPTopUp() (see audioStreamPSPIsFinished()) rather than
* here.
*
* @param stream The audio stream to output.
* @return Error state if any.
@@ -70,8 +155,27 @@ errorret_t audioStreamPSPDispose(audiostream_t *stream);
errorret_t audioStreamPSPBuffer(audiostream_t *stream);
/**
* Checks whether the stream's feeder thread has finished feeding its
* currently buffered data.
* Tops up the stream's ring buffer from the main thread if it has fallen
* below AUDIO_PSP_LEAD_FRAMES, reading enough of the asset in one call to
* fill whatever room the ring currently has (bounded by the current loop
* segment/clip end) - not just one small fixed step, so a temporary
* engine frame-rate dip can't let production fall permanently behind
* playback's consumption rate. Seeks back to loopToFrame and records a
* loop marker if this read crosses a looping pass's loop point, or marks
* readReachedEnd on a genuine end/failure. Called once per engine Update()
* via audioStreamPSPIsFinished(), same as dusklinux's own feed-on-poll
* pattern. A no-op once readReachedEnd or readFailed is set, since there's
* nothing left to add.
*
* @param stream The audio stream to top up.
*/
void audioStreamPSPTopUp(audiostream_t *stream);
/**
* Checks whether the stream's output thread has finished outputting its
* currently buffered data - also drives audioStreamPSPTopUp() each call,
* since this is invoked exactly once per engine Update() while the stream
* is playing (see audioStreamUpdate()).
*
* @param stream The audio stream to check.
* @return true if playback has finished, false otherwise.
@@ -79,14 +183,15 @@ errorret_t audioStreamPSPBuffer(audiostream_t *stream);
bool_t audioStreamPSPIsFinished(audiostream_t *stream);
/**
* Feeder thread entry point, run once for the stream's whole lifetime.
* Output thread entry point, run once for the stream's whole lifetime.
* Idles (polling playRequested) until woken by audioStreamPSPBuffer(),
* then reads and streams the stream's asset PCM data (via the audiostream_t
* passed as thread->data) to its hardware channel in fixed-size chunks,
* blocking naturally on each
* sceAudioOutputPannedBlocking() call, until the whole buffer has been
* sent - then goes back to idling, ready for the next play request, until
* the thread is asked to stop.
* then repeatedly waits for a full hardware chunk to become available in
* the ring buffer (topped up by the main thread - see
* audioStreamPSPTopUp()) and outputs it, blocking naturally on each
* sceAudioOutputPannedBlocking() call, until the pass's final
* (possibly-partial, faded) chunk has been sent - then goes back to
* idling, ready for the next play request, until the thread is asked to
* stop. Never touches the asset/PCM layer directly.
*
* @param thread The running thread_t, with data set to the audiostream_t.
*/