Files
dusk/src/dusk/audio/stream/audiostreammp3.c
T
YourWishesandClaude Sonnet 5 cebd3d81e7 Wrap long lines to fit within 80 columns across the codebase
Pure whitespace/line-break reformatting (braces, newlines, and line
continuations matching this codebase's existing wrap conventions) - no
logic, string content, or identifiers changed anywhere. Confirmed via
diff against the pre-change tree and by rebuilding + re-running the
affected test suites, which produce identical pass/fail results.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
2026-09-05 13:13:10 -05:00

168 lines
5.2 KiB
C

/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "audiostreammp3.h"
#include "audiostream.h"
#include "assert/assert.h"
#include "util/math.h"
#include "util/memory.h"
errorret_t audioStreamMp3Init(audiostream_t *stream) {
assertNotNull(stream, "Stream cannot be NULL.");
assertNotNull(stream->asset, "Stream must have an asset assigned.");
assertTrue(
stream->asset->type == ASSET_LOADER_TYPE_MP3,
"Asset is not an MP3 file."
);
const assetmp3file_t *mp3 = &stream->asset->data.mp3;
stream->type = AUDIO_STREAM_TYPE_MP3;
stream->sampleRate = mp3->sampleRate;
stream->channels = mp3->channels;
stream->duration = (float_t) mp3->totalFrames / (float_t) mp3->sampleRate;
stream->mp3.pendingFrames = 0;
stream->mp3.pendingPosition = 0;
stream->mp3.position = 0;
stream->mp3.totalFrames = mp3->totalFrames;
// Each stream opens its own independent handle to the same underlying
// asset file - see audiostreampcm.c's audioStreamPcmInit() for why.
errorChain(assetFileInit(
&stream->mp3.file, stream->asset->name, NULL, NULL
));
errorChain(assetFileOpen(&stream->mp3.file));
errorChain(assetFileRead(&stream->mp3.file, NULL, mp3->dataOffset));
errorChain(audioStreamMp3DecoderInit(stream));
errorChain(audioStreamPlatformInit(stream));
errorOk();
}
errorret_t audioStreamMp3Dispose(audiostream_t *stream) {
assertNotNull(stream, "Stream cannot be NULL.");
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
errorChain(audioStreamMp3DecoderDispose(stream));
errorChain(assetFileClose(&stream->mp3.file));
errorChain(assetFileDispose(&stream->mp3.file));
errorOk();
}
size_t audioStreamMp3GetTotalFrames(const audiostream_t *stream) {
assertNotNull(stream, "Stream cannot be NULL.");
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
return stream->mp3.totalFrames;
}
errorret_t audioStreamMp3Seek(audiostream_t *stream, const size_t frame) {
assertNotNull(stream, "Stream cannot be NULL.");
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
if(frame == stream->mp3.position) {
errorOk();
}
// Every seek - forward or backward - restarts decoding from the very
// start of the compressed stream and discards frames until reaching the
// target; see this file's own header comment for why MP3 has no cheaper
// option, unlike audioStreamPcmSeek()'s direct byte-offset seek.
errorChain(audioStreamMp3DecoderRewind(stream));
stream->mp3.position = 0;
stream->mp3.pendingFrames = 0;
stream->mp3.pendingPosition = 0;
const size_t channels = stream->channels;
int16_t discard[AUDIO_MP3_MAX_SAMPLES_PER_FRAME];
while(stream->mp3.position < frame) {
size_t decodedFrames = 0;
errorChain(
audioStreamMp3DecoderDecodeFrame(stream, discard, &decodedFrames)
);
if(decodedFrames == 0) {
// Ran out of stream before reaching the target - clamp rather than
// erroring, same tolerance audioStreamPcmRead() has for a
// shorter-than-declared asset.
break;
}
const size_t framesNeeded = frame - stream->mp3.position;
if(decodedFrames <= framesNeeded) {
stream->mp3.position += decodedFrames;
continue;
}
// This frame overshoots the target - keep the excess as pending so
// the next Read() starts exactly at `frame` instead of skipping past
// it.
const size_t keepFrames = decodedFrames - framesNeeded;
memoryMove(
discard, discard + (framesNeeded * channels),
keepFrames * channels * sizeof(int16_t)
);
memoryCopy(
stream->mp3.pending, discard, keepFrames * channels * sizeof(int16_t)
);
stream->mp3.pendingFrames = keepFrames;
stream->mp3.pendingPosition = 0;
stream->mp3.position = frame;
}
errorOk();
}
errorret_t audioStreamMp3Read(
audiostream_t *stream,
int16_t *buffer,
const size_t frameCount,
size_t *outFramesRead
) {
assertNotNull(stream, "Stream cannot be NULL.");
assertNotNull(buffer, "Buffer cannot be NULL.");
assertNotNull(outFramesRead, "outFramesRead cannot be NULL.");
assertTrue(stream->type == AUDIO_STREAM_TYPE_MP3, "Stream is not MP3.");
const size_t channels = stream->channels;
size_t framesWritten = 0;
while(framesWritten < frameCount) {
if(stream->mp3.pendingPosition >= stream->mp3.pendingFrames) {
size_t decodedFrames = 0;
errorChain(audioStreamMp3DecoderDecodeFrame(
stream, stream->mp3.pending, &decodedFrames
));
stream->mp3.pendingFrames = decodedFrames;
stream->mp3.pendingPosition = 0;
if(decodedFrames == 0) break; // Genuine end of stream.
}
const size_t framesAvailable =
stream->mp3.pendingFrames - stream->mp3.pendingPosition;
const size_t framesToCopy =
mathMin(frameCount - framesWritten, framesAvailable);
memoryCopy(
buffer + (framesWritten * channels),
stream->mp3.pending + (stream->mp3.pendingPosition * channels),
framesToCopy * channels * sizeof(int16_t)
);
stream->mp3.pendingPosition += framesToCopy;
framesWritten += framesToCopy;
}
stream->mp3.position += framesWritten;
*outFramesRead = framesWritten;
errorOk();
}