Replaced std mutexes and lock guards with SDL_mutex, since they weren't working properly on Vita

Northfear · Northfear · commit 210256177786 · 2024-06-02T10:55:56.000+03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -310,8 +310,7 @@ if(WIN32)
 endif()
 
 if(VITA)
-    #set(VITA_FLAGS "-Ofast -mcpu=cortex-a9 -mfpu=neon -fgraphite-identity -floop-parallelize-all -floop-nest-optimize -ftree-parallelize-loops=3 -flto -fno-peephole2 -DNDEBUG")
-    set(VITA_FLAGS "-O2 -g -mcpu=cortex-a9 -mfpu=neon -fno-peephole2 -DNDEBUG")
+    set(VITA_FLAGS "-O2 -mcpu=cortex-a9 -mfpu=neon -DNDEBUG")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${VITA_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VITA_FLAGS}")
 
diff --git a/src/audio_engine.cc b/src/audio_engine.cc
@@ -2,8 +2,6 @@
 
 #include <string.h>
 
-#include <mutex>
-
 #include <SDL.h>
 
 namespace fallout {
@@ -22,7 +20,7 @@ struct AudioEngineSoundBuffer {
     bool looping;
     unsigned int pos;
     SDL_AudioStream* stream;
-    std::recursive_mutex mutex;
+    SDL_mutex* mutex;
 };
 
 extern bool gProgramIsActive;
@@ -54,7 +52,10 @@ static void audioEngineMixin(void* userData, Uint8* stream, int length)
 
     for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {
         AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);
-        std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+        // for some strange reason std::lock_guard isn't locking the mutex properly on Vita
+        // which results in audioEngineSoundBufferRelease call during this loop and subsequent crash
+        // replacing the std::recursive_mutex with SDL_mutex is fixing this issue
+        SDL_LockMutex(soundBuffer->mutex);
 
         if (soundBuffer->active && soundBuffer->playing) {
             int srcFrameSize = soundBuffer->bitsPerSample / 8 * soundBuffer->channels;
@@ -90,11 +91,18 @@ static void audioEngineMixin(void* userData, Uint8* stream, int length)
                 pos += bytesRead;
             }
         }
+
+        SDL_UnlockMutex(soundBuffer->mutex);
     }
 }
 
 bool audioEngineInit()
 {
+    for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {
+        AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);
+        soundBuffer->mutex = SDL_CreateMutex();
+    }
+
     if (SDL_InitSubSystem(SDL_INIT_AUDIO) == -1) {
         return false;
     }
@@ -126,6 +134,11 @@ void audioEngineExit()
     if (SDL_WasInit(SDL_INIT_AUDIO)) {
         SDL_QuitSubSystem(SDL_INIT_AUDIO);
     }
+
+    for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {
+        AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);
+        SDL_DestroyMutex(soundBuffer->mutex);
+    }
 }
 
 void audioEnginePause()
