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]>
168 lines
5.2 KiB
C
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();
|
|
}
|