Update V1.8.3

Author: fiverecords

AppSettings.h

@@ -5,6 +5,7 @@
 #pragma once
 #include <JuceHeader.h>
 #include <unordered_map>
+#include <unordered_set>
 #include <string>
 
 //==============================================================================
@@ -589,6 +590,50 @@ class TrackMap
 
     uint64_t getGeneration() const { return generation; }
 
+    //------------------------------------------------------------------
+    // rekordbox XML import -- parse <DJ_PLAYLISTS> into TrackMapEntry list.
+    // Returns entries with artist, title, durationSec populated.
+    // Offsets and triggers are left at defaults (user configures later).
+    // Artwork and waveform will be fetched from the CDJ on first play.
+    //------------------------------------------------------------------
+    static std::vector<TrackMapEntry> parseRekordboxXml(const juce::File& file)
+    {
+        std::vector<TrackMapEntry> result;
+        auto xml = juce::XmlDocument::parse(file);
+        if (!xml || xml->getTagName() != "DJ_PLAYLISTS") return result;
+
+        auto* collection = xml->getChildByName("COLLECTION");
+        if (!collection) return result;
+
+        // Deduplicate by key (same artist+title can appear from multiple
+        // locations, e.g. local library + USB export in the same XML).
+        std::unordered_set<std::string> seen;
+
+        for (auto* track = collection->getChildByName("TRACK");
+             track != nullptr;
+             track = track->getNextElementWithTagName("TRACK"))
+        {
+            juce::String title  = track->getStringAttribute("Name").trim();
+            juce::String artist = track->getStringAttribute("Artist").trim();
+            int duration        = track->getIntAttribute("TotalTime", 0);
+
+            if (title.isEmpty()) continue;  // hasValidKey requires title
+
+            TrackMapEntry e;
+            e.title       = title;
+            e.artist      = artist;
+            e.durationSec = duration;
+
+            auto k = e.key();
+            if (seen.count(k)) continue;
+            seen.insert(k);
+
+            result.push_back(std::move(e));
+        }
+
+        return result;
+    }
+
 private:
     std::unordered_map<std::string, TrackMapEntry> entries;
     uint64_t generation = 0;

ArtnetOutput.h

@@ -99,6 +99,7 @@ class ArtnetOutput : public juce::HighResolutionTimer
         isRunningFlag.store(true, std::memory_order_relaxed);
         paused.store(false, std::memory_order_relaxed);
         sendErrors.store(0, std::memory_order_relaxed);
+        artnetSeeded = false;
         updateTimerRate();
         return true;
     }
@@ -155,6 +156,7 @@ class ArtnetOutput : public juce::HighResolutionTimer
         }
         else if (isRunningFlag.load(std::memory_order_relaxed))
         {
+            artnetSeeded = false;
             lastFrameSendTime.store(juce::Time::getMillisecondCounterHiRes(), std::memory_order_relaxed);
             updateTimerRate();
         }
@@ -171,6 +173,7 @@ class ArtnetOutput : public juce::HighResolutionTimer
             || paused.load(std::memory_order_relaxed)
             || socket == nullptr)
             return;
+        artnetSeeded = false;
         FrameRate fps = currentFps.load(std::memory_order_relaxed);
         sendArtTimeCode(fps);
     }