@@ -150,7 +163,7 @@ int audioEngineCreateSoundBuffer(unsigned int size, int bitsPerSample, int chann
 
     for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {
         AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);
-        std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+        SDL_LockMutex(soundBuffer->mutex);
 
         if (!soundBuffer->active) {
             soundBuffer->active = true;
@@ -164,8 +177,11 @@ int audioEngineCreateSoundBuffer(unsigned int size, int bitsPerSample, int chann
             soundBuffer->pos = 0;
             soundBuffer->data = malloc(size);
             soundBuffer->stream = SDL_NewAudioStream(bitsPerSample == 16 ? AUDIO_S16 : AUDIO_S8, channels, rate, gAudioEngineSpec.format, gAudioEngineSpec.channels, gAudioEngineSpec.freq);
+            SDL_UnlockMutex(soundBuffer->mutex);
             return index;
         }
+
+        SDL_UnlockMutex(soundBuffer->mutex);
     }
 
     return -1;
@@ -182,9 +198,10 @@ bool audioEngineSoundBufferRelease(int soundBufferIndex)
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
@@ -196,6 +213,7 @@ bool audioEngineSoundBufferRelease(int soundBufferIndex)
     SDL_FreeAudioStream(soundBuffer->stream);
     soundBuffer->stream = nullptr;
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -210,14 +228,16 @@ bool audioEngineSoundBufferSetVolume(int soundBufferIndex, int volume)
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     soundBuffer->volume = volume;
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -232,14 +252,16 @@ bool audioEngineSoundBufferGetVolume(int soundBufferIndex, int* volumePtr)
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     *volumePtr = soundBuffer->volume;
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -254,15 +276,17 @@ bool audioEngineSoundBufferSetPan(int soundBufferIndex, int pan)
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     // NOTE: Audio engine does not support sound panning. I'm not sure it's
     // even needed. For now this value is silently ignored.
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -277,9 +301,10 @@ bool audioEngineSoundBufferPlay(int soundBufferIndex, unsigned int flags)
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
@@ -289,6 +314,7 @@ bool audioEngineSoundBufferPlay(int soundBufferIndex, unsigned int flags)
         soundBuffer->looping = true;
     }
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -303,14 +329,16 @@ bool audioEngineSoundBufferStop(int soundBufferIndex)
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     soundBuffer->playing = false;
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -325,9 +353,10 @@ bool audioEngineSoundBufferGetCurrentPosition(int soundBufferIndex, unsigned int
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
@@ -346,6 +375,7 @@ bool audioEngineSoundBufferGetCurrentPosition(int soundBufferIndex, unsigned int
         }
     }
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -360,14 +390,16 @@ bool audioEngineSoundBufferSetCurrentPosition(int soundBufferIndex, unsigned int
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     soundBuffer->pos = pos % soundBuffer->size;
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -382,18 +414,21 @@ bool audioEngineSoundBufferLock(int soundBufferIndex, unsigned int writePos, uns
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     if (audioBytes1 == nullptr) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     if ((flags & AUDIO_ENGINE_SOUND_BUFFER_LOCK_FROM_WRITE_POS) != 0) {
         if (!audioEngineSoundBufferGetCurrentPosition(soundBufferIndex, nullptr, &writePos)) {
+            SDL_UnlockMutex(soundBuffer->mutex);
             return false;
         }
     }
@@ -429,6 +464,7 @@ bool audioEngineSoundBufferLock(int soundBufferIndex, unsigned int writePos, uns
 
     // TODO: Mark range as locked.
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -443,14 +479,16 @@ bool audioEngineSoundBufferUnlock(int soundBufferIndex, void* audioPtr1, unsigne
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     // TODO: Mark range as unlocked.
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
@@ -465,13 +503,15 @@ bool audioEngineSoundBufferGetStatus(int soundBufferIndex, unsigned int* statusP
     }
 
     AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);
-    std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);
+    SDL_LockMutex(soundBuffer->mutex);
 
     if (!soundBuffer->active) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
     if (statusPtr == nullptr) {
+        SDL_UnlockMutex(soundBuffer->mutex);
         return false;
     }
 
@@ -485,6 +525,7 @@ bool audioEngineSoundBufferGetStatus(int soundBufferIndex, unsigned int* statusP
         }
     }
 
+    SDL_UnlockMutex(soundBuffer->mutex);
     return true;
 }
 
diff --git a/vita/vita.cmake b/vita/vita.cmake
@@ -4,7 +4,7 @@ set(VITA_APP_NAME "Fallout 2 CE")
 set(VITA_TITLEID  "FOUT00002")
 
 set(EXECUTABLE_NAME fallout2-ce)
-set(VITA_VERSION "01.00")
+set(VITA_VERSION "01.30")
 set(VITA_MKSFOEX_FLAGS "-d ATTRIBUTE2=12")
 
 vita_create_self(${EXECUTABLE_NAME}.self ${EXECUTABLE_NAME})

Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,6 @@`
`2`	`2`
`3`	`3`	`#include <string.h>`
`4`	`4`
`5`		`-#include <mutex>`
`6`		`-`
`7`	`5`	`#include <SDL.h>`
`8`	`6`
`9`	`7`	`namespace fallout {`
`@@ -22,7 +20,7 @@ struct AudioEngineSoundBuffer {`
`22`	`20`	`bool looping;`
`23`	`21`	`unsigned int pos;`
`24`	`22`	`SDL_AudioStream* stream;`
`25`		`- std::recursive_mutex mutex;`
	`23`	`+ SDL_mutex* mutex;`
