Update V1.5.3

Author: fiverecords

ArtnetOutput.h

@@ -338,7 +338,7 @@ class ArtnetOutput : public juce::HighResolutionTimer
     std::atomic<FrameRate> currentFps { FrameRate::FPS_25 };
     std::atomic<double> lastFrameSendTime { 0.0 };
     std::atomic<uint32_t> sendErrors { 0 };
-    uint8_t dmxSequence = 0;  // incrementing 1-255 for OpDmx sequencing
+    uint8_t dmxSequence = 0;  // incrementing 1-255 for OpDmx sequencing (message-thread-only currently, but atomic-safe for future use)
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ArtnetOutput)
 };

DbServerClient.h

@@ -219,6 +219,45 @@ class DbServerClient : private juce::Thread
         return {};
     }
 
+    /// Lightweight metadata lookup -- returns text fields and IDs only,
+    /// skipping the waveform vector copy.  Use when you only need artist/title/
+    /// key/BPM/artworkId (e.g. from getActiveTrackInfo at 60Hz).
+    struct MetadataLight
+    {
+        uint32_t trackId = 0;
+        juce::String title, artist, album, genre, key;
+        int bpmTimes100 = 0;
+        uint32_t artworkId = 0;
+        int durationSeconds = 0;
+        bool valid = false;
+        bool isValid() const { return valid; }
+    };
+
+    MetadataLight getCachedMetadataLightById(uint32_t trackId) const
+    {
+        if (trackId == 0) return {};
+        const juce::SpinLock::ScopedLockType lock(cacheLock);
+        for (auto& [key, meta] : metadataCache)
+        {
+            if (meta.trackId == trackId && meta.isValid())
+            {
+                MetadataLight m;
+                m.trackId         = meta.trackId;
+                m.title           = meta.title;
+                m.artist          = meta.artist;
+                m.album           = meta.album;
+                m.genre           = meta.genre;
+                m.key             = meta.key;
+                m.bpmTimes100     = meta.bpmTimes100;
+                m.artworkId       = meta.artworkId;
+                m.durationSeconds = meta.durationSeconds;
+                m.valid           = true;
+                return m;
+            }
+        }
+        return {};
+    }
+
     //==========================================================================
     // Retrieve cached artwork (returns null Image if not cached)
     //==========================================================================

LtcOutput.h

@@ -110,8 +110,8 @@ class LtcOutput : private juce::AudioIODeviceCallback
     /// Call when resuming from pause to avoid continuing a stale half-encoded frame.
     void reseed()
     {
-        needNewFrame = true;
-        encoderSeeded = false;
+        needNewFrame.store(true, std::memory_order_relaxed);
+        encoderSeeded.store(false, std::memory_order_relaxed);
     }
 
     void setPaused(bool p)
@@ -148,30 +148,34 @@ class LtcOutput : private juce::AudioIODeviceCallback
     std::atomic<float> peakLevel { 0.0f };
     std::atomic<double> pitchMultiplier { 1.0 };
 
-    // LTC encoder state -- audio-callback-thread-only (no synchronisation needed)
+    // LTC encoder state -- mostly audio-callback-thread-only.
+    // EXCEPTION: needNewFrame and encoderSeeded are also written by reseed()
+    // from the message thread, so they must be atomic to avoid data races
+    // (especially on ARM / Apple Silicon where non-atomic cross-thread writes
+    // can produce torn reads).
     static constexpr int LTC_FRAME_BITS = 80;
     uint8_t frameBits[LTC_FRAME_BITS] = {};
     int currentBitIndex = 0;
     int halfCellIndex = 0;
     double samplePositionInHalfBit = 0.0;
     double samplesPerHalfBit = 0.0;
     float currentLevel = 1.0f;
-    bool needNewFrame = true;
+    std::atomic<bool> needNewFrame { true };
     static constexpr float baseAmplitude = 0.8f;
 
     // Auto-increment state: the encoder maintains its own running timecode
     // to avoid repeating frames when the UI thread lags behind the audio clock
     Timecode encoderTc;
-    bool encoderSeeded = false;
+    std::atomic<bool> encoderSeeded { false };
 
     void resetEncoder()
     {
         currentBitIndex = 0;
         halfCellIndex = 0;
         samplePositionInHalfBit = 0.0;
         currentLevel = 1.0f;
-        needNewFrame = true;
-        encoderSeeded = false;
+        needNewFrame.store(true, std::memory_order_relaxed);
+        encoderSeeded.store(false, std::memory_order_relaxed);
         encoderTc = Timecode();
         updateSamplesPerBit();
     }
@@ -190,10 +194,10 @@ class LtcOutput : private juce::AudioIODeviceCallback
         FrameRate fps = pendingFps.load(std::memory_order_relaxed);
         Timecode pendingTc = unpackTimecode(packedPendingTc.load(std::memory_order_relaxed));
 