@@ -273,11 +276,41 @@ class ArtnetOutput : public juce::HighResolutionTimer
 
     void sendArtTimeCode(FrameRate fps)
     {
-        Timecode tc;
+        Timecode pending;
         {
             const juce::SpinLock::ScopedLockType lock(tcLock);
-            tc = timecodeToSend;
+            pending = timecodeToSend;
+        }
+
+        // Auto-increment: advance by 1 frame per send.  Compare with
+        // pendingTimecode and only resync on diff > 1 (seek/jump).
+        // Prevents 1-frame backward jitter from interpolation overshoot.
+        // Same architectural pattern as the LTC and MTC encoders.
+        Timecode tc;
+        if (!artnetSeeded)
+        {
+            tc = pending;
+            artnetSeeded = true;
+        }
+        else
+        {
+            tc = incrementFrame(encoderTc, fps);
+
+            int maxFrames = frameRateToInt(fps);
+            auto toTotal = [maxFrames](const Timecode& t) -> int64_t {
+                return (int64_t)t.hours * 3600 * maxFrames
+                     + (int64_t)t.minutes * 60 * maxFrames
+                     + (int64_t)t.seconds * maxFrames
+                     + (int64_t)t.frames;
+            };
+            int64_t dayFrames = (int64_t)24 * 3600 * maxFrames;
+            int64_t rawDiff = toTotal(pending) - toTotal(tc);
+            int64_t diff = ((rawDiff % dayFrames) + dayFrames) % dayFrames;
+            if (diff > dayFrames / 2) diff = dayFrames - diff;
+            if (diff > 1)
+                tc = pending;
         }
+        encoderTc = tc;
 
         // Validate ranges -- don't send corrupt data to the network
         int maxFrames = frameRateToInt(fps);
@@ -335,6 +368,8 @@ class ArtnetOutput : public juce::HighResolutionTimer
 
     juce::SpinLock tcLock;
     Timecode timecodeToSend;        // Written by UI thread under tcLock, read by timer thread under tcLock
+    Timecode encoderTc;             // Auto-increment: last sent timecode (timer thread only)
+    bool     artnetSeeded = false;  // Auto-increment: false until first frame seeds encoderTc
     std::atomic<FrameRate> currentFps { FrameRate::FPS_25 };
     std::atomic<double> lastFrameSendTime { 0.0 };
     std::atomic<uint32_t> sendErrors { 0 };

DbServerClient.h

@@ -495,7 +495,7 @@ class DbServerClient : private juce::Thread
     static constexpr int kPortDiscoveryPort = 12523;
     static constexpr int kDefaultDbPort     = 1051;
     static constexpr int kConnectTimeoutMs  = 3000;
-    static constexpr int kReadTimeoutMs     = 3000;
+    static constexpr int kReadTimeoutMs     = 1000;  // CDJ responds in <10ms; 3000 was wasteful
     static constexpr int kMaxCacheEntries   = 256;
     static constexpr int kMaxArtCacheEntries = 64;
     static constexpr int kMaxConnections    = 6;
@@ -555,6 +555,7 @@ class DbServerClient : private juce::Thread
         std::unique_ptr<juce::StreamingSocket> socket;
         int dbPort = 0;
         bool contextSetUp = false;
+        uint8_t contextPlayer = 0;  // player number used in setupQueryContext
         uint32_t txId = 0;
         double lastFailTime = 0.0;
 
@@ -568,6 +569,7 @@ class DbServerClient : private juce::Thread
                 socket = nullptr;
             }
             contextSetUp = false;
+            contextPlayer = 0;
             txId = 0;
             dbPort = 0;
             playerIP.clear();
@@ -892,7 +894,22 @@ class DbServerClient : private juce::Thread
         for (auto& conn : connections)
         {
             if (conn.playerIP == playerIP && conn.isConnected())
+            {
+                // If the query identity changed (e.g. NXS2 network topology
+                // change caused suggestDbPlayerNumber to pick a different
+                // player), the existing context is stale -- close and reconnect
+                // so setupQueryContext uses the new identity.
+                if (conn.contextPlayer != 0 && conn.contextPlayer != ourPlayer)
+                {
+                    DBG("DbServerClient: context player mismatch ("
+                        + juce::String(conn.contextPlayer) + " vs "
+                        + juce::String(ourPlayer) + ") -- reconnecting to " + playerIP);
+                    conn.close();
+                    conn.lastFailTime = 0.0;  // intentional close, not a failure
+                    break;  // fall through to new connection below
+                }
                 return &conn;
+            }
         }
 
         // Find empty slot or recycle oldest
@@ -1060,6 +1077,7 @@ class DbServerClient : private juce::Thread
         DBG("DbServerClient: query context established, CDJ reports player="
             + juce::String(resp.numArgs[1]));
         conn.contextSetUp = true;
+        conn.contextPlayer = ourPlayer;
         conn.txId = 1;
         return true;
     }

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.8.2"; }
+    const juce::String getApplicationVersion() override { return "1.8.3"; }
     bool moreThanOneInstanceAllowed() override           { return false; }
 
     void initialise(const juce::String&) override

MtcOutput.h

