Update V1.9.8

Author: fiverecords

AppSettings.h

@@ -110,6 +110,115 @@ struct CuePoint
     }
 };
 
+//==============================================================================
+// GeneratorCuePoint -- a cue inside a Generator preset.  Same trigger
+// payload as CuePoint (MIDI/OSC/Art-Net) but the trigger position is
+// expressed as an absolute SMPTE timecode (HH:MM:SS:FF) rather than as
+// milliseconds from track start.  This matches the rest of the Generator
+// preset editor (which already speaks in TC for Start / Stop) and means a
+// cue at "01:00:30:00" works identically whether the preset has an audio
+// file (TC follows the audio playhead) or runs in pure TC-generation mode.
+//==============================================================================
+struct GeneratorCuePoint
+{
+    juce::String positionTC = "00:00:00:00";  // HH:MM:SS:FF -- when to fire
+    juce::String name;                          // user label
+
+    // Trigger config -- mirrors CuePoint exactly so the same dispatch
+    // helpers (firing MIDI / OSC / DMX) can be reused.
+    int  midiChannel  = 0;          // 0-15 (displayed as 1-16)
+    int  midiNoteNum  = -1;         // -1 = disabled
+    int  midiNoteVel  = 127;
+    int  midiCCNum    = -1;         // -1 = disabled
+    int  midiCCVal    = 127;
+
+    juce::String oscAddress;
+    juce::String oscArgs;
+
+    int  artnetCh     = 0;          // 0 = disabled, 1-512
+    int  artnetVal    = 255;
+
+    bool hasMidiTrigger()   const { return midiNoteNum >= 0 || midiCCNum >= 0; }
+    bool hasOscTrigger()    const { return oscAddress.isNotEmpty(); }
+    bool hasArtnetTrigger() const { return artnetCh > 0; }
+    bool hasAnyTrigger()    const { return hasMidiTrigger() || hasOscTrigger() || hasArtnetTrigger(); }
+
+    /// Convert positionTC to total milliseconds (frame -> ms uses the
+    /// supplied frame rate; default 30 matches the rest of the codebase
+    /// when the caller doesn't know the engine's effective fps).  This is
+    /// the form the engine uses to compare against its current TC and
+    /// decide whether a cue should fire.
+    uint32_t positionMs(double fps = 30.0) const
+    {
+        auto parts = juce::StringArray::fromTokens(positionTC, ":.", "");
+        int h = 0, m = 0, s = 0, f = 0;
+        if (parts.size() >= 1) h = parts[0].getIntValue();
+        if (parts.size() >= 2) m = parts[1].getIntValue();
+        if (parts.size() >= 3) s = parts[2].getIntValue();
+        if (parts.size() >= 4) f = parts[3].getIntValue();
+        if (fps <= 0.0) fps = 30.0;
+        double totalSec = h * 3600.0 + m * 60.0 + s + (double) f / fps;
+        return (uint32_t) juce::jmax(0.0, totalSec * 1000.0);
+    }
+
+    juce::var toVar() const
+    {
+        auto* obj = new juce::DynamicObject();
+        obj->setProperty("positionTC", positionTC);
+        if (name.isNotEmpty())
+            obj->setProperty("name", name);
+
+        if (midiNoteNum >= 0 || midiCCNum >= 0)
+        {
+            obj->setProperty("midiChannel", midiChannel);
+            obj->setProperty("midiNoteNum", midiNoteNum);
+            obj->setProperty("midiNoteVel", midiNoteVel);
+            obj->setProperty("midiCCNum",   midiCCNum);
+            obj->setProperty("midiCCVal",   midiCCVal);
+        }
+        if (oscAddress.isNotEmpty())
+        {
+            obj->setProperty("oscAddress", oscAddress);
+            if (oscArgs.isNotEmpty())
+                obj->setProperty("oscArgs", oscArgs);
+        }
+        if (artnetCh > 0)
+        {
+            obj->setProperty("artnetCh",  artnetCh);
+            obj->setProperty("artnetVal", artnetVal);
+        }
+        return juce::var(obj);
+    }
+
+    void fromVar(const juce::var& v)
+    {
+        auto* obj = v.getDynamicObject();
+        if (!obj) return;
+
+        auto getInt = [&](const char* key, int def) {
+            auto val = obj->getProperty(key);
+            return val.isVoid() ? def : (int)val;
+        };
+        auto getString = [&](const char* key, const juce::String& def = {}) {
+            auto val = obj->getProperty(key);
+            return val.isVoid() ? def : val.toString();
+        };
+
+        positionTC  = getString("positionTC", "00:00:00:00");
+        if (positionTC.isEmpty()) positionTC = "00:00:00:00";
+        name        = getString("name");
+        midiChannel = juce::jlimit(0, 15, getInt("midiChannel", 0));
+        midiNoteNum = juce::jlimit(-1, 127, getInt("midiNoteNum", -1));
+        midiNoteVel = juce::jlimit(0, 127, getInt("midiNoteVel", 127));
+        midiCCNum   = juce::jlimit(-1, 127, getInt("midiCCNum", -1));
+        midiCCVal   = juce::jlimit(0, 127, getInt("midiCCVal", 127));
+        oscAddress  = getString("oscAddress");
+        oscArgs     = getString("oscArgs");
+        artnetCh    = juce::jlimit(0, 512, getInt("artnetCh", 0));
+        artnetVal   = juce::jlimit(0, 255, getInt("artnetVal", 255));
+    }
+};
+
 //==============================================================================
 // TrackMapEntry -- per-track config: offset, triggers, cue points
 //==============================================================================