`26`	`24`	`};`
`27`	`25`
`28`	`26`	`extern bool gProgramIsActive;`
`@@ -54,7 +52,10 @@ static void audioEngineMixin(void* userData, Uint8* stream, int length)`
`54`	`52`
`55`	`53`	`for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {`
`56`	`54`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);`
`57`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`55`	`+ // for some strange reason std::lock_guard isn't locking the mutex properly on Vita`
	`56`	`+ // which results in audioEngineSoundBufferRelease call during this loop and subsequent crash`
	`57`	`+ // replacing the std::recursive_mutex with SDL_mutex is fixing this issue`
	`58`	`+ SDL_LockMutex(soundBuffer->mutex);`
`58`	`59`
`59`	`60`	`if (soundBuffer->active && soundBuffer->playing) {`
`60`	`61`	`int srcFrameSize = soundBuffer->bitsPerSample / 8 * soundBuffer->channels;`
`@@ -90,11 +91,18 @@ static void audioEngineMixin(void* userData, Uint8* stream, int length)`
`90`	`91`	`pos += bytesRead;`
`91`	`92`	`}`
`92`	`93`	`}`
	`94`	`+`
	`95`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`93`	`96`	`}`
`94`	`97`	`}`
`95`	`98`
`96`	`99`	`bool audioEngineInit()`
`97`	`100`	`{`
	`101`	`+ for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {`
	`102`	`+ AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);`
	`103`	`+ soundBuffer->mutex = SDL_CreateMutex();`
	`104`	`+ }`
	`105`	`+`
`98`	`106`	`if (SDL_InitSubSystem(SDL_INIT_AUDIO) == -1) {`
`99`	`107`	`return false;`
`100`	`108`	`}`
`@@ -126,6 +134,11 @@ void audioEngineExit()`
`126`	`134`	`if (SDL_WasInit(SDL_INIT_AUDIO)) {`
`127`	`135`	`SDL_QuitSubSystem(SDL_INIT_AUDIO);`
`128`	`136`	`}`
	`137`	`+`
	`138`	`+ for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {`
	`139`	`+ AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);`
	`140`	`+ SDL_DestroyMutex(soundBuffer->mutex);`
	`141`	`+ }`