@@ -56,6 +56,7 @@ class MtcOutput : public juce::HighResolutionTimer
             isRunningFlag.store(true, std::memory_order_relaxed);
             paused.store(false, std::memory_order_relaxed);
             currentQFIndex.store(0, std::memory_order_relaxed);
+            mtcSeeded = false;
 
             // Full Frame is sent after the first setTimecode() call populates
             // pendingTimecode -- avoids transmitting a misleading 00:00:00.00
@@ -123,6 +124,7 @@ class MtcOutput : public juce::HighResolutionTimer
             stopTimer();
             currentQFIndex.store(0, std::memory_order_relaxed);
             paused.store(false, std::memory_order_relaxed);
+            mtcSeeded = false;
 
             // Re-sync receivers after pause with a Full Frame message
             sendFullFrame();
@@ -148,6 +150,7 @@ class MtcOutput : public juce::HighResolutionTimer
             return;
         // Reset QF cycle to start fresh from the new position
         currentQFIndex.store(0, std::memory_order_relaxed);
+        mtcSeeded = false;
         sendFullFrame();
     }
 
@@ -216,13 +219,46 @@ class MtcOutput : public juce::HighResolutionTimer
         double lastSend = lastQfSendTime.load(std::memory_order_relaxed);
         while ((now - lastSend) >= qfInterval && sent < 2)
         {
-            // At QF index 0, snapshot the timecode for this entire 8-QF cycle
-            // This guarantees all 8 QFs describe the SAME timecode - no jumps
+            // At QF index 0, determine the timecode for this entire 8-QF cycle.
+            // Auto-increment: advance by 2 frames (one QF cycle = 2 frame durations).
+            // Compare with pendingTimecode and only resync on diff > 2 (seek/jump).
+            // This prevents 1-frame backward jitter from interpolation overshoot
+            // causing a full QF cycle of wrong data → MTC receiver flicker.
+            // Same architectural pattern as the LTC encoder's auto-increment.
             int qfIdx = currentQFIndex.load(std::memory_order_relaxed);
             if (qfIdx == 0)
             {
-                const juce::SpinLock::ScopedLockType lock(tcLock);
-                cycleTimecode = pendingTimecode;
+                Timecode pending;
+                {
+                    const juce::SpinLock::ScopedLockType lock(tcLock);
+                    pending = pendingTimecode;
+                }
+
+                if (!mtcSeeded)
+                {
+                    cycleTimecode = pending;
+                    mtcSeeded = true;
+                }
+                else
+                {
+                    // Auto-increment by 2 frames (1 QF cycle = 2 frame durations)
+                    cycleTimecode = incrementFrame(incrementFrame(cycleTimecode, fps), fps);
+
+                    // Resync if pending differs by more than 2 frames (seek/jump)
+                    int maxFrames = frameRateToInt(fps);
+                    auto toTotal = [maxFrames](const Timecode& t) -> int64_t {
+                        return (int64_t)t.hours * 3600 * maxFrames
+                             + (int64_t)t.minutes * 60 * maxFrames
+                             + (int64_t)t.seconds * maxFrames
+                             + (int64_t)t.frames;
+                    };
+                    int64_t dayFrames = (int64_t)24 * 3600 * maxFrames;
+                    int64_t rawDiff = toTotal(pending) - toTotal(cycleTimecode);
+                    int64_t diff = ((rawDiff % dayFrames) + dayFrames) % dayFrames;
+                    if (diff > dayFrames / 2) diff = dayFrames - diff;
+                    if (diff > 2)
+                        cycleTimecode = pending;
+                }
             }
 
             sendQuarterFrame(qfIdx, fps);
@@ -289,6 +325,7 @@ class MtcOutput : public juce::HighResolutionTimer
     juce::SpinLock tcLock;
     Timecode pendingTimecode;   // Written by UI thread, read under tcLock
     Timecode cycleTimecode;     // Timer-thread-only: snapshot taken at QF index 0, read through QF 1-7
+    bool     mtcSeeded = false; // Auto-increment: false until first QF0 seeds cycleTimecode
     std::atomic<FrameRate> currentFps { FrameRate::FPS_25 };
     // currentQFIndex is primarily accessed from the timer thread, but reset from
     // the UI thread in start()/setPaused() after stopTimer().  JUCE guarantees