@@ -836,9 +945,26 @@ struct GeneratorPreset
     juce::String audioFilePath;                 // empty = no audio playback
     bool         audioLoop = false;             // loop file when reaching its end
 
+    // Cue points -- triggers that fire when the generated TC reaches each
+    // cue's positionTC.  Sorted by positionTC (compared as ms) so the
+    // engine can do a forward linear scan during playback.
+    std::vector<GeneratorCuePoint> cuePoints;
+
     std::string key() const { return name.toLowerCase().trim().toStdString(); }
     bool hasValidKey() const { return name.trim().isNotEmpty(); }
 
+    bool hasCuePoints() const { return ! cuePoints.empty(); }
+
+    /// Sort cue points by position (ms), with frame-rate cancellation: any
+    /// reasonable fps gives the same ordering since positionTC ordering is
+    /// dominated by H/M/S, frames only matter in tie-breaking.
+    void sortCuePoints()
+    {
+        std::sort(cuePoints.begin(), cuePoints.end(),
+                  [](const GeneratorCuePoint& a, const GeneratorCuePoint& b)
+                  { return a.positionMs() < b.positionMs(); });
+    }
+
     juce::var toVar() const
     {
         auto* obj = new juce::DynamicObject();
@@ -847,6 +973,14 @@ struct GeneratorPreset
         obj->setProperty("stopTC",        stopTC);
         obj->setProperty("audioFilePath", audioFilePath);
         obj->setProperty("audioLoop",     audioLoop);
+
+        if (! cuePoints.empty())
+        {
+            juce::Array<juce::var> arr;
+            for (auto& cp : cuePoints)
+                arr.add(cp.toVar());
+            obj->setProperty("cuePoints", arr);
+        }
         return juce::var(obj);
     }
 
@@ -861,6 +995,19 @@ struct GeneratorPreset
         audioLoop     = (bool) obj->getProperty("audioLoop");
         if (startTC.isEmpty()) startTC = "00:00:00:00";
         if (stopTC.isEmpty())  stopTC  = "00:00:00:00";
+
+        cuePoints.clear();
+        auto cuesVar = obj->getProperty("cuePoints");
+        if (auto* arr = cuesVar.getArray())
+        {
+            cuePoints.reserve((size_t) arr->size());
+            for (auto& item : *arr)
+            {
+                GeneratorCuePoint cp;
+                cp.fromVar(item);
+                cuePoints.push_back(std::move(cp));
+            }
+        }
     }
 };
 
@@ -1207,7 +1354,8 @@ struct EngineSettings
         generatorAudioSampleRate = getDouble("generatorAudioSampleRate", 0.0);
         generatorAudioBufferSize = getInt("generatorAudioBufferSize", 0);
         generatorAudioFileChannelMode = getInt("generatorAudioFileChannelMode", 0);
-        proDJLinkPlayer      = juce::jlimit(1, 8, getInt("proDJLinkPlayer", 1));
+        // proDJLinkPlayer ids: 1-6 = players, 7 = XF-A, 8 = XF-B, 9 = MASTER
+        proDJLinkPlayer      = juce::jlimit(1, 9, getInt("proDJLinkPlayer", 1));
         trackMapEnabled      = getBool("trackMapEnabled", getBool("tcnetTrackMapEnabled", false));
         midiClockEnabled     = getBool("midiClockEnabled", getBool("tcnetMidiClock", false));
         oscBpmAddr           = getString("oscBpmAddr", getString("tcnetOscBpmAddr", "/composition/tempocontroller/tempo"));

DbServerClient.h

@@ -957,7 +957,21 @@ class DbServerClient : private juce::Thread
                 msg.strArgs[i] = arg.stringValue;
             if (arg.type == 0x14 && arg.blobData.getSize() > 0)
                 msg.blobArgs[i] = std::move(arg.blobData);
-            lastArg = arg;
+
+            // The next-iteration safety check (zero-length blob detection)
+            // only needs lastArg.type, lastArg.numericValue, and lastArg.ok.
+            // Do NOT copy `arg` whole here: when the branch above moved
+            // arg.blobData out, JUCE's MemoryBlock move-assignment leaves
+            // arg.blobData with data=nullptr but size=originalSize, so a
+            // subsequent copy-assignment of the MemoryBlock would call
+            // memcpy(dst, nullptr, size) inside MemoryBlock::operator=,
+            // crashing the whole dbserver worker thread.  Manifests when
+            // reading any blob field (artwork JPEG, ANLZ waveform tags,
+            // etc.) -- exactly the path that loads images in the PDL view.
+            lastArg = FieldResult{};
+            lastArg.type         = arg.type;
+            lastArg.numericValue = arg.numericValue;
+            lastArg.ok           = arg.ok;
         }
 
         msg.ok = true;