-        if (!encoderSeeded)
+        if (!encoderSeeded.load(std::memory_order_relaxed))
         {
             encoderTc = pendingTc;
-            encoderSeeded = true;
+            encoderSeeded.store(true, std::memory_order_relaxed);
         }
         else
         {
@@ -320,14 +324,14 @@ class LtcOutput : private juce::AudioIODeviceCallback
         float peak = 0.0f;
         for (int i = 0; i < numSamples; ++i)
         {
-            if (needNewFrame)
+            if (needNewFrame.load(std::memory_order_relaxed))
             {
                 updateSamplesPerBit();
                 packFrame();
                 currentBitIndex = 0;
                 halfCellIndex = 0;
                 samplePositionInHalfBit = 0.0;
-                needNewFrame = false;
+                needNewFrame.store(false, std::memory_order_relaxed);
                 // Do NOT invert currentLevel here -- the mandatory start-of-bit
                 // transition for bit 0 was already applied when the previous
                 // frame's last bit completed (halfCellIndex 1 -> 0 branch).
@@ -362,7 +366,7 @@ class LtcOutput : private juce::AudioIODeviceCallback
                     currentLevel = -currentLevel;
 
                     if (currentBitIndex >= LTC_FRAME_BITS)
-                        needNewFrame = true;
+                        needNewFrame.store(true, std::memory_order_relaxed);
                 }
             }
         }

Main.cpp

@@ -11,7 +11,7 @@ class SuperTimecodeConverterApplication : public juce::JUCEApplication
     SuperTimecodeConverterApplication() {}
 
     const juce::String getApplicationName() override    { return "Super Timecode Converter"; }
-    const juce::String getApplicationVersion() override { return "1.5.2"; }
+    const juce::String getApplicationVersion() override { return "1.5.3"; }
     bool moreThanOneInstanceAllowed() override           { return false; }
 
     void initialise(const juce::String&) override

MainComponent.cpp

@@ -939,26 +939,33 @@ MainComponent::MainComponent()
     startTimerHz(60);
     startAudioDeviceScan();
 
-    // GPU-accelerated rendering (Windows only).
-    // On Windows, JUCE's OpenGL context offloads image compositing from GDI
-    // to the GPU, reducing message-thread load from repaint().
-    // On macOS, this is DISABLED: JUCE still renders into software images
-    // and then uploads them as textures through Apple's deprecated
-    // OpenGL-to-Metal translation layer, which adds overhead rather than
-    // reducing it.  CoreGraphics already uses Metal internally for
-    // compositing, so native rendering is faster without OpenGL.
-#if JUCE_WINDOWS
-    glContext.attachTo(*this);
-#endif
+    // GPU-accelerated rendering: DISABLED for thread safety.
+    //
+    // When glContext.attachTo(*this) is active, JUCE calls paint() for ALL
+    // child components on the OpenGL thread -- not the message thread.
+    // Meanwhile, timerCallback() writes juce::String members (artist, title,
+    // playState, sourceName, etc.) on the message thread.  juce::String is
+    // reference-counted: a concurrent read during write can corrupt the
+    // refcount and crash.  This affects TimecodeDisplay, ProDJLinkView,
+    // all juce::Label instances, and any component that reads String data
+    // in paint().
+    //
+    // JUCE's OpenGL renderer paints into software images on the CPU and
+    // only uses the GPU for the final texture upload + composite.  With
+    // the waveform image cache, HiDPI deck image cache, and targeted
+    // dirty-rect repainting already in place, the performance difference
+    // is negligible.  Windows DWM already hardware-accelerates the native
+    // GDI composite path.
+    //
+    // For a live performance application, eliminating the entire class of
+    // GL-thread data races is worth more than the marginal compositing
+    // speedup.  If GPU acceleration is ever re-enabled, all juce::String
+    // members read in paint() must be replaced with atomic-safe types
+    // (fixed char arrays, packed atomics, or a SpinLock-protected snapshot).
 }
 
 MainComponent::~MainComponent()
 {
-    // 0. Detach OpenGL before destroying any components (Windows only)
-#if JUCE_WINDOWS
-    glContext.detach();
-#endif
-
     // 1. Stop our UI timer first -- no more timerCallback() after this
     stopTimer();
 
@@ -1021,9 +1028,15 @@ MainComponent::~MainComponent()
     // 9. Explicitly shut down each engine (timers, threads, sockets)
     //    BEFORE engines.clear() destroys the objects, so all HighResolutionTimer
     //    threads are stopped while the message manager is still alive.
+    //    Also disconnect shared pointers (TrackMap, MixerMap, ProDJLink, DbServer)
+    //    so no stale references survive into AppSettings destruction.
     for (auto& eng : engines)
     {
         eng->setMidiClockEnabled(false);
+        eng->setTrackMap(nullptr);
+        eng->setMixerMap(nullptr);
+        eng->setSharedProDJLinkInput(nullptr);
+        eng->setDbServerClient(nullptr);
         eng->stopMtcOutput();
         eng->stopArtnetOutput();
         eng->stopLtcOutput();
@@ -1033,7 +1046,7 @@ MainComponent::~MainComponent()
         eng->stopLtcInput();
     }
 
-    // 9. Now safe to destroy engine objects
+    // 10. Now safe to destroy engine objects
     engines.clear();
 }
 
