Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ac8023d50f | ||
|
|
769f2f5702 |
No files matched your search
+232
-134
@@ -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;
|
||||
|
||||
@@ -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.
|
||||
*/
|
||||
|
||||
Reference in new issue
Block a user