GeneratorAudioPlayer.h

@@ -35,26 +35,45 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
 public:
     GeneratorAudioPlayer()
     {
-        formatManager.registerBasicFormats();   // WAV, AIFF, FLAC, OGG (+ MP3 if JUCE_USE_MP3AUDIOFORMAT was set in Projucer)
-       #if JUCE_USE_MP3AUDIOFORMAT
-        // Belt and braces: register MP3 explicitly even though
-        // registerBasicFormats() already includes it.  Duplicate registration
-        // is harmless -- createReaderFor returns the first format that
-        // accepts the extension.
-        formatManager.registerFormat(new juce::MP3AudioFormat(), false);
-       #endif
+        // Registers WAV, AIFF, FLAC, OGG, and -- when the Projucer flag
+        // JUCE_USE_MP3AUDIOFORMAT is set -- MP3.  Do NOT re-register MP3
+        // explicitly afterwards; JUCE_DEBUG asserts on duplicate format
+        // registration (jassertfalse in AudioFormatManager::registerFormat).
+        formatManager.registerBasicFormats();
     }
 
     ~GeneratorAudioPlayer() override
     {
-        // Stop the loader thread first so it cannot fire a new load against
-        // members we are about to tear down.  (Belt and braces: the
-        // LoaderThread destructor also does this on its own destruction,
-        // but doing it explicitly here means the closeDevice / unloadFile
-        // calls that follow run with no concurrent file I/O.)
+        // Order matters here.  Members are destroyed in reverse declaration
+        // order, which means the std::atomic<> flags (deviceOpen, userPaused,
+        // shouldPlay, fileLoadedAtomic, ...) are torn down BEFORE the
+        // deviceManager.  If the audio device had any callback still in
+        // flight when ~AudioDeviceManager() runs, that callback would read
+        // already-destroyed atomics -- the std::atomic load crash on shutdown
+        // we hunted in v1.9.7/v1.9.8.
+        //
+        // Step 1: latch shuttingDown so any in-flight or imminent audio
+        // callback returns immediately without touching other atomics.
+        // The acquire/release pairing on shuttingDown ensures the callback
+        // sees the flag if it observes the store.
+        shuttingDown.store(true, std::memory_order_release);
+
+        // Step 2: closeDevice() calls removeAudioCallback, which JUCE
+        // documents as blocking until any in-flight callback returns.  We
+        // call it explicitly here (rather than relying on the deviceManager
+        // destructor) so the audio thread is provably idle BEFORE we leave
+        // the user-defined destructor body and member destruction begins.
+        // The loader thread is stopped first because its tick can call back
+        // into transport / reader objects that closeDevice will tear down.
         loaderThread.stop();
         closeDevice();
         unloadFile();
+        // Belt-and-braces: ensure the AudioDeviceManager is fully closed
+        // and has no callbacks attached.  closeDevice already did this for
+        // the case where a device was open, but this also covers the path
+        // where ~GeneratorAudioPlayer runs without ever having opened one.
+        deviceManager.removeAudioCallback(this);
+        deviceManager.closeAudioDevice();
     }
 
     //==========================================================================
@@ -575,6 +594,14 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
             if (outputChannelData[ch])
                 std::memset(outputChannelData[ch], 0, sizeof(float) * (size_t) numSamples);
 
+        // Shutting-down guard: if our destructor has latched this flag, we
+        // return immediately without touching any other atomic / object.
+        // This makes the callback's lifetime trivially safe even if some
+        // exotic driver path delivers a final tick after removeAudioCallback
+        // has been issued (which JUCE itself protects against on most
+        // backends, but a single atomic load is cheap insurance).
+        if (shuttingDown.load(std::memory_order_acquire)) return;
+
         if (userPaused.load(std::memory_order_acquire)) return;
         if (! transport.isPlaying()) return;
         if (! fileLoadedAtomic.load(std::memory_order_acquire)) return;
@@ -659,6 +686,8 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
 
     void audioDeviceAboutToStart(juce::AudioIODevice* device) override
     {
+        if (shuttingDown.load(std::memory_order_acquire)) return;
+
         if (device)
         {
             currentSampleRate    = device->getCurrentSampleRate();
@@ -675,6 +704,8 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
 
     void audioDeviceStopped() override
     {
+        if (shuttingDown.load(std::memory_order_acquire)) return;
+
         const juce::ScopedLock sl(transportLock);
         transport.releaseResources();
     }
@@ -696,6 +727,7 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
     juce::AudioBuffer<float> scratchBuffer;
 
     std::atomic<bool> deviceOpen      { false };
+    std::atomic<bool> shuttingDown    { false };  // set in dtor before closeDevice; audio callback returns immediately if true
     std::atomic<int>  selectedChannel { -1 };
     std::atomic<bool> loopFlag        { false };
     std::atomic<bool> userPaused      { false };  // logical pause state -- see pause() comment