@@ -1083,6 +1096,12 @@ void MainComponent::removeEngine(int index)
 
     // Explicitly stop all protocols on the engine being deleted BEFORE
     // erasing it, so destructors don't race with any pending callbacks.
+    // Disconnect shared pointers first to prevent stale access during stop.
+    engines[(size_t)index]->setTrackMap(nullptr);
+    engines[(size_t)index]->setMixerMap(nullptr);
+    engines[(size_t)index]->setSharedProDJLinkInput(nullptr);
+    engines[(size_t)index]->setDbServerClient(nullptr);
+    engines[(size_t)index]->setMidiClockEnabled(false);
     engines[(size_t)index]->getTriggerOutput().setSharedMidiOutput(nullptr);
     engines[(size_t)index]->stopMtcOutput();
     engines[(size_t)index]->stopArtnetOutput();
@@ -1732,7 +1751,7 @@ void MainComponent::openMixerMapEditor()
     }
 
     auto* editor = new MixerMapEditor(sharedMixerMap,
-                                      sharedProDJLinkInput.getMixerChannelCount() > 4);
+                                      djmModelFromString(sharedProDJLinkInput.getDJMModel()));
     editor->onChange = [this]
     {
         sharedMixerMap.save();
@@ -3944,8 +3963,11 @@ void MainComponent::timerCallback()
     // uses its own audio-callback-driven auto-increment, so it's similarly
     // decoupled.  If UI stalls (resize, modal dialog), outputs continue
     // transmitting the last-known timecode until the next tick() updates it.
-    for (auto& eng : engines)
-        eng->tick();
+    for (int i = 0; i < (int)engines.size(); ++i)
+    {
+        engines[(size_t)i]->setStatusTextVisible(i == selectedEngine);
+        engines[(size_t)i]->tick();
+    }
 
     // Update UI for selected engine
     auto& eng = currentEngine();
@@ -4087,7 +4109,10 @@ void MainComponent::timerCallback()
         {
             // Track changed -- clear old waveform immediately (avoids stale cursor)
             waveformDisplay.clearWaveform();
-            displayedWaveformTrackId = 0;
+            // Mark this track as "attempted" so we don't re-enter this block
+            // every frame.  The retry path below uses hasWaveformData() to
+            // detect when the async waveform query completes.
+            displayedWaveformTrackId = wfTrackId;
 
             // Try to populate from cache (may not have waveform yet)
             juce::String pdlIP = sharedProDJLinkInput.getPlayerIP(pdlPlayer);
@@ -4096,10 +4121,9 @@ void MainComponent::timerCallback()
             {
                 waveformDisplay.setColorWaveformData(meta.waveformData,
                     meta.waveformEntryCount, meta.waveformBytesPerEntry);
-                displayedWaveformTrackId = wfTrackId;
             }
         }
-        else if (wfTrackId != 0 && displayedWaveformTrackId == 0)
+        else if (wfTrackId != 0 && !waveformDisplay.hasWaveformData())
         {
             // Waveform not yet loaded -- retry from cache (async: arrives after metadata)
             juce::String pdlIP = sharedProDJLinkInput.getPlayerIP(pdlPlayer);
@@ -4108,7 +4132,6 @@ void MainComponent::timerCallback()
             {
                 waveformDisplay.setColorWaveformData(meta.waveformData,
                     meta.waveformEntryCount, meta.waveformBytesPerEntry);
-                displayedWaveformTrackId = wfTrackId;
             }
         }
         else if (wfTrackId == 0 && displayedWaveformTrackId != 0)

MainComponent.h

@@ -480,9 +480,10 @@ class MainComponent : public juce::Component,
     int  getArtNetAddressFromCombos(const juce::ComboBox& cmbNet, const juce::ComboBox& cmbSub,
                                      const juce::ComboBox& cmbUni);
 
-#if JUCE_WINDOWS
-    juce::OpenGLContext glContext;     // GPU-accelerated rendering (Windows only)
-#endif
+    // OpenGL context removed: see constructor comment for rationale.
+    // Keeping the juce_opengl module in Projucer is harmless and allows
+    // re-enabling GPU rendering in the future if the thread safety issues
+    // are addressed.
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(MainComponent)
 };