Update V1.9.9

Author: fiverecords

GeneratorAudioPlayer.h

@@ -351,6 +351,11 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
 
     /// Seek to position in seconds, relative to the start of the audio file.
     /// When looping, positions beyond file length are folded back via fmod.
+    /// If the player was supposed to be playing (shouldPlay set, not paused)
+    /// but the transport had auto-stopped (typically because it reached EOF
+    /// before this seek), the transport is re-engaged so audio resumes from
+    /// the new position.  start() is a no-op when the transport is already
+    /// playing, so the in-flight seek-while-playing case is unaffected.
     void seekSeconds(double seconds)
     {
         if (! hasFileLoaded()) return;
@@ -368,6 +373,13 @@ class GeneratorAudioPlayer : private juce::AudioIODeviceCallback
         }
 
         transport.setPosition(seconds);
+
+        if (shouldPlay.load(std::memory_order_acquire)
+            && ! userPaused.load(std::memory_order_acquire)
+            && deviceOpen.load(std::memory_order_relaxed))
+        {
+            transport.start();
+        }
     }
 
     double getCurrentPositionSeconds() const { return transport.getCurrentPosition(); }

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

README.md

@@ -390,7 +390,7 @@ The sections below are for developers who want to build STC from source.
 3. **Create a `CMakeLists.txt`** in the project root:
    ```cmake
    cmake_minimum_required(VERSION 3.22)
-   project(SuperTimecodeConverter VERSION 1.9.8)
+   project(SuperTimecodeConverter VERSION 1.9.9)
 
    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -400,7 +400,7 @@ The sections below are for developers who want to build STC from source.
    juce_add_gui_app(SuperTimecodeConverter
        PRODUCT_NAME "Super Timecode Converter"
        COMPANY_NAME "Fiverecords"
-       VERSION "1.9.8"
+       VERSION "1.9.9"
        HARDENED_RUNTIME_ENABLED TRUE
        HARDENED_RUNTIME_OPTIONS com.apple.security.device.audio-input
        MICROPHONE_PERMISSION_ENABLED TRUE
@@ -572,6 +572,19 @@ This affects any software using these ports, including the official PRO DJ LINK
 
 On macOS, the DJM-900NXS2 / DJM-A9 / DJM-V10 may occasionally fail to deliver mixer fader data on the first connection after the DJM is powered on. This is a timing issue in the subscribe handshake. Workaround: restart STC or toggle the Pro DJ Link interface off and on. A delayed-subscribe fix is planned for a future release.
 
+### StageLinQ: Playhead Does Not Advance
+
+The StageLinQ playhead is driven by the device's BeatInfo stream. If STC connects to a Denon player but the playhead stays at zero (BPM and track name may still appear, but position never moves), the BeatInfo stream is not arriving from the device. This has nothing to do with the StateMap subscription -- those two channels are independent on the player side.
+
+Field-reported conditions that silence BeatInfo on SC5000 / SC6000:
+
+- **Deck has no track loaded, or is paused / not playing.** BeatInfo only streams while a track is actively playing.
+- **The physical LINK button on the player is on.** Linking decks via the player itself disables BeatInfo. Turn LINK off on every player on the network.
+- **Decks are linked from Engine DJ.** Same effect as the physical LINK button. Unlink the decks from Engine DJ, or close Engine DJ entirely if it is not needed.
+- **Player was already running when STC started.** Some firmware revisions only emit BeatInfo if a consumer was already listening at the time the player booted. Power-cycling the player after STC is running is enough.
+
+Walk through the four conditions in that order before assuming a network or firmware issue. If the playhead still does not move after all four are satisfied, a Wireshark capture of STC connecting to the player would help diagnose; please open an issue and attach the `.pcapng`.
+
 ### rekordbox Cannot Run Simultaneously with STC
 
 STC and rekordbox use the same UDP ports for Pro DJ Link communication (50000, 50001, 50002). Running both applications at the same time on the same machine causes port conflicts: CDJ discovery fails, status packets are lost, and neither application works correctly. This is the same limitation that affects the official PRO DJ LINK Bridge.

StageLinQInput.h

@@ -54,7 +54,13 @@ namespace StageLinQ
     // StateMap sub-types (bytes 8-11 inside smaa block)
     static constexpr uint32_t kSmaaStateEmit       = 0x00000000;  // device -> us: state value
     static constexpr uint32_t kSmaaEmitResponse     = 0x000007D1;  // device -> us: subscription ack
-    static constexpr uint32_t kSmaaSubscribe        = 0x000007D2;  // us -> device: subscribe request
+    // 0x07D2 is used in both directions:
+    //  - us -> device: subscribe request, with min interval (ms) appended after the path
+    //  - device -> us: periodic catalogue announcement of the paths the device offers
+    //    (no JSON value, just path + 4-byte interval).  Some firmware revisions
+    //    re-broadcast their catalogue on this opcode every few seconds; we
+    //    silently consume them since we already know what we asked for.
+    static constexpr uint32_t kSmaaSubscribe        = 0x000007D2;  // bidirectional, see above
 
     // TCP message IDs (first 4 bytes of TCP messages)
     static constexpr uint32_t kMsgServiceAnnounce   = 0x00000000;
@@ -439,6 +445,25 @@ namespace StageLinQ
     //==========================================================================
     // Build a BeatInfo start-stream frame
     //==========================================================================
+    //
+    // Handshake is exactly 8 bytes: length=4 (BE), magic=0x00000000 (BE).
+    // Adding any payload (e.g. our token) is a known way to make the device
+    // silently refuse to stream -- the connection stays open but no packets
+    // ever arrive.  Independent third-party Python implementations against
+    // SC5000 have reproduced this; keep the frame minimal.
+    //
+    // BeatInfo silence conditions (field-reported, not all firmware-confirmed):
+    //   - The deck has no track loaded, or is not in playback.
+    //   - Some firmware will only emit if the consumer was already listening
+    //     when the device booted; power-cycling the device after STC has
+    //     started restores the stream.
+    //   - The physical LINK button on the SC5000 is on.  Linking decks at
+    //     the device disables BeatInfo on the device side.
+    //   - Decks are linked from Engine DJ (same effect as the physical LINK
+    //     button).
+    //
+    // If a user reports "StageLinQ playhead never moves", these are the four
+    // things to walk through before assuming a bug in this code path.
     inline std::vector<uint8_t> buildBeatInfoStart()
     {
         std::vector<uint8_t> frame;
@@ -2552,9 +2577,12 @@ class StageLinQInput : public juce::Thread
                             }
                         }
                     }
-                    // kSmaaEmitResponse (0x7D1) -- subscription ack, ignore
+                    // kSmaaEmitResponse (0x7D1) -- subscription ack, ignore.
+                    // kSmaaSubscribe (0x7D2) from device direction -- periodic
+                    // catalogue announce (path + interval, no JSON), ignore.
 #if JUCE_DEBUG
-                    else if (subType != StageLinQ::kSmaaEmitResponse)
+                    else if (subType != StageLinQ::kSmaaEmitResponse
+                             && subType != StageLinQ::kSmaaSubscribe)
                     {
                         DBG("StageLinQ: Unknown smaa subtype 0x"
                             + juce::String::toHexString((int)subType)

TimecodeEngine.h

@@ -137,6 +137,10 @@ class TimecodeEngine
         userOverrodeLtcFps = false;
         activeInput = source;
         sourceActive = false;
+        // Switching the input source is an explicit user transition; any
+        // pending natural-EOF marker from the Generator path is no longer
+        // relevant and must not survive the round-trip.
+        genEndedAtEof = false;
 
         // Releasing the Generator audio output device when the engine
         // switches to a non-Generator input is important for shows where
@@ -1857,6 +1861,10 @@ class TimecodeEngine
     {
         if (genState == GeneratorState::Playing) return;
 
+        // Explicit user transition; any pending natural-EOF marker is no
+        // longer relevant to the next click on the timeline.
+        genEndedAtEof = false;
+
         const bool wasStopped = (genState == GeneratorState::Stopped);
         if (wasStopped)
         {
@@ -1898,6 +1906,9 @@ class TimecodeEngine
     void generatorStop()
     {
         genState = GeneratorState::Stopped;
+        // Explicit user transition; clear the natural-EOF marker so a
+        // subsequent click on the timeline does NOT auto-resume.
+        genEndedAtEof = false;
         genCurrentMs = genStartMs;
         // Reset the crossing-based cue cursor too -- the next play will
         // start from genStartMs and we want the first tick's (prev, now]
@@ -1984,6 +1995,10 @@ class TimecodeEngine
     ///   Stopped -> Paused  (preserves the seeked position; if we stayed in
     ///                       Stopped, the next generatorPlay() would reset
     ///                       genCurrentMs to genStartMs and discard the seek)
+    ///   Stopped + genEndedAtEof -> Playing (the player just finished a
+    ///                       track naturally; clicking the timeline is
+    ///                       interpreted as "play from here", consistent
+    ///                       with consumer media players)
     ///
     /// The caller is responsible for any clamping (e.g. against Stop TC or
     /// the audio file's length); this method only enforces newMs >= 0.
@@ -2000,14 +2015,36 @@ class TimecodeEngine
         // on the lower bound.
         lastCueCheckMs = (uint32_t) juce::jmax(0.0, genCurrentMs);
 
+        // Decide the post-seek state.  Stopped + genEndedAtEof means we
+        // just finished the track on its own; treat the click as a
+        // "resume from here" instead of a cue.  Any other Stopped becomes
+        // Paused (preserves previous behaviour for cold scrub / post-Stop
+        // scrub).  Playing / Paused are not modified.
+        const bool resumeFromEof = (genState == GeneratorState::Stopped
+                                    && genEndedAtEof);
         if (genState == GeneratorState::Stopped)
-            genState = GeneratorState::Paused;
+            genState = resumeFromEof ? GeneratorState::Playing
+                                      : GeneratorState::Paused;
+
+        // Consume the flag once acted on so the same click never
+        // resumes twice.  Cleared regardless of whether we used it
+        // (a click while Playing/Paused also implies the user has
+        // moved on from the natural-end state).
+        genEndedAtEof = false;
 
         if (activeInput == InputSource::SystemTime)
             currentTimecode = wallClockToTimecode(genCurrentMs, currentFps);
 
         const double audioPosSec = juce::jmax(0.0, (genCurrentMs - genStartMs) / 1000.0);
         generatorAudioPlayer.seekSeconds(audioPosSec);
+
+        // For the EOF-resume case, the audio player still has shouldPlay
+        // cleared (stopAndReset was called when the EOF auto-stop fired),
+        // so seekSeconds alone will not have restarted the transport.
+        // Arm the play intent now; play() also calls transport.start()
+        // at the just-seeked position.
+        if (resumeFromEof)
+            generatorAudioPlayer.play();
     }
 
     double getGeneratorStartMs() const { return genStartMs; }
@@ -2057,10 +2094,18 @@ class TimecodeEngine
     void setGeneratorAudioFile(const juce::File& file, bool shouldLoop)
     {
         const juce::File f = (file == juce::File() || ! file.existsAsFile()) ? juce::File() : file;
+        // New file (or unload) invalidates the natural-EOF marker -- a
+        // click on the timeline of a freshly loaded track should cue,
+        // not auto-resume from the previous track's EOF intent.
+        genEndedAtEof = false;
         generatorAudioPlayer.requestLoad(f, shouldLoop);
     }
 
-    void clearGeneratorAudioFile() { generatorAudioPlayer.requestLoad(juce::File(), false); }
+    void clearGeneratorAudioFile()
+    {
+        genEndedAtEof = false;
+        generatorAudioPlayer.requestLoad(juce::File(), false);
+    }
 
     bool       hasGeneratorAudioFile()    const { return generatorAudioPlayer.hasFileLoaded(); }
     juce::File getGeneratorAudioFile()    const { return generatorAudioPlayer.getCurrentFile(); }
@@ -2203,6 +2248,14 @@ class TimecodeEngine
     double genStopMs    = 0.0;     // stop TC in ms (0 = freerun)
     double genCurrentMs = 0.0;     // current position in ms
     double genLastTickTime = 0.0;  // hiRes ms for delta calculation
+    // Set when the generator stops automatically because the loaded audio
+    // file reached EOF (as opposed to a user-initiated stop).  Consumed by
+    // setGeneratorPosition() so that a click on the timeline immediately
+    // after the track ends both seeks and resumes audio in one action,
+    // matching the muscle memory of consumer media players.  Cleared by
+    // any explicit user transition (Play / Stop / file change / input
+    // source change), so it never survives a context switch.
+    bool   genEndedAtEof = false;
 
     // Generator audio playback (per-engine, optional)
     GeneratorAudioPlayer generatorAudioPlayer;
@@ -3262,6 +3315,33 @@ class TimecodeEngine
                 genState = GeneratorState::Stopped;
                 generatorAudioPlayer.stopAndReset();
             }
+            // Auto-stop when the loaded audio file has played to its end.
+            // Without this, the SMPTE would keep advancing past the file's
+            // last sample (the audio transport silently auto-stops at EOF
+            // but nothing was relaying that back to the generator state).
+            // Looping files fold around inside seekSeconds() so they do
+            // not reach this branch; a user-defined stop TC takes
+            // precedence (handled by the prior branch).
+            //
+            // genEndedAtEof is set so that a subsequent click on the
+            // waveform timeline (setGeneratorPosition) treats the seek
+            // as a "resume from new position" gesture instead of just
+            // cueing.  See setGeneratorPosition for the consumer side.
+            else
+            {
+                const double fileLenSec = generatorAudioPlayer.getFileLengthSeconds();
+                if (fileLenSec > 0.0 && ! generatorAudioPlayer.isLooping())
+                {
+                    const double endMs = genStartMs + fileLenSec * 1000.0;
+                    if (genCurrentMs >= endMs)
+                    {
+                        genCurrentMs = endMs;
+                        genState = GeneratorState::Stopped;
+                        genEndedAtEof = true;
+                        generatorAudioPlayer.stopAndReset();
+                    }
+                }
+            }
 
             // Check armed cue points against the current generated TC.
             // Uses the crossing-based variant: a cue fires whenever the