ShuriZma
/
mgba
mirror of https://github.com/mgba-emu/mgba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Util: Rename CircleBuffer to mCircleBuffer

This commit is contained in:
Vicki Pfau 2024-04-12 23:27:37 -07:00
parent b62ae33f38
commit fd4175ebf8
14 changed files with 569 additions and 569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
include/mgba-util/circle-buffer.h
View File

@ -10,7 +10,7 @@
CXX_GUARD_START CXX_GUARD_START
struct CircleBuffer { struct mCircleBuffer {
void* data; void* data;
size_t capacity; size_t capacity;
size_t size; size_t size;
@ -18,21 +18,21 @@ struct CircleBuffer {
void* writePtr; void* writePtr;
}; };
void CircleBufferInit(struct CircleBuffer* buffer, unsigned capacity); void mCircleBufferInit(struct mCircleBuffer* buffer, unsigned capacity);
void CircleBufferDeinit(struct CircleBuffer* buffer); void mCircleBufferDeinit(struct mCircleBuffer* buffer);
size_t CircleBufferSize(const struct CircleBuffer* buffer); size_t mCircleBufferSize(const struct mCircleBuffer* buffer);
size_t CircleBufferCapacity(const struct CircleBuffer* buffer); size_t mCircleBufferCapacity(const struct mCircleBuffer* buffer);
void CircleBufferClear(struct CircleBuffer* buffer); void mCircleBufferClear(struct mCircleBuffer* buffer);
int CircleBufferWrite8(struct CircleBuffer* buffer, int8_t value); int mCircleBufferWrite8(struct mCircleBuffer* buffer, int8_t value);
int CircleBufferWrite16(struct CircleBuffer* buffer, int16_t value); int mCircleBufferWrite16(struct mCircleBuffer* buffer, int16_t value);
int CircleBufferWrite32(struct CircleBuffer* buffer, int32_t value); int mCircleBufferWrite32(struct mCircleBuffer* buffer, int32_t value);
size_t CircleBufferWrite(struct CircleBuffer* buffer, const void* input, size_t length); size_t mCircleBufferWrite(struct mCircleBuffer* buffer, const void* input, size_t length);
size_t CircleBufferWriteTruncate(struct CircleBuffer* buffer, const void* input, size_t length); size_t mCircleBufferWriteTruncate(struct mCircleBuffer* buffer, const void* input, size_t length);
int CircleBufferRead8(struct CircleBuffer* buffer, int8_t* value); int mCircleBufferRead8(struct mCircleBuffer* buffer, int8_t* value);
int CircleBufferRead16(struct CircleBuffer* buffer, int16_t* value); int mCircleBufferRead16(struct mCircleBuffer* buffer, int16_t* value);
int CircleBufferRead32(struct CircleBuffer* buffer, int32_t* value); int mCircleBufferRead32(struct mCircleBuffer* buffer, int32_t* value);
size_t CircleBufferRead(struct CircleBuffer* buffer, void* output, size_t length); size_t mCircleBufferRead(struct mCircleBuffer* buffer, void* output, size_t length);
size_t CircleBufferDump(const struct CircleBuffer* buffer, void* output, size_t length, size_t offset); size_t mCircleBufferDump(const struct mCircleBuffer* buffer, void* output, size_t length, size_t offset);
CXX_GUARD_END CXX_GUARD_END

4
include/mgba-util/vfs.h
View File

@ -73,8 +73,8 @@ struct VFile* VFileFromMemory(void* mem, size_t size);
struct VFile* VFileFromConstMemory(const void* mem, size_t size); struct VFile* VFileFromConstMemory(const void* mem, size_t size);
struct VFile* VFileMemChunk(const void* mem, size_t size); struct VFile* VFileMemChunk(const void* mem, size_t size);
struct CircleBuffer; struct mCircleBuffer;
struct VFile* VFileFIFO(struct CircleBuffer* backing); struct VFile* VFileFIFO(struct mCircleBuffer* backing);
struct VDir* VDirOpen(const char* path); struct VDir* VDirOpen(const char* path);
struct VDir* VDirOpenArchive(const char* path); struct VDir* VDirOpenArchive(const char* path);

2
include/mgba/internal/gba/audio.h
View File

@ -253,7 +253,7 @@ struct GBAMP2kTrack {
struct GBAMP2kMusicPlayerTrack track; struct GBAMP2kMusicPlayerTrack track;
struct GBAMP2kSoundChannel* channel; struct GBAMP2kSoundChannel* channel;
uint8_t lastCommand; uint8_t lastCommand;
struct CircleBuffer buffer; struct mCircleBuffer buffer;
uint32_t samplePlaying; uint32_t samplePlaying;
float currentOffset; float currentOffset;
bool waiting; bool waiting;

16
src/feature/gui/gui-runner.c
View File

@ -220,7 +220,7 @@ void mGUIInit(struct mGUIRunner* runner, const char* port) {
runner->fps = 0; runner->fps = 0;
runner->lastFpsCheck = 0; runner->lastFpsCheck = 0;
runner->totalDelta = 0; runner->totalDelta = 0;
CircleBufferInit(&runner->fpsBuffer, FPS_BUFFER_SIZE * sizeof(uint32_t)); mCircleBufferInit(&runner->fpsBuffer, FPS_BUFFER_SIZE * sizeof(uint32_t));
mInputMapInit(&runner->params.keyMap, &_mGUIKeyInfo); mInputMapInit(&runner->params.keyMap, &_mGUIKeyInfo);
mCoreConfigInit(&runner->config, runner->port); mCoreConfigInit(&runner->config, runner->port);
@ -284,7 +284,7 @@ void mGUIDeinit(struct mGUIRunner* runner) {
if (runner->teardown) { if (runner->teardown) {
runner->teardown(runner); runner->teardown(runner);
} }
CircleBufferDeinit(&runner->fpsBuffer); mCircleBufferDeinit(&runner->fpsBuffer);
mInputMapDeinit(&runner->params.keyMap); mInputMapDeinit(&runner->params.keyMap);
mCoreConfigDeinit(&runner->config); mCoreConfigDeinit(&runner->config);
if (logger.vf) { if (logger.vf) {
@ -502,7 +502,7 @@ void mGUIRun(struct mGUIRunner* runner, const char* path) {
runner->fps = 0; runner->fps = 0;
bool fastForward = false; bool fastForward = false;
while (running) { while (running) {
CircleBufferClear(&runner->fpsBuffer); mCircleBufferClear(&runner->fpsBuffer);
runner->totalDelta = 0; runner->totalDelta = 0;
struct timeval tv; struct timeval tv;
gettimeofday(&tv, 0); gettimeofday(&tv, 0);
@ -610,17 +610,17 @@ void mGUIRun(struct mGUIRunner* runner, const char* path) {
uint64_t delta = t - runner->lastFpsCheck; uint64_t delta = t - runner->lastFpsCheck;
runner->lastFpsCheck = t; runner->lastFpsCheck = t;
if (delta > 0x7FFFFFFFLL) { if (delta > 0x7FFFFFFFLL) {
CircleBufferClear(&runner->fpsBuffer); mCircleBufferClear(&runner->fpsBuffer);
runner->fps = 0; runner->fps = 0;
} }
if (CircleBufferSize(&runner->fpsBuffer) == CircleBufferCapacity(&runner->fpsBuffer)) { if (mCircleBufferSize(&runner->fpsBuffer) == mCircleBufferCapacity(&runner->fpsBuffer)) {
int32_t last; int32_t last;
CircleBufferRead32(&runner->fpsBuffer, &last); mCircleBufferRead32(&runner->fpsBuffer, &last);
runner->totalDelta -= last; runner->totalDelta -= last;
} }
CircleBufferWrite32(&runner->fpsBuffer, delta); mCircleBufferWrite32(&runner->fpsBuffer, delta);
runner->totalDelta += delta; runner->totalDelta += delta;
runner->fps = (CircleBufferSize(&runner->fpsBuffer) * FPS_GRANULARITY * 1000000.0f) / (runner->totalDelta * sizeof(uint32_t)); runner->fps = (mCircleBufferSize(&runner->fpsBuffer) * FPS_GRANULARITY * 1000000.0f) / (runner->totalDelta * sizeof(uint32_t));
} }
} }
if (frame % (AUTOSAVE_GRANULARITY * (fastForwarding ? 2 : 1)) == 0) { if (frame % (AUTOSAVE_GRANULARITY * (fastForwarding ? 2 : 1)) == 0) {

2
src/feature/gui/gui-runner.h
View File

@ -78,7 +78,7 @@ struct mGUIRunner {
float fps; float fps;
int64_t lastFpsCheck; int64_t lastFpsCheck;
int32_t totalDelta; int32_t totalDelta;
struct CircleBuffer fpsBuffer; struct mCircleBuffer fpsBuffer;
void (*setup)(struct mGUIRunner*); void (*setup)(struct mGUIRunner*);
void (*teardown)(struct mGUIRunner*); void (*teardown)(struct mGUIRunner*);

64
src/feature/video-logger.c
View File

@ -87,8 +87,8 @@ struct mVideoLogChannel {
enum mVideoLoggerInjectionPoint injectionPoint; enum mVideoLoggerInjectionPoint injectionPoint;
uint32_t ignorePackets; uint32_t ignorePackets;
struct CircleBuffer injectedBuffer; struct mCircleBuffer injectedBuffer;
struct CircleBuffer buffer; struct mCircleBuffer buffer;
}; };
struct mVideoLogContext { struct mVideoLogContext {
@ -662,8 +662,8 @@ bool mVideoLogContextLoad(struct mVideoLogContext* context, struct VFile* vf) {
size_t i; size_t i;
for (i = 0; i < context->nChannels; ++i) { for (i = 0; i < context->nChannels; ++i) {
CircleBufferInit(&context->channels[i].injectedBuffer, BUFFER_BASE_SIZE); mCircleBufferInit(&context->channels[i].injectedBuffer, BUFFER_BASE_SIZE);
CircleBufferInit(&context->channels[i].buffer, BUFFER_BASE_SIZE); mCircleBufferInit(&context->channels[i].buffer, BUFFER_BASE_SIZE);
context->channels[i].bufferRemaining = 0; context->channels[i].bufferRemaining = 0;
context->channels[i].currentPointer = pointer; context->channels[i].currentPointer = pointer;
context->channels[i].p = context; context->channels[i].p = context;
@ -676,8 +676,8 @@ bool mVideoLogContextLoad(struct mVideoLogContext* context, struct VFile* vf) {
#ifdef USE_ZLIB #ifdef USE_ZLIB
static void _flushBufferCompressed(struct mVideoLogContext* context) { static void _flushBufferCompressed(struct mVideoLogContext* context) {
struct CircleBuffer* buffer = &context->channels[context->activeChannel].buffer; struct mCircleBuffer* buffer = &context->channels[context->activeChannel].buffer;
if (!CircleBufferSize(buffer)) { if (!mCircleBufferSize(buffer)) {
return; return;
} }
struct VFile* vfm = VFileMemChunk(NULL, 0); struct VFile* vfm = VFileMemChunk(NULL, 0);
@ -707,20 +707,20 @@ static void _flushBuffer(struct mVideoLogContext* context) {
} }
#endif #endif
struct CircleBuffer* buffer = &context->channels[context->activeChannel].buffer; struct mCircleBuffer* buffer = &context->channels[context->activeChannel].buffer;
if (!CircleBufferSize(buffer)) { if (!mCircleBufferSize(buffer)) {
return; return;
} }
struct mVLBlockHeader header = { 0 }; struct mVLBlockHeader header = { 0 };
STORE_32LE(mVL_BLOCK_DATA, 0, &header.blockType); STORE_32LE(mVL_BLOCK_DATA, 0, &header.blockType);
STORE_32LE(CircleBufferSize(buffer), 0, &header.length); STORE_32LE(mCircleBufferSize(buffer), 0, &header.length);
STORE_32LE(context->activeChannel, 0, &header.channelId); STORE_32LE(context->activeChannel, 0, &header.channelId);
context->backing->write(context->backing, &header, sizeof(header)); context->backing->write(context->backing, &header, sizeof(header));
uint8_t writeBuffer[0x800]; uint8_t writeBuffer[0x800];
while (CircleBufferSize(buffer)) { while (mCircleBufferSize(buffer)) {
size_t read = CircleBufferRead(buffer, writeBuffer, sizeof(writeBuffer)); size_t read = mCircleBufferRead(buffer, writeBuffer, sizeof(writeBuffer));
context->backing->write(context->backing, writeBuffer, read); context->backing->write(context->backing, writeBuffer, read);
} }
} }
@ -743,8 +743,8 @@ void mVideoLogContextDestroy(struct mCore* core, struct mVideoLogContext* contex
size_t i; size_t i;
for (i = 0; i < context->nChannels; ++i) { for (i = 0; i < context->nChannels; ++i) {
CircleBufferDeinit(&context->channels[i].injectedBuffer); mCircleBufferDeinit(&context->channels[i].injectedBuffer);
CircleBufferDeinit(&context->channels[i].buffer); mCircleBufferDeinit(&context->channels[i].buffer);
#ifdef USE_ZLIB #ifdef USE_ZLIB
if (context->channels[i].inflating) { if (context->channels[i].inflating) {
inflateEnd(&context->channels[i].inflateStream); inflateEnd(&context->channels[i].inflateStream);
@ -778,8 +778,8 @@ void mVideoLogContextRewind(struct mVideoLogContext* context, struct mCore* core
size_t i; size_t i;
for (i = 0; i < context->nChannels; ++i) { for (i = 0; i < context->nChannels; ++i) {
CircleBufferClear(&context->channels[i].injectedBuffer); mCircleBufferClear(&context->channels[i].injectedBuffer);
CircleBufferClear(&context->channels[i].buffer); mCircleBufferClear(&context->channels[i].buffer);
context->channels[i].bufferRemaining = 0; context->channels[i].bufferRemaining = 0;
context->channels[i].currentPointer = pointer; context->channels[i].currentPointer = pointer;
#ifdef USE_ZLIB #ifdef USE_ZLIB
@ -805,8 +805,8 @@ int mVideoLoggerAddChannel(struct mVideoLogContext* context) {
int chid = context->nChannels; int chid = context->nChannels;
++context->nChannels; ++context->nChannels;
context->channels[chid].p = context; context->channels[chid].p = context;
CircleBufferInit(&context->channels[chid].injectedBuffer, BUFFER_BASE_SIZE); mCircleBufferInit(&context->channels[chid].injectedBuffer, BUFFER_BASE_SIZE);
CircleBufferInit(&context->channels[chid].buffer, BUFFER_BASE_SIZE); mCircleBufferInit(&context->channels[chid].buffer, BUFFER_BASE_SIZE);
context->channels[chid].injecting = false; context->channels[chid].injecting = false;
context->channels[chid].injectionPoint = LOGGER_INJECTION_IMMEDIATE; context->channels[chid].injectionPoint = LOGGER_INJECTION_IMMEDIATE;
context->channels[chid].ignorePackets = 0; context->channels[chid].ignorePackets = 0;
@ -898,7 +898,7 @@ static size_t _readBufferCompressed(struct VFile* vf, struct mVideoLogChannel* c
} }
} }
thisWrite = CircleBufferWrite(&channel->buffer, zbuffer, thisWrite - channel->inflateStream.avail_out); thisWrite = mCircleBufferWrite(&channel->buffer, zbuffer, thisWrite - channel->inflateStream.avail_out);
length -= thisWrite; length -= thisWrite;
read += thisWrite; read += thisWrite;
@ -921,7 +921,7 @@ static void _readBuffer(struct VFile* vf, struct mVideoLogChannel* channel, size
if (thisRead <= 0) { if (thisRead <= 0) {
return; return;
} }
size_t thisWrite = CircleBufferWrite(&channel->buffer, buffer, thisRead); size_t thisWrite = mCircleBufferWrite(&channel->buffer, buffer, thisRead);
length -= thisWrite; length -= thisWrite;
channel->bufferRemaining -= thisWrite; channel->bufferRemaining -= thisWrite;
channel->currentPointer += thisWrite; channel->currentPointer += thisWrite;
@ -986,16 +986,16 @@ static ssize_t mVideoLoggerReadChannel(struct mVideoLogChannel* channel, void* d
if (channelId >= mVL_MAX_CHANNELS) { if (channelId >= mVL_MAX_CHANNELS) {
return 0; return 0;
} }
struct CircleBuffer* buffer = &channel->buffer; struct mCircleBuffer* buffer = &channel->buffer;
if (channel->injecting) { if (channel->injecting) {
buffer = &channel->injectedBuffer; buffer = &channel->injectedBuffer;
} }
if (CircleBufferSize(buffer) >= length) { if (mCircleBufferSize(buffer) >= length) {
return CircleBufferRead(buffer, data, length); return mCircleBufferRead(buffer, data, length);
} }
ssize_t size = 0; ssize_t size = 0;
if (CircleBufferSize(buffer)) { if (mCircleBufferSize(buffer)) {
size = CircleBufferRead(buffer, data, CircleBufferSize(buffer)); size = mCircleBufferRead(buffer, data, mCircleBufferSize(buffer));
if (size <= 0) { if (size <= 0) {
return size; return size;
} }
@ -1005,7 +1005,7 @@ static ssize_t mVideoLoggerReadChannel(struct mVideoLogChannel* channel, void* d
if (channel->injecting || !_fillBuffer(context, channelId, BUFFER_BASE_SIZE)) { if (channel->injecting || !_fillBuffer(context, channelId, BUFFER_BASE_SIZE)) {
return size; return size;
} }
size += CircleBufferRead(buffer, data, length); size += mCircleBufferRead(buffer, data, length);
return size; return size;
} }
@ -1019,20 +1019,20 @@ static ssize_t mVideoLoggerWriteChannel(struct mVideoLogChannel* channel, const
_flushBuffer(context); _flushBuffer(context);
context->activeChannel = channelId; context->activeChannel = channelId;
} }
struct CircleBuffer* buffer = &channel->buffer; struct mCircleBuffer* buffer = &channel->buffer;
if (channel->injecting) { if (channel->injecting) {
buffer = &channel->injectedBuffer; buffer = &channel->injectedBuffer;
} }
if (CircleBufferCapacity(buffer) - CircleBufferSize(buffer) < length) { if (mCircleBufferCapacity(buffer) - mCircleBufferSize(buffer) < length) {
_flushBuffer(context); _flushBuffer(context);
if (CircleBufferCapacity(buffer) < length) { if (mCircleBufferCapacity(buffer) < length) {
CircleBufferDeinit(buffer); mCircleBufferDeinit(buffer);
CircleBufferInit(buffer, toPow2(length << 1)); mCircleBufferInit(buffer, toPow2(length << 1));
} }
} }
ssize_t read = CircleBufferWrite(buffer, data, length); ssize_t read = mCircleBufferWrite(buffer, data, length);
if (CircleBufferCapacity(buffer) == CircleBufferSize(buffer)) { if (mCircleBufferCapacity(buffer) == mCircleBufferSize(buffer)) {
_flushBuffer(context); _flushBuffer(context);
} }
return read; return read;

14
src/gba/extra/audio-mixer.c
View File

@ -43,7 +43,7 @@ void _mp2kInit(void* cpu, struct mCPUComponent* component) {
size_t i; size_t i;
for (i = 0; i < MP2K_MAX_SOUND_CHANNELS; ++i) { for (i = 0; i < MP2K_MAX_SOUND_CHANNELS; ++i) {
mixer->activeTracks[i].channel = &mixer->context.chans[i]; mixer->activeTracks[i].channel = &mixer->context.chans[i];
CircleBufferInit(&mixer->activeTracks[i].buffer, 0x10000); mCircleBufferInit(&mixer->activeTracks[i].buffer, 0x10000);
} }
} }
@ -51,7 +51,7 @@ void _mp2kDeinit(struct mCPUComponent* component) {
struct GBAAudioMixer* mixer = (struct GBAAudioMixer*) component; struct GBAAudioMixer* mixer = (struct GBAAudioMixer*) component;
size_t i; size_t i;
for (i = 0; i < MP2K_MAX_SOUND_CHANNELS; ++i) { for (i = 0; i < MP2K_MAX_SOUND_CHANNELS; ++i) {
CircleBufferDeinit(&mixer->activeTracks[i].buffer); mCircleBufferDeinit(&mixer->activeTracks[i].buffer);
} }
} }
@ -130,8 +130,8 @@ static void _stepSample(struct GBAAudioMixer* mixer, struct GBAMP2kTrack* track)
(sample * track->channel->rightVolume * track->channel->envelopeV) >> 9 (sample * track->channel->rightVolume * track->channel->envelopeV) >> 9
}; };
CircleBufferWrite16(&track->buffer, stereo.left); mCircleBufferWrite16(&track->buffer, stereo.left);
CircleBufferWrite16(&track->buffer, stereo.right); mCircleBufferWrite16(&track->buffer, stereo.right);
sampleOffset += mixer->p->sampleInterval / OVERSAMPLE; sampleOffset += mixer->p->sampleInterval / OVERSAMPLE;
while (sampleOffset > freq) { while (sampleOffset > freq) {
@ -265,7 +265,7 @@ void _mp2kStep(struct GBAAudioMixer* mixer) {
} else { } else {
track->currentOffset = 0; track->currentOffset = 0;
track->samplePlaying = 0; track->samplePlaying = 0;
CircleBufferClear(&track->buffer); mCircleBufferClear(&track->buffer);
} }
} }
mixer->frame -= VIDEO_TOTAL_LENGTH / mixer->tempo; mixer->frame -= VIDEO_TOTAL_LENGTH / mixer->tempo;
@ -281,9 +281,9 @@ void _mp2kStep(struct GBAAudioMixer* mixer) {
continue; continue;
} }
int16_t value; int16_t value;
CircleBufferRead16(&mixer->activeTracks[track].buffer, &value); mCircleBufferRead16(&mixer->activeTracks[track].buffer, &value);
sample.left += value; sample.left += value;
CircleBufferRead16(&mixer->activeTracks[track].buffer, &value); mCircleBufferRead16(&mixer->activeTracks[track].buffer, &value);
sample.right += value; sample.right += value;
} }
sample.left = (sample.left * mixer->p->masterVolume) >> 8; sample.left = (sample.left * mixer->p->masterVolume) >> 8;

12
src/platform/psp2/psp2-context.c
View File

@ -65,7 +65,7 @@ static struct mSceRotationSource {
static struct mSceRumble { static struct mSceRumble {
struct mRumble d; struct mRumble d;
struct CircleBuffer history; struct mCircleBuffer history;
int current; int current;
} rumble; } rumble;
@ -155,12 +155,12 @@ static int32_t _readGyroZ(struct mRotationSource* source) {
static void _setRumble(struct mRumble* source, int enable) { static void _setRumble(struct mRumble* source, int enable) {
struct mSceRumble* rumble = (struct mSceRumble*) source; struct mSceRumble* rumble = (struct mSceRumble*) source;
rumble->current += enable; rumble->current += enable;
if (CircleBufferSize(&rumble->history) == RUMBLE_PWM) { if (mCircleBufferSize(&rumble->history) == RUMBLE_PWM) {
int8_t oldLevel; int8_t oldLevel;
CircleBufferRead8(&rumble->history, &oldLevel); mCircleBufferRead8(&rumble->history, &oldLevel);
rumble->current -= oldLevel; rumble->current -= oldLevel;
} }
CircleBufferWrite8(&rumble->history, enable); mCircleBufferWrite8(&rumble->history, enable);
int small = (rumble->current << 21) / 65793; int small = (rumble->current << 21) / 65793;
int big = ((rumble->current * rumble->current) << 18) / 65793; int big = ((rumble->current * rumble->current) << 18) / 65793;
struct SceCtrlActuator state = { struct SceCtrlActuator state = {
@ -342,7 +342,7 @@ void mPSP2Setup(struct mGUIRunner* runner) {
runner->core->setPeripheral(runner->core, mPERIPH_ROTATION, &rotation.d); runner->core->setPeripheral(runner->core, mPERIPH_ROTATION, &rotation.d);
rumble.d.setRumble = _setRumble; rumble.d.setRumble = _setRumble;
CircleBufferInit(&rumble.history, RUMBLE_PWM); mCircleBufferInit(&rumble.history, RUMBLE_PWM);
runner->core->setPeripheral(runner->core, mPERIPH_RUMBLE, &rumble.d); runner->core->setPeripheral(runner->core, mPERIPH_RUMBLE, &rumble.d);
camera.d.startRequestImage = _startRequestImage; camera.d.startRequestImage = _startRequestImage;
@ -482,7 +482,7 @@ void mPSP2Unpaused(struct mGUIRunner* runner) {
void mPSP2Teardown(struct mGUIRunner* runner) { void mPSP2Teardown(struct mGUIRunner* runner) {
UNUSED(runner); UNUSED(runner);
CircleBufferDeinit(&rumble.history); mCircleBufferDeinit(&rumble.history);
vita2d_free_texture(tex[0]); vita2d_free_texture(tex[0]);
vita2d_free_texture(tex[1]); vita2d_free_texture(tex[1]);
vita2d_free_texture(screenshot); vita2d_free_texture(screenshot);

20
src/platform/sdl/sdl-events.c
View File

@ -202,7 +202,7 @@ bool mSDLAttachPlayer(struct mSDLEvents* events, struct mSDLPlayer* player) {
#if SDL_VERSION_ATLEAST(2, 0, 0) #if SDL_VERSION_ATLEAST(2, 0, 0)
player->rumble.d.setRumble = _mSDLSetRumble; player->rumble.d.setRumble = _mSDLSetRumble;
CircleBufferInit(&player->rumble.history, RUMBLE_PWM); mCircleBufferInit(&player->rumble.history, RUMBLE_PWM);
player->rumble.level = 0; player->rumble.level = 0;
player->rumble.activeLevel = 0; player->rumble.activeLevel = 0;
player->rumble.p = player; player->rumble.p = player;
@ -219,7 +219,7 @@ bool mSDLAttachPlayer(struct mSDLEvents* events, struct mSDLPlayer* player) {
player->rotation.gyroY = 1; player->rotation.gyroY = 1;
player->rotation.gyroZ = -1; player->rotation.gyroZ = -1;
player->rotation.zDelta = 0; player->rotation.zDelta = 0;
CircleBufferInit(&player->rotation.zHistory, sizeof(float) * GYRO_STEPS); mCircleBufferInit(&player->rotation.zHistory, sizeof(float) * GYRO_STEPS);
player->rotation.p = player; player->rotation.p = player;
player->playerId = events->playersAttached; player->playerId = events->playersAttached;
@ -293,9 +293,9 @@ void mSDLDetachPlayer(struct mSDLEvents* events, struct mSDLPlayer* player) {
} }
} }
--events->playersAttached; --events->playersAttached;
CircleBufferDeinit(&player->rotation.zHistory); mCircleBufferDeinit(&player->rotation.zHistory);
#if SDL_VERSION_ATLEAST(2, 0, 0) #if SDL_VERSION_ATLEAST(2, 0, 0)
CircleBufferDeinit(&player->rumble.history); mCircleBufferDeinit(&player->rumble.history);
#endif #endif
} }
@ -739,12 +739,12 @@ static void _mSDLSetRumble(struct mRumble* rumble, int enable) {
int8_t originalLevel = sdlRumble->level; int8_t originalLevel = sdlRumble->level;
sdlRumble->level += enable; sdlRumble->level += enable;
if (CircleBufferSize(&sdlRumble->history) == RUMBLE_PWM) { if (mCircleBufferSize(&sdlRumble->history) == RUMBLE_PWM) {
int8_t oldLevel; int8_t oldLevel;
CircleBufferRead8(&sdlRumble->history, &oldLevel); mCircleBufferRead8(&sdlRumble->history, &oldLevel);
sdlRumble->level -= oldLevel; sdlRumble->level -= oldLevel;
} }
CircleBufferWrite8(&sdlRumble->history, enable); mCircleBufferWrite8(&sdlRumble->history, enable);
if (sdlRumble->level == originalLevel) { if (sdlRumble->level == originalLevel) {
return; return;
} }
@ -851,10 +851,10 @@ static void _mSDLRotationSample(struct mRotationSource* source) {
rotation->oldY = y; rotation->oldY = y;
float oldZ = 0; float oldZ = 0;
if (CircleBufferSize(&rotation->zHistory) == GYRO_STEPS * sizeof(float)) { if (mCircleBufferSize(&rotation->zHistory) == GYRO_STEPS * sizeof(float)) {
CircleBufferRead32(&rotation->zHistory, (int32_t*) &oldZ); mCircleBufferRead32(&rotation->zHistory, (int32_t*) &oldZ);
} }
CircleBufferWrite32(&rotation->zHistory, theta.i); mCircleBufferWrite32(&rotation->zHistory, theta.i);
rotation->zDelta += theta.f - oldZ; rotation->zDelta += theta.f - oldZ;
} }

4
src/platform/sdl/sdl-events.h
View File

@ -76,7 +76,7 @@ struct mSDLPlayer {
int level; int level;
float activeLevel; float activeLevel;
struct CircleBuffer history; struct mCircleBuffer history;
} rumble; } rumble;
#else #else
int newWidth; int newWidth;
@ -98,7 +98,7 @@ struct mSDLPlayer {
int gyroY; int gyroY;
int gyroZ; int gyroZ;
float gyroSensitivity; float gyroSensitivity;
struct CircleBuffer zHistory; struct mCircleBuffer zHistory;
int oldX; int oldX;
int oldY; int oldY;
float zDelta; float zDelta;

60
src/util/circle-buffer.c
View File

@ -6,7 +6,7 @@
#include <mgba-util/circle-buffer.h> #include <mgba-util/circle-buffer.h>
#ifndef NDEBUG #ifndef NDEBUG
static int _checkIntegrity(struct CircleBuffer* buffer) { static int _checkIntegrity(struct mCircleBuffer* buffer) {
if ((int8_t*) buffer->writePtr - (int8_t*) buffer->readPtr == (ssize_t) buffer->size) { if ((int8_t*) buffer->writePtr - (int8_t*) buffer->readPtr == (ssize_t) buffer->size) {
return 1; return 1;
} }
@ -20,32 +20,32 @@ static int _checkIntegrity(struct CircleBuffer* buffer) {
} }
#endif #endif
void CircleBufferInit(struct CircleBuffer* buffer, unsigned capacity) { void mCircleBufferInit(struct mCircleBuffer* buffer, unsigned capacity) {
buffer->data = malloc(capacity); buffer->data = malloc(capacity);
buffer->capacity = capacity; buffer->capacity = capacity;
CircleBufferClear(buffer); mCircleBufferClear(buffer);
} }
void CircleBufferDeinit(struct CircleBuffer* buffer) { void mCircleBufferDeinit(struct mCircleBuffer* buffer) {
free(buffer->data); free(buffer->data);
buffer->data = 0; buffer->data = 0;
} }
size_t CircleBufferSize(const struct CircleBuffer* buffer) { size_t mCircleBufferSize(const struct mCircleBuffer* buffer) {
return buffer->size; return buffer->size;
} }
size_t CircleBufferCapacity(const struct CircleBuffer* buffer) { size_t mCircleBufferCapacity(const struct mCircleBuffer* buffer) {
return buffer->capacity; return buffer->capacity;
} }
void CircleBufferClear(struct CircleBuffer* buffer) { void mCircleBufferClear(struct mCircleBuffer* buffer) {
buffer->size = 0; buffer->size = 0;
buffer->readPtr = buffer->data; buffer->readPtr = buffer->data;
buffer->writePtr = buffer->data; buffer->writePtr = buffer->data;
} }
int CircleBufferWrite8(struct CircleBuffer* buffer, int8_t value) { int mCircleBufferWrite8(struct mCircleBuffer* buffer, int8_t value) {
int8_t* data = buffer->writePtr; int8_t* data = buffer->writePtr;
if (buffer->size + sizeof(int8_t) > buffer->capacity) { if (buffer->size + sizeof(int8_t) > buffer->capacity) {
return 0; return 0;
@ -67,17 +67,17 @@ int CircleBufferWrite8(struct CircleBuffer* buffer, int8_t value) {
return 1; return 1;
} }
int CircleBufferWrite32(struct CircleBuffer* buffer, int32_t value) { int mCircleBufferWrite32(struct mCircleBuffer* buffer, int32_t value) {
int32_t* data = buffer->writePtr; int32_t* data = buffer->writePtr;
if (buffer->size + sizeof(int32_t) > buffer->capacity) { if (buffer->size + sizeof(int32_t) > buffer->capacity) {
return 0; return 0;
} }
if (((intptr_t) data & 0x3) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int32_t)) { if (((intptr_t) data & 0x3) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int32_t)) {
int written = 0; int written = 0;
written += CircleBufferWrite8(buffer, ((int8_t*) &value)[0]); written += mCircleBufferWrite8(buffer, ((int8_t*) &value)[0]);
written += CircleBufferWrite8(buffer, ((int8_t*) &value)[1]); written += mCircleBufferWrite8(buffer, ((int8_t*) &value)[1]);
written += CircleBufferWrite8(buffer, ((int8_t*) &value)[2]); written += mCircleBufferWrite8(buffer, ((int8_t*) &value)[2]);
written += CircleBufferWrite8(buffer, ((int8_t*) &value)[3]); written += mCircleBufferWrite8(buffer, ((int8_t*) &value)[3]);
return written; return written;
} }
*data = value; *data = value;
@ -97,15 +97,15 @@ int CircleBufferWrite32(struct CircleBuffer* buffer, int32_t value) {
return 4; return 4;
} }
int CircleBufferWrite16(struct CircleBuffer* buffer, int16_t value) { int mCircleBufferWrite16(struct mCircleBuffer* buffer, int16_t value) {
int16_t* data = buffer->writePtr; int16_t* data = buffer->writePtr;
if (buffer->size + sizeof(int16_t) > buffer->capacity) { if (buffer->size + sizeof(int16_t) > buffer->capacity) {
return 0; return 0;
} }
if (((intptr_t) data & 0x1) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int16_t)) { if (((intptr_t) data & 0x1) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int16_t)) {
int written = 0; int written = 0;
written += CircleBufferWrite8(buffer, ((int8_t*) &value)[0]); written += mCircleBufferWrite8(buffer, ((int8_t*) &value)[0]);
written += CircleBufferWrite8(buffer, ((int8_t*) &value)[1]); written += mCircleBufferWrite8(buffer, ((int8_t*) &value)[1]);
return written; return written;
} }
*data = value; *data = value;
@ -125,7 +125,7 @@ int CircleBufferWrite16(struct CircleBuffer* buffer, int16_t value) {
return 2; return 2;
} }
size_t CircleBufferWrite(struct CircleBuffer* buffer, const void* input, size_t length) { size_t mCircleBufferWrite(struct mCircleBuffer* buffer, const void* input, size_t length) {
int8_t* data = buffer->writePtr; int8_t* data = buffer->writePtr;
if (buffer->size + length > buffer->capacity) { if (buffer->size + length > buffer->capacity) {
return 0; return 0;
@ -153,14 +153,14 @@ size_t CircleBufferWrite(struct CircleBuffer* buffer, const void* input, size_t
return length; return length;
} }
size_t CircleBufferWriteTruncate(struct CircleBuffer* buffer, const void* input, size_t length) { size_t mCircleBufferWriteTruncate(struct mCircleBuffer* buffer, const void* input, size_t length) {
if (buffer->size + length > buffer->capacity) { if (buffer->size + length > buffer->capacity) {
length = buffer->capacity - buffer->size; length = buffer->capacity - buffer->size;
} }
return CircleBufferWrite(buffer, input, length); return mCircleBufferWrite(buffer, input, length);
} }
int CircleBufferRead8(struct CircleBuffer* buffer, int8_t* value) { int mCircleBufferRead8(struct mCircleBuffer* buffer, int8_t* value) {
int8_t* data = buffer->readPtr; int8_t* data = buffer->readPtr;
if (buffer->size < sizeof(int8_t)) { if (buffer->size < sizeof(int8_t)) {
return 0; return 0;
@ -182,15 +182,15 @@ int CircleBufferRead8(struct CircleBuffer* buffer, int8_t* value) {
return 1; return 1;
} }
int CircleBufferRead16(struct CircleBuffer* buffer, int16_t* value) { int mCircleBufferRead16(struct mCircleBuffer* buffer, int16_t* value) {
int16_t* data = buffer->readPtr; int16_t* data = buffer->readPtr;
if (buffer->size < sizeof(int16_t)) { if (buffer->size < sizeof(int16_t)) {
return 0; return 0;
} }
if (((intptr_t) data & 0x1) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int16_t)) { if (((intptr_t) data & 0x1) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int16_t)) {
int read = 0; int read = 0;
read += CircleBufferRead8(buffer, &((int8_t*) value)[0]); read += mCircleBufferRead8(buffer, &((int8_t*) value)[0]);
read += CircleBufferRead8(buffer, &((int8_t*) value)[1]); read += mCircleBufferRead8(buffer, &((int8_t*) value)[1]);
return read; return read;
} }
*value = *data; *value = *data;
@ -210,17 +210,17 @@ int CircleBufferRead16(struct CircleBuffer* buffer, int16_t* value) {
return 2; return 2;
} }
int CircleBufferRead32(struct CircleBuffer* buffer, int32_t* value) { int mCircleBufferRead32(struct mCircleBuffer* buffer, int32_t* value) {
int32_t* data = buffer->readPtr; int32_t* data = buffer->readPtr;
if (buffer->size < sizeof(int32_t)) { if (buffer->size < sizeof(int32_t)) {
return 0; return 0;
} }
if (((intptr_t) data & 0x3) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int32_t)) { if (((intptr_t) data & 0x3) || (uintptr_t) data - (uintptr_t) buffer->data > buffer->capacity - sizeof(int32_t)) {
int read = 0; int read = 0;
read += CircleBufferRead8(buffer, &((int8_t*) value)[0]); read += mCircleBufferRead8(buffer, &((int8_t*) value)[0]);
read += CircleBufferRead8(buffer, &((int8_t*) value)[1]); read += mCircleBufferRead8(buffer, &((int8_t*) value)[1]);
read += CircleBufferRead8(buffer, &((int8_t*) value)[2]); read += mCircleBufferRead8(buffer, &((int8_t*) value)[2]);
read += CircleBufferRead8(buffer, &((int8_t*) value)[3]); read += mCircleBufferRead8(buffer, &((int8_t*) value)[3]);
return read; return read;
} }
*value = *data; *value = *data;
@ -240,7 +240,7 @@ int CircleBufferRead32(struct CircleBuffer* buffer, int32_t* value) {
return 4; return 4;
} }
size_t CircleBufferRead(struct CircleBuffer* buffer, void* output, size_t length) { size_t mCircleBufferRead(struct mCircleBuffer* buffer, void* output, size_t length) {
int8_t* data = buffer->readPtr; int8_t* data = buffer->readPtr;
if (buffer->size == 0) { if (buffer->size == 0) {
return 0; return 0;
@ -271,7 +271,7 @@ size_t CircleBufferRead(struct CircleBuffer* buffer, void* output, size_t length
return length; return length;
} }
size_t CircleBufferDump(const struct CircleBuffer* buffer, void* output, size_t length, size_t offset) { size_t mCircleBufferDump(const struct mCircleBuffer* buffer, void* output, size_t length, size_t offset) {
int8_t* data = buffer->readPtr; int8_t* data = buffer->readPtr;
if (buffer->size <= offset) { if (buffer->size <= offset) {
return 0; return 0;

28
src/util/patch-ups.c
View File

@ -23,7 +23,7 @@ static size_t _UPSOutputSize(struct Patch* patch, size_t inSize);
static bool _UPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize); static bool _UPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize);
static bool _BPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize); static bool _BPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* out, size_t outSize);
static size_t _decodeLength(struct VFile* vf, struct CircleBuffer* buffer); static size_t _decodeLength(struct VFile* vf, struct mCircleBuffer* buffer);
bool loadPatchUPS(struct Patch* patch) { bool loadPatchUPS(struct Patch* patch) {
patch->vf->seek(patch->vf, 0, SEEK_SET); patch->vf->seek(patch->vf, 0, SEEK_SET);
@ -77,42 +77,42 @@ bool _UPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* ou
return false; return false;
} }
struct CircleBuffer buffer; struct mCircleBuffer buffer;
memcpy(out, in, inSize > outSize ? outSize : inSize); memcpy(out, in, inSize > outSize ? outSize : inSize);
size_t offset = 0; size_t offset = 0;
size_t alreadyRead = 0; size_t alreadyRead = 0;
uint8_t* buf = out; uint8_t* buf = out;
CircleBufferInit(&buffer, BUFFER_SIZE); mCircleBufferInit(&buffer, BUFFER_SIZE);
while (alreadyRead < filesize + IN_CHECKSUM) { while (alreadyRead < filesize + IN_CHECKSUM) {
offset += _decodeLength(patch->vf, &buffer); offset += _decodeLength(patch->vf, &buffer);
int8_t byte; int8_t byte;
while (true) { while (true) {
if (!CircleBufferSize(&buffer)) { if (!mCircleBufferSize(&buffer)) {
uint8_t block[BUFFER_SIZE]; uint8_t block[BUFFER_SIZE];
ssize_t read = patch->vf->read(patch->vf, block, sizeof(block)); ssize_t read = patch->vf->read(patch->vf, block, sizeof(block));
if (read < 1) { if (read < 1) {
CircleBufferDeinit(&buffer); mCircleBufferDeinit(&buffer);
return false; return false;
} }
CircleBufferWrite(&buffer, block, read); mCircleBufferWrite(&buffer, block, read);
} }
CircleBufferRead8(&buffer, &byte); mCircleBufferRead8(&buffer, &byte);
if (!byte) { if (!byte) {
break; break;
} }
if (offset >= outSize) { if (offset >= outSize) {
CircleBufferDeinit(&buffer); mCircleBufferDeinit(&buffer);
return false; return false;
} }
buf[offset] ^= byte; buf[offset] ^= byte;
++offset; ++offset;
} }
++offset; ++offset;
alreadyRead = patch->vf->seek(patch->vf, 0, SEEK_CUR) - CircleBufferSize(&buffer); alreadyRead = patch->vf->seek(patch->vf, 0, SEEK_CUR) - mCircleBufferSize(&buffer);
} }
CircleBufferDeinit(&buffer); mCircleBufferDeinit(&buffer);
uint32_t goodCrc32; uint32_t goodCrc32;
patch->vf->seek(patch->vf, OUT_CHECKSUM, SEEK_END); patch->vf->seek(patch->vf, OUT_CHECKSUM, SEEK_END);
@ -223,21 +223,21 @@ bool _BPSApplyPatch(struct Patch* patch, const void* in, size_t inSize, void* ou
return true; return true;
} }
size_t _decodeLength(struct VFile* vf, struct CircleBuffer* buffer) { size_t _decodeLength(struct VFile* vf, struct mCircleBuffer* buffer) {
size_t shift = 1; size_t shift = 1;
size_t value = 0; size_t value = 0;
uint8_t byte; uint8_t byte;
while (true) { while (true) {
if (buffer) { if (buffer) {
if (!CircleBufferSize(buffer)) { if (!mCircleBufferSize(buffer)) {
uint8_t block[BUFFER_SIZE]; uint8_t block[BUFFER_SIZE];
ssize_t read = vf->read(vf, block, sizeof(block)); ssize_t read = vf->read(vf, block, sizeof(block));
if (read < 1) { if (read < 1) {
return false; return false;
} }
CircleBufferWrite(buffer, block, read); mCircleBufferWrite(buffer, block, read);
} }
CircleBufferRead8(buffer, (int8_t*) &byte); mCircleBufferRead8(buffer, (int8_t*) &byte);
} else { } else {
if (vf->read(vf, &byte, 1) != 1) { if (vf->read(vf, &byte, 1) != 1) {
break; break;

868
src/util/test/circle-buffer.c
View File

File diff suppressed because it is too large Load Diff

12
src/util/vfs/vfs-fifo.c
View File

@ -8,7 +8,7 @@
struct VFileFIFO { struct VFileFIFO {
struct VFile d; struct VFile d;
struct CircleBuffer* backing; struct mCircleBuffer* backing;
}; };
static bool _vffClose(struct VFile* vf); static bool _vffClose(struct VFile* vf);
@ -21,7 +21,7 @@ static void _vffTruncate(struct VFile* vf, size_t size);
static ssize_t _vffSize(struct VFile* vf); static ssize_t _vffSize(struct VFile* vf);
static bool _vffSync(struct VFile* vf, void* buffer, size_t size); static bool _vffSync(struct VFile* vf, void* buffer, size_t size);
struct VFile* VFileFIFO(struct CircleBuffer* backing) { struct VFile* VFileFIFO(struct mCircleBuffer* backing) {
if (!backing) { if (!backing) {
return NULL; return NULL;
} }
@ -61,12 +61,12 @@ static off_t _vffSeek(struct VFile* vf, off_t offset, int whence) {
static ssize_t _vffRead(struct VFile* vf, void* buffer, size_t size) { static ssize_t _vffRead(struct VFile* vf, void* buffer, size_t size) {
struct VFileFIFO* vff = (struct VFileFIFO*) vf; struct VFileFIFO* vff = (struct VFileFIFO*) vf;
return CircleBufferRead(vff->backing, buffer, size); return mCircleBufferRead(vff->backing, buffer, size);
} }
static ssize_t _vffWrite(struct VFile* vf, const void* buffer, size_t size) { static ssize_t _vffWrite(struct VFile* vf, const void* buffer, size_t size) {
struct VFileFIFO* vff = (struct VFileFIFO*) vf; struct VFileFIFO* vff = (struct VFileFIFO*) vf;
return CircleBufferWrite(vff->backing, buffer, size); return mCircleBufferWrite(vff->backing, buffer, size);
} }
static void* _vffMap(struct VFile* vf, size_t size, int flags) { static void* _vffMap(struct VFile* vf, size_t size, int flags) {
@ -85,13 +85,13 @@ static void _vffUnmap(struct VFile* vf, void* memory, size_t size) {
static void _vffTruncate(struct VFile* vf, size_t size) { static void _vffTruncate(struct VFile* vf, size_t size) {
struct VFileFIFO* vff = (struct VFileFIFO*) vf; struct VFileFIFO* vff = (struct VFileFIFO*) vf;
if (!size) { if (!size) {
CircleBufferClear(vff->backing); mCircleBufferClear(vff->backing);
} }
} }
static ssize_t _vffSize(struct VFile* vf) { static ssize_t _vffSize(struct VFile* vf) {
struct VFileFIFO* vff = (struct VFileFIFO*) vf; struct VFileFIFO* vff = (struct VFileFIFO*) vf;
return CircleBufferSize(vff->backing); return mCircleBufferSize(vff->backing);
} }
static bool _vffSync(struct VFile* vf, void* buffer, size_t size) { static bool _vffSync(struct VFile* vf, void* buffer, size_t size) {