Fix heap corruption and crashes from thread safety issues

Add mutex synchronization to prevent concurrent access to projectM state:

- Add std::recursive_mutex to ProjectM class protecting RenderFrame,
  LoadPresetFile, LoadPresetData, SetWindowSize, SetPresetLocked,
  SetTexturePaths, ResetTextures, and BurnInTexture
- Add std::mutex to PCM class protecting audio buffer writes (Add) and
  reads (UpdateFrameAudioData) from concurrent audio/render threads
- Replace m_start from std::atomic<size_t> to plain size_t (now mutex-protected)
- Implement EvalLibMutex lock/unlock with actual std::mutex (was no-op stubs)
- Fix null pointer dereference in SpriteManager::Draw when m_transitioningPreset
  is nullptr after transition completes
- Expose RenderMutex() accessor for external synchronization

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Carmelo Piccione

src/libprojectM/Audio/PCM.cpp

@@ -1,5 +1,7 @@
 #include "Audio/PCM.hpp"
 
+#include <mutex>
+
 namespace libprojectM {
 namespace Audio {
 
@@ -17,6 +19,7 @@ void PCM::AddToBuffer(
         return;
     }
 
+    std::lock_guard<std::mutex> lock(m_pcmMutex);
     for (size_t i = 0; i < sampleCount; i++)
     {
         size_t const bufferOffset = (m_start + i) % AudioBufferSamples;
@@ -48,9 +51,12 @@ void PCM::Add(int16_t const* const samples, uint32_t channels, size_t const coun
 
 void PCM::UpdateFrameAudioData(double secondsSinceLastFrame, uint32_t frame)
 {
-    // 1. Copy audio data from input buffer
-    CopyNewWaveformData(m_inputBufferL, m_waveformL);
-    CopyNewWaveformData(m_inputBufferR, m_waveformR);
+    // 1. Copy audio data from input buffer (lock to prevent tearing with audio thread writes)
+    {
+        std::lock_guard<std::mutex> lock(m_pcmMutex);
+        CopyNewWaveformData(m_inputBufferL, m_waveformL);
+        CopyNewWaveformData(m_inputBufferR, m_waveformR);
+    }
 
     // 2. Update spectrum analyzer data for both channels
     UpdateSpectrum(m_waveformL, m_spectrumL);
@@ -110,7 +116,7 @@ void PCM::UpdateSpectrum(const WaveformBuffer& waveformData, SpectrumBuffer& spe
 
 void PCM::CopyNewWaveformData(const WaveformBuffer& source, WaveformBuffer& destination)
 {
-    auto const bufferStartIndex = m_start.load();
+    auto const bufferStartIndex = m_start;
 
     for (size_t i = 0; i < AudioBufferSamples; i++)
     {

src/libprojectM/Audio/PCM.hpp

@@ -18,6 +18,7 @@
 #include <atomic>
 #include <cstdint>
 #include <cstdlib>
+#include <mutex>
 
 
 namespace libprojectM {
@@ -89,10 +90,12 @@ class PCM
      */
     void CopyNewWaveformData(const WaveformBuffer& source, WaveformBuffer& destination);
 
+    std::mutex m_pcmMutex; //!< Protects the circular input buffer from concurrent access.
+
     // External input buffer
     WaveformBuffer m_inputBufferL{0.f}; //!< Circular buffer for left-channel PCM data.
     WaveformBuffer m_inputBufferR{0.f}; //!< Circular buffer for right-channel PCM data.
-    std::atomic<size_t> m_start{0};     //!< Circular buffer start index.
+    size_t m_start{0};                  //!< Circular buffer start index.
 
     // Frame waveform data
     WaveformBuffer m_waveformL{0.f}; //!< Left-channel waveform data, aligned. Only the first WaveformSamples number of samples are valid.

src/libprojectM/MilkdropPreset/EvalLibMutex.cpp

@@ -1,4 +1,15 @@
 #include <projectm-eval.h>
 
-void projectm_eval_memory_host_lock_mutex() {}
-void projectm_eval_memory_host_unlock_mutex() {}
+#include <mutex>
+
+static std::mutex s_evalMutex;
+
+void projectm_eval_memory_host_lock_mutex()
+{
+    s_evalMutex.lock();
+}
+
+void projectm_eval_memory_host_unlock_mutex()
+{
+    s_evalMutex.unlock();
+}

src/libprojectM/ProjectM.cpp

@@ -28,6 +28,8 @@
 
 #include <Audio/PCM.hpp>
 
+#include <mutex>
+
 #include <Renderer/CopyTexture.hpp>
 #include <Renderer/PresetTransition.hpp>
 #include <Renderer/ShaderCache.hpp>
@@ -59,6 +61,7 @@ void ProjectM::PresetSwitchFailedEvent(const std::string&, const std::string&) c
 
 void ProjectM::LoadPresetFile(const std::string& presetFilename, bool smoothTransition)
 {
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     try
     {
         m_textureManager->PurgeTextures();
@@ -73,6 +76,7 @@ void ProjectM::LoadPresetFile(const std::string& presetFilename, bool smoothTran
 
 void ProjectM::LoadPresetData(std::istream& presetData, bool smoothTransition)
 {
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     try
     {
         m_textureManager->PurgeTextures();
@@ -87,17 +91,21 @@ void ProjectM::LoadPresetData(std::istream& presetData, bool smoothTransition)
 
 void ProjectM::SetTexturePaths(std::vector<std::string> texturePaths)
 {
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     m_textureSearchPaths = std::move(texturePaths);
     m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
 }
 
 void ProjectM::ResetTextures()
 {
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
 }
 
 void ProjectM::RenderFrame(uint32_t targetFramebufferObject /*= 0*/)
 {
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
+
     // Don't render if window area is zero.
     if (m_windowWidth == 0 || m_windowHeight == 0)
     {
@@ -183,8 +191,15 @@ void ProjectM::RenderFrame(uint32_t targetFramebufferObject /*= 0*/)
         m_textureCopier->Draw(*renderContext.shaderCache, m_activePreset->OutputTexture(), false, false);
     }
 
-    // Draw user sprites
-    m_spriteManager->Draw(audioData, renderContext, targetFramebufferObject, {m_activePreset, m_transitioningPreset});
+    // Draw user sprites - only pass non-null presets to avoid dereferencing nullptr
+    if (m_transitioningPreset)
+    {
+        m_spriteManager->Draw(audioData, renderContext, targetFramebufferObject, {m_activePreset, m_transitioningPreset});
+    }
+    else
+    {
+        m_spriteManager->Draw(audioData, renderContext, targetFramebufferObject, {m_activePreset});
+    }
 
     m_frameCount++;
     m_previousFrameVolume = audioData.vol;
@@ -251,7 +266,7 @@ void ProjectM::LoadIdlePreset()
 
 void ProjectM::SetWindowSize(uint32_t width, uint32_t height)
 {
-    /** Stash the new dimensions */
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     m_windowWidth = width;
     m_windowHeight = height;
 }
@@ -339,6 +354,7 @@ auto ProjectM::UserSpriteIdentifiers() const -> std::vector<uint32_t>
 
 void ProjectM::BurnInTexture(uint32_t openGlTextureId, int left, int top, int width, int height)
 {
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     if (m_activePreset)
     {
         m_activePreset->BindFramebuffer();
@@ -356,8 +372,7 @@ void ProjectM::BurnInTexture(uint32_t openGlTextureId, int left, int top, int wi
 
 void ProjectM::SetPresetLocked(bool locked)
 {
-    // ToDo: Add a preset switch timer separate from the display timer and reset to 0 when
-    //       disabling the preset switch lock.
+    std::lock_guard<std::recursive_mutex> lock(m_renderMutex);
     m_presetLocked = locked;
     m_presetChangeNotified = locked;
 }
@@ -514,6 +529,11 @@ auto ProjectM::PCM() -> libprojectM::Audio::PCM&
     return m_audioStorage;
 }
 
+auto ProjectM::RenderMutex() -> std::recursive_mutex&
+{
+    return m_renderMutex;
+}
+
 void ProjectM::Touch(float, float, int, int)
 {
     // UNIMPLEMENTED

src/libprojectM/ProjectM.hpp

@@ -27,6 +27,7 @@
 #include <Audio/PCM.hpp>
 
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -196,6 +197,14 @@ class PROJECTM_EXPORT ProjectM
 
     auto PCM() -> Audio::PCM&;
 
+    /**
+     * @brief Returns a reference to the render mutex for external synchronization.
+     *
+     * This mutex must be held when calling any method that modifies or reads projectM state
+     * from a thread other than the render thread (e.g., loading presets, adding PCM data).
+     */
+    auto RenderMutex() -> std::recursive_mutex&;
+
     auto WindowWidth() -> int;
 
     auto WindowHeight() -> int;
@@ -291,6 +300,8 @@ class PROJECTM_EXPORT ProjectM
     bool m_presetLocked{false};         //!< If true, the preset change event will not be sent.
     bool m_presetChangeNotified{false}; //!< Stores whether the user has been notified that projectM wants to switch the preset.
 
+    std::recursive_mutex m_renderMutex; //!< Protects all projectM state from concurrent access across threads.
+
     std::unique_ptr<PresetFactoryManager> m_presetFactoryManager; //!< Provides access to all available preset factories.
 
     Audio::PCM m_audioStorage;                                                    //!< Audio data buffer and analyzer instance.

src/libprojectM/ProjectMCWrapper.cpp

@@ -393,7 +393,6 @@ template<class BufferType>
 static auto PcmAdd(projectm_handle instance, const BufferType* samples, unsigned int count, projectm_channels channels) -> void
 {
     auto* projectMInstance = handle_to_instance(instance);
-
     projectMInstance->PCM().Add(samples, channels, count);
 }