`129`	`142`	`}`
`130`	`143`
`131`	`144`	`void audioEnginePause()`
`@@ -150,7 +163,7 @@ int audioEngineCreateSoundBuffer(unsigned int size, int bitsPerSample, int chann`
`150`	`163`
`151`	`164`	`for (int index = 0; index < AUDIO_ENGINE_SOUND_BUFFERS; index++) {`
`152`	`165`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[index]);`
`153`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`166`	`+ SDL_LockMutex(soundBuffer->mutex);`
`154`	`167`
`155`	`168`	`if (!soundBuffer->active) {`
`156`	`169`	`soundBuffer->active = true;`
`@@ -164,8 +177,11 @@ int audioEngineCreateSoundBuffer(unsigned int size, int bitsPerSample, int chann`
`164`	`177`	`soundBuffer->pos = 0;`
`165`	`178`	`soundBuffer->data = malloc(size);`
`166`	`179`	`soundBuffer->stream = SDL_NewAudioStream(bitsPerSample == 16 ? AUDIO_S16 : AUDIO_S8, channels, rate, gAudioEngineSpec.format, gAudioEngineSpec.channels, gAudioEngineSpec.freq);`
	`180`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`167`	`181`	`return index;`
`168`	`182`	`}`
	`183`	`+`
	`184`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`169`	`185`	`}`
`170`	`186`
`171`	`187`	`return -1;`
`@@ -182,9 +198,10 @@ bool audioEngineSoundBufferRelease(int soundBufferIndex)`
`182`	`198`	`}`
`183`	`199`
`184`	`200`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`185`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`201`	`+ SDL_LockMutex(soundBuffer->mutex);`
`186`	`202`
`187`	`203`	`if (!soundBuffer->active) {`
	`204`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`188`	`205`	`return false;`
`189`	`206`	`}`
`190`	`207`
`@@ -196,6 +213,7 @@ bool audioEngineSoundBufferRelease(int soundBufferIndex)`
`196`	`213`	`SDL_FreeAudioStream(soundBuffer->stream);`
`197`	`214`	`soundBuffer->stream = nullptr;`
`198`	`215`
	`216`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`199`	`217`	`return true;`
`200`	`218`	`}`
`201`	`219`
`@@ -210,14 +228,16 @@ bool audioEngineSoundBufferSetVolume(int soundBufferIndex, int volume)`
`210`	`228`	`}`
`211`	`229`
`212`	`230`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`213`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`231`	`+ SDL_LockMutex(soundBuffer->mutex);`
`214`	`232`
`215`	`233`	`if (!soundBuffer->active) {`
	`234`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`216`	`235`	`return false;`
`217`	`236`	`}`
`218`	`237`
`219`	`238`	`soundBuffer->volume = volume;`
`220`	`239`
	`240`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`221`	`241`	`return true;`
`222`	`242`	`}`
`223`	`243`
`@@ -232,14 +252,16 @@ bool audioEngineSoundBufferGetVolume(int soundBufferIndex, int* volumePtr)`
`232`	`252`	`}`
`233`	`253`
`234`	`254`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`235`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`255`	`+ SDL_LockMutex(soundBuffer->mutex);`
`236`	`256`
`237`	`257`	`if (!soundBuffer->active) {`
	`258`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`238`	`259`	`return false;`
`239`	`260`	`}`
`240`	`261`
`241`	`262`	`*volumePtr = soundBuffer->volume;`
`242`	`263`
	`264`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`243`	`265`	`return true;`
`244`	`266`	`}`
`245`	`267`
`@@ -254,15 +276,17 @@ bool audioEngineSoundBufferSetPan(int soundBufferIndex, int pan)`
`254`	`276`	`}`
`255`	`277`
`256`	`278`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`257`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`279`	`+ SDL_LockMutex(soundBuffer->mutex);`
`258`	`280`
`259`	`281`	`if (!soundBuffer->active) {`
	`282`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`260`	`283`	`return false;`
`261`	`284`	`}`
`262`	`285`
`263`	`286`	`// NOTE: Audio engine does not support sound panning. I'm not sure it's`
`264`	`287`	`// even needed. For now this value is silently ignored.`
`265`	`288`
	`289`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`266`	`290`	`return true;`
`267`	`291`	`}`
`268`	`292`
`@@ -277,9 +301,10 @@ bool audioEngineSoundBufferPlay(int soundBufferIndex, unsigned int flags)`
`277`	`301`	`}`
`278`	`302`
`279`	`303`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`280`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`304`	`+ SDL_LockMutex(soundBuffer->mutex);`
`281`	`305`
`282`	`306`	`if (!soundBuffer->active) {`
	`307`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`283`	`308`	`return false;`
`284`	`309`	`}`
`285`	`310`
`@@ -289,6 +314,7 @@ bool audioEngineSoundBufferPlay(int soundBufferIndex, unsigned int flags)`
`289`	`314`	`soundBuffer->looping = true;`
`290`	`315`	`}`
`291`	`316`
	`317`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`292`	`318`	`return true;`
`293`	`319`	`}`
`294`	`320`
`@@ -303,14 +329,16 @@ bool audioEngineSoundBufferStop(int soundBufferIndex)`
`303`	`329`	`}`
`304`	`330`
`305`	`331`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`306`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`332`	`+ SDL_LockMutex(soundBuffer->mutex);`
`307`	`333`
`308`	`334`	`if (!soundBuffer->active) {`
	`335`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`309`	`336`	`return false;`
`310`	`337`	`}`
`311`	`338`
`312`	`339`	`soundBuffer->playing = false;`
`313`	`340`
	`341`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`314`	`342`	`return true;`
`315`	`343`	`}`
`316`	`344`
`@@ -325,9 +353,10 @@ bool audioEngineSoundBufferGetCurrentPosition(int soundBufferIndex, unsigned int`
`325`	`353`	`}`
`326`	`354`
`327`	`355`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`328`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`356`	`+ SDL_LockMutex(soundBuffer->mutex);`
`329`	`357`
`330`	`358`	`if (!soundBuffer->active) {`
	`359`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`331`	`360`	`return false;`
`332`	`361`	`}`
`333`	`362`
`@@ -346,6 +375,7 @@ bool audioEngineSoundBufferGetCurrentPosition(int soundBufferIndex, unsigned int`
`346`	`375`	`}`
`347`	`376`	`}`
`348`	`377`
	`378`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`349`	`379`	`return true;`
`350`	`380`	`}`
`351`	`381`
`@@ -360,14 +390,16 @@ bool audioEngineSoundBufferSetCurrentPosition(int soundBufferIndex, unsigned int`
`360`	`390`	`}`
`361`	`391`
`362`	`392`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`363`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`393`	`+ SDL_LockMutex(soundBuffer->mutex);`
`364`	`394`
`365`	`395`	`if (!soundBuffer->active) {`
	`396`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`366`	`397`	`return false;`
`367`	`398`	`}`
`368`	`399`
`369`	`400`	`soundBuffer->pos = pos % soundBuffer->size;`
`370`	`401`
	`402`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`371`	`403`	`return true;`
`372`	`404`	`}`
`373`	`405`
`@@ -382,18 +414,21 @@ bool audioEngineSoundBufferLock(int soundBufferIndex, unsigned int writePos, uns`
`382`	`414`	`}`
`383`	`415`
`384`	`416`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`385`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`417`	`+ SDL_LockMutex(soundBuffer->mutex);`
`386`	`418`
`387`	`419`	`if (!soundBuffer->active) {`
	`420`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`388`	`421`	`return false;`
`389`	`422`	`}`
`390`	`423`
`391`	`424`	`if (audioBytes1 == nullptr) {`
	`425`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`392`	`426`	`return false;`
`393`	`427`	`}`
`394`	`428`
`395`	`429`	`if ((flags & AUDIO_ENGINE_SOUND_BUFFER_LOCK_FROM_WRITE_POS) != 0) {`
`396`	`430`	`if (!audioEngineSoundBufferGetCurrentPosition(soundBufferIndex, nullptr, &writePos)) {`
	`431`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`397`	`432`	`return false;`
`398`	`433`	`}`
`399`	`434`	`}`
`@@ -429,6 +464,7 @@ bool audioEngineSoundBufferLock(int soundBufferIndex, unsigned int writePos, uns`
`429`	`464`
`430`	`465`	`// TODO: Mark range as locked.`
`431`	`466`
	`467`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`432`	`468`	`return true;`
`433`	`469`	`}`
`434`	`470`
`@@ -443,14 +479,16 @@ bool audioEngineSoundBufferUnlock(int soundBufferIndex, void* audioPtr1, unsigne`
`443`	`479`	`}`
`444`	`480`
`445`	`481`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`446`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`482`	`+ SDL_LockMutex(soundBuffer->mutex);`
`447`	`483`
`448`	`484`	`if (!soundBuffer->active) {`
	`485`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`449`	`486`	`return false;`
`450`	`487`	`}`
`451`	`488`
`452`	`489`	`// TODO: Mark range as unlocked.`
`453`	`490`
	`491`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`454`	`492`	`return true;`
`455`	`493`	`}`
`456`	`494`
`@@ -465,13 +503,15 @@ bool audioEngineSoundBufferGetStatus(int soundBufferIndex, unsigned int* statusP`
`465`	`503`	`}`
`466`	`504`
`467`	`505`	`AudioEngineSoundBuffer* soundBuffer = &(gAudioEngineSoundBuffers[soundBufferIndex]);`
`468`		`- std::lock_guard<std::recursive_mutex> lock(soundBuffer->mutex);`
	`506`	`+ SDL_LockMutex(soundBuffer->mutex);`
`469`	`507`
`470`	`508`	`if (!soundBuffer->active) {`
	`509`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`471`	`510`	`return false;`
`472`	`511`	`}`
`473`	`512`
`474`	`513`	`if (statusPtr == nullptr) {`
	`514`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`475`	`515`	`return false;`
`476`	`516`	`}`
`477`	`517`
`@@ -485,6 +525,7 @@ bool audioEngineSoundBufferGetStatus(int soundBufferIndex, unsigned int* statusP`
`485`	`525`	`}`
`486`	`526`	`}`
`487`	`527`
	`528`	`+ SDL_UnlockMutex(soundBuffer->mutex);`
`488`	`529`	`return true;`
`489`	`530`	`}`
`490`	`531`