// Super Timecode Converter

// Copyright (c) 2026 Fiverecords -- MIT License

// https://github.com/fiverecords/SuperTimecodeConverter

#pragma once

#include <JuceHeader.h>

#include "TimecodeCore.h"

#include "MtcInput.h"

#include "MtcOutput.h"

#include "ArtnetInput.h"

#include "ArtnetOutput.h"

#include "LtcInput.h"

#include "LtcOutput.h"

#include "ProDJLinkInput.h"

#include "StageLinQInput.h"

#include "HippotizerInput.h"

#include "HippotizerOutput.h"

#include "DbServerClient.h"

#include "TriggerOutput.h"

#include "LinkBridge.h"

#include "AudioThru.h"

#include "AudioBpmInput.h"

#include "AppSettings.h"

#include "MixerMap.h"

#include <memory>

//==============================================================================

// TimecodeEngine -- one independent routing pipeline

//

// Each engine owns: 1 input source -> N output destinations.

// AudioThru is only available on the primary engine (index 0).

//==============================================================================

// All public methods of TimecodeEngine are designed to be called exclusively

// from the JUCE message thread. Protocol handler callbacks (MTC/ArtNet/LTC)

// communicate back via atomics only. No additional synchronisation is needed.

inline constexpr int kPrimaryEngineIndex = 0;

inline constexpr int kMaxEngines = 8;

class TimecodeEngine

{

public:

enum class InputSource { MTC, ArtNet, SystemTime, LTC, ProDJLink, StageLinQ, Hippotizer };

//--------------------------------------------------------------------------

explicit TimecodeEngine(int index, const juce::String& name = {})

: engineIndex(index),

engineName(name.isEmpty() ? ("ENGINE " + juce::String(index + 1)) : name)

{

std::fill(std::begin(lastSentMixer), std::end(lastSentMixer), -1); lastMixerPktCount = 0;

// Only the primary engine (index 0) gets AudioThru

if (index == kPrimaryEngineIndex)

audioThru = std::make_unique<AudioThru>();

}

~TimecodeEngine()

{

// Stop MIDI clock timer first (runs on HighResolutionTimer thread)

setMidiClockEnabled(false);

triggerOutput.stopMidi();

triggerOutput.disconnectOsc();

// Shutdown order: outputs first, then inputs

stopMtcOutput();

stopArtnetOutput();

stopLtcOutput();

stopHippotizerOutput();

stopThruOutput();

stopMtcInput();

stopArtnetInput();

stopLtcInput();

stopHippotizerInput();

stopAudioBpm();

// ProDJLink is shared -- not stopped per-engine

// StageLinQ is shared -- not stopped per-engine

}

//==========================================================================

// Identity

//==========================================================================

int getIndex() const { return engineIndex; }

juce::String getName() const { return engineName; }

void setName(const juce::String& name) { engineName = name; }

bool isPrimary() const { return engineIndex == kPrimaryEngineIndex; }

// Called after engine deletion to fix indices so isPrimary() stays correct

// and AudioThru is created for the new primary engine if needed.

// NOTE: The caller (MainComponent::removeEngine) is responsible for

// restarting AudioThru on the new primary engine after reindexing,

// because that requires UI state (device combos) that the engine doesn't own.

void reindex(int newIndex)

{

// If we were the primary engine and are being moved away, destroy AudioThru

// to avoid a stale handler referencing a deleted LtcInput.

if (engineIndex == kPrimaryEngineIndex && newIndex != kPrimaryEngineIndex)

{

stopThruOutput();

audioThru.reset();

outputThruEnabled = false;

}

engineIndex = newIndex;

// Create AudioThru if we just became the primary engine

if (newIndex == kPrimaryEngineIndex && !audioThru)

audioThru = std::make_unique<AudioThru>();

}

//==========================================================================

// Input source

//==========================================================================

InputSource getActiveInput() const { return activeInput; }

FrameRate getCurrentFps() const { return currentFps; }

Timecode getCurrentTimecode() const

{

const juce::SpinLock::ScopedLockType sl(timecodeLock);

return currentTimecode;

}

bool isSourceActive() const { return sourceActive; }

bool getUserOverrodeLtcFps() const { return userOverrodeLtcFps; }

void setInputSource(InputSource source)

{

// Stop current input

switch (activeInput)

{

case InputSource::MTC: stopMtcInput(); break;

case InputSource::ArtNet: stopArtnetInput(); break;

case InputSource::LTC: stopLtcInput(); break;

case InputSource::ProDJLink: stopProDJLinkInput(); break;

case InputSource::StageLinQ: stopStageLinQInput(); break;

case InputSource::Hippotizer: stopHippotizerInput(); break;

default: break;

}

userOverrodeLtcFps = false;

activeInput = source;

sourceActive = false;

// Reset TrackMap cache when leaving ProDJLink / StageLinQ

if (source != InputSource::ProDJLink && source != InputSource::StageLinQ)

{

trackMapped = false;

cachedTrackId = 0;

cachedOffH = cachedOffM = cachedOffS = cachedOffF = 0;

cachedBpmMultiplier = 0;

bpmPlayerOverride = kBpmNoOverride;

cachedTrackArtist.clear();

cachedTrackTitle.clear();

cachedTrackDurationSec = 0;

// Disable Link to avoid publishing stale tempo on the network

// (unless audio BPM is active -- it will keep feeding Link)

if (!audioBpmEnabled)

linkBridge.setEnabled(false);

}

// Note: actual start is deferred to the caller (MainComponent),

// which gathers device params from UI before calling startXxxInput().

if (source == InputSource::SystemTime)

{

sourceActive = genClockMode; // clock mode: always active; transport mode: wait for Play

genLastTickTime = juce::Time::getMillisecondCounterHiRes(); // prevent time jump

}

}

void setFrameRate(FrameRate fps)

{

currentFps = fps;

FrameRate outRate = getEffectiveOutputFps();

mtcOutput.setFrameRate(outRate);

artnetOutput.setFrameRate(outRate);

ltcOutput.setFrameRate(outRate);

hippotizerOutput.setFrameRate(outRate);

}

void setUserOverrodeLtcFps(bool v) { userOverrodeLtcFps = v; }

//==========================================================================

// FPS conversion

//==========================================================================

bool isFpsConvertEnabled() const { return fpsConvertEnabled; }

FrameRate getOutputFps() const { return outputFps; }

Timecode getOutputTimecode() const { return outputTimecode; }

/// Playhead in ms from CDJ/Denon (for UI cursor / position display).

/// Reads directly from ProDJLinkInput or StageLinQInput.

uint32_t getSmoothedPlayheadMs() const

{

if (activeInput == InputSource::StageLinQ && sharedStageLinQ != nullptr)

{

int ep = getEffectivePlayer();

return (ep >= 1) ? sharedStageLinQ->getPlayheadMs(ep) : 0;

}

if (activeInput != InputSource::ProDJLink) return 0; // non-DJ sources use tcToMs in TCNet

if (sharedProDJLink == nullptr) return 0;

int ep = getEffectivePlayer();

if (ep < 1) return 0;

return sharedProDJLink->getPlayheadMs(ep);

}

/// Play position as 0.0-1.0 ratio (for waveform cursor).

float getSmoothedPlayPositionRatio() const

{

if (activeInput == InputSource::StageLinQ && sharedStageLinQ != nullptr)

{

int ep = getEffectivePlayer();

return (ep >= 1) ? sharedStageLinQ->getPlayPositionRatio(ep) : 0.0f;

}

if (activeInput != InputSource::ProDJLink) return 0.0f;

if (sharedProDJLink == nullptr) return 0.0f;

int ep = getEffectivePlayer();

if (ep < 1) return 0.0f;

return sharedProDJLink->getPlayPositionRatio(ep);

}

FrameRate getEffectiveOutputFps() const

{

return fpsConvertEnabled ? outputFps : currentFps;

}

void setFpsConvertEnabled(bool enabled)

{

fpsConvertEnabled = enabled;

if (!enabled)

{

outputFps = currentFps;

setOutputFrameRate(currentFps);

}

}

void setOutputFrameRate(FrameRate fps)

{

outputFps = fps;

// ProDJLink has no inherent frame rate (CDJ sends ms, not frames).

// The user's fps choice IS the current fps.

if (activeInput == InputSource::ProDJLink)

currentFps = fps;

FrameRate outRate = getEffectiveOutputFps();

mtcOutput.setFrameRate(outRate);

artnetOutput.setFrameRate(outRate);

ltcOutput.setFrameRate(outRate);

hippotizerOutput.setFrameRate(outRate);

}

//==========================================================================

// Output enables & offsets

//==========================================================================

bool isOutputMtcEnabled() const { return outputMtcEnabled; }

bool isOutputArtnetEnabled() const { return outputArtnetEnabled; }

bool isOutputLtcEnabled() const { return outputLtcEnabled; }

bool isOutputThruEnabled() const { return outputThruEnabled; }

void setOutputMtcEnabled(bool e) { outputMtcEnabled = e; }

void setOutputArtnetEnabled(bool e) { outputArtnetEnabled = e; }

void setOutputLtcEnabled(bool e) { outputLtcEnabled = e; }

void setOutputThruEnabled(bool e) { outputThruEnabled = e; }

void setOutputTcnetEnabled(bool e) { outputTcnetEnabled = e; }

bool isOutputTcnetEnabled() const { return outputTcnetEnabled; }

void setOutputHippoEnabled(bool e) { outputHippoEnabled = e; }

bool isOutputHippoEnabled() const { return outputHippoEnabled; }

void setTcnetLayer(int l) { tcnetLayer = juce::jlimit(0, 3, l); }

int getTcnetLayer() const { return tcnetLayer; }

int getMtcOutputOffset() const { return mtcOutputOffset; }

int getArtnetOutputOffset() const { return artnetOutputOffset; }

int getLtcOutputOffset() const { return ltcOutputOffset; }

void setMtcOutputOffset(int v) { mtcOutputOffset = v; }

void setArtnetOutputOffset(int v) { artnetOutputOffset = v; }

void setLtcOutputOffset(int v) { ltcOutputOffset = v; }

void setTcnetOutputOffsetMs(int v) { tcnetOutputOffsetMs = juce::jlimit(-1000, 1000, v); }

int getTcnetOutputOffsetMs() const { return tcnetOutputOffsetMs; }

// On-air gate (requires CDJ on-air flag from DJM for engine to be active)

bool isOnAirGateEnabled() const { return onAirGateEnabled; }

void setOnAirGateEnabled(bool e) { onAirGateEnabled = e; }

/// Returns true if the on-air gate allows the engine to be active.

/// If the gate is disabled, always returns true. Otherwise consults the

/// CDJ's on-air flag -- this reflects the DJM mixer's full gating logic

/// (channel fader + cross-fader + EQ kill + mute), computed by the mixer

/// itself and transmitted to the CDJs. The DJ sees the same "ON AIR"

/// indicator light on the CDJ display.

bool isOnAirGateOpen() const

{

if (!onAirGateEnabled) return true;

if (activeInput != InputSource::ProDJLink) return true;

if (sharedProDJLink == nullptr) return true;

// If no DJM is active on the network, the on-air flag is meaningless

// (CDJs default to false without a DJM broadcast). Keep the gate open

// so the engine isn't silenced just because the DJ unplugged the mixer.

if (!sharedProDJLink->hasMixerFaderData()) return true;

int ep = getEffectivePlayer();

// If XF mode hasn't resolved yet (ep == 0) or is out of range,

// don't block the engine.

if (ep < 1 || ep > 4) return true;

return sharedProDJLink->isPlayerOnAir(ep);

}

//==========================================================================

// Protocol handlers -- direct access for device queries

//==========================================================================

MtcInput& getMtcInput() { return mtcInput; }

MtcOutput& getMtcOutput() { return mtcOutput; }

ArtnetInput& getArtnetInput() { return artnetInput; }

ArtnetOutput& getArtnetOutput() { return artnetOutput; }

LtcInput& getLtcInput() { return ltcInput; }

LtcOutput& getLtcOutput() { return ltcOutput; }

ProDJLinkInput& getProDJLinkInput() { jassert(sharedProDJLink != nullptr); return *sharedProDJLink; }

void setSharedProDJLinkInput(ProDJLinkInput* shared) { sharedProDJLink = shared; }

StageLinQInput& getStageLinQInput() { jassert(sharedStageLinQ != nullptr); return *sharedStageLinQ; }

void setSharedStageLinQInput(StageLinQInput* shared) { sharedStageLinQ = shared; }

void setDbServerClient(DbServerClient* client) { dbClient = client; }

int getProDJLinkPlayer() const { return proDJLinkPlayer; }

/// Returns the physical player (1-6) actually being followed.

/// In fixed mode: same as proDJLinkPlayer. In XF mode: the resolved player.

int getEffectivePlayer() const

{

return isXfMode() ? resolvedXfPlayer : proDJLinkPlayer;

}

void setProDJLinkPlayer(int p)

{

proDJLinkPlayer = juce::jlimit(1, kPlayerXfB, p);

resolvedXfPlayer = 0; // force re-resolve on next tick

resetProDJLinkCache();

bpmPlayerOverride = kBpmNoOverride;

lastSentClockBpm = -1.0f;

lastSentOscBpm = -1.0f;

}

AudioThru* getAudioThru() { return audioThru.get(); }

//==========================================================================

// Start / Stop input protocols

//==========================================================================

bool startMtcInput(int deviceIndex)

{

stopMtcInput();

mtcInput.refreshDeviceList();

if (deviceIndex < 0 && mtcInput.getDeviceCount() > 0) deviceIndex = 0;

if (deviceIndex >= 0 && mtcInput.start(deviceIndex))

{

inputStatusText = "RX: " + mtcInput.getCurrentDeviceName();

return true;

}

inputStatusText = (deviceIndex < 0) ? "NO MIDI DEVICE AVAILABLE" : "FAILED TO OPEN DEVICE";

return false;

}

void stopMtcInput() { mtcInput.stop(); }

bool startArtnetInput(int interfaceIndex)

{

stopArtnetInput();

if (interfaceIndex < 0) interfaceIndex = 0;

artnetInput.refreshNetworkInterfaces();

if (artnetInput.start(interfaceIndex, 6454))

{

inputStatusText = "RX ON " + artnetInput.getBindInfo();

if (artnetInput.didFallBackToAllInterfaces())

inputStatusText += " [FALLBACK]";

return true;

}

inputStatusText = "FAILED TO BIND PORT 6454";

return false;

}

void stopArtnetInput() { artnetInput.stop(); }

bool startLtcInput(const juce::String& typeName, const juce::String& devName,

int ltcChannel, int thruChannel = -1,

double sampleRate = 0, int bufferSize = 0)

{

stopLtcInput();

if (devName.isEmpty()) { inputStatusText = "NO AUDIO DEVICE AVAILABLE"; return false; }

if (ltcInput.start(typeName, devName, ltcChannel, thruChannel, sampleRate, bufferSize))

{

inputStatusText = "RX: " + ltcInput.getCurrentDeviceName()

+ " Ch " + juce::String(ltcChannel + 1);

return true;

}

inputStatusText = "FAILED TO OPEN AUDIO DEVICE";

return false;

}

void stopLtcInput()

{

stopThruOutput();

ltcInput.stop();

}

//==========================================================================

// Audio BPM detection (for non-DJ input sources)

//==========================================================================

bool startAudioBpm(const juce::String& typeName, const juce::String& devName,

int channel, double sampleRate = 0, int bufferSize = 0)

{

stopAudioBpm();

if (devName.isEmpty()) return false;

if (audioBpmInput.start(typeName, devName, channel, sampleRate, bufferSize))

{

audioBpmEnabled = true;

return true;

}

return false;

}

void stopAudioBpm()

{

audioBpmEnabled = false;

audioBpmInput.stop();

lastSentClockBpm = -1.0f;

lastSentOscBpm = -1.0f;

}

bool isAudioBpmRunning() const { return audioBpmEnabled && audioBpmInput.getIsRunning(); }

double getAudioBpm() const { return audioBpmInput.getBpm(); }

double getAudioBpmConfidence() const { return audioBpmInput.getConfidence(); }

bool hasAudioBpm() const { return isAudioBpmRunning() && audioBpmInput.hasBpm(); }

float getAudioBpmPeakLevel() const { return audioBpmInput.getPeakLevel(); }

AudioBpmInput& getAudioBpmInput() { return audioBpmInput; }

const AudioBpmInput& getAudioBpmInput() const { return audioBpmInput; }

//==========================================================================

// Pro DJ Link input (shared across engines)

//==========================================================================

void resetProDJLinkCache()

{

trackMapped = false;

cachedTrackId = 0;

lastSeenTrackVersion = 0;

cachedOffH = cachedOffM = cachedOffS = cachedOffF = 0;

cachedTrackArtist.clear();

cachedTrackTitle.clear();

cachedTrackDurationSec = 0;

armedCues.clear();

lastCueCheckMs = 0;

pll.reset(); clearBeatGrid(); pdlTcFrozen = false; pdlLastPlayheadMs = 0; pdlLastAbsPosTs = 0.0;

pdlSnapMs = 0.0; pdlSnapTime = 0.0; pdlSnapSpeed = 1.0;

ltcOutput.setPitchMultiplier(1.0);

std::memset(trigDmxBuffer, 0, sizeof(trigDmxBuffer));

trigDmxHighWater = 0;

}

bool startProDJLinkInput(int player = 1)

{

resetProDJLinkCache();

// Reset forward dedup

lastSentClockBpm = -1.0f;

lastSentOscBpm = -1.0f;

// NOTE: do NOT overwrite currentFps here. The user's fps choice is

// already set via setFrameRate() from settings load or the FPS buttons.

// Previously this was "currentFps = outputFps" which would overwrite

// a user-selected 25fps with outputFps=30 (the default) when loading

// settings, because startProDJLinkInput runs after the initial load.

// LTC direct mode is now toggled dynamically per tick

// (direct in transient, auto-increment in stable)

proDJLinkPlayer = juce::jlimit(1, kPlayerXfB, player);

resolvedXfPlayer = 0; // force resolve on first tick

// NOTE: lastSeenTrackVersion stays at 0 (set by resetProDJLinkCache).

// This forces the first tick to detect the current track as "changed"

// and re-run metadata request + TrackMap lookup + cue point loading.

// Without this, switching away from ProDJLink and back would leave

// cachedTrackId=0 permanently because lastSeenTrackVersion already

// matched the CDJ's current value, so "track changed" never fired.

if (sharedProDJLink != nullptr && sharedProDJLink->getIsRunning())

{

inputStatusText = "LISTENING | " + sharedProDJLink->getBindInfo();

return true;

}

inputStatusText = "WAITING FOR PRO DJ LINK...";

return sharedProDJLink != nullptr;

}

void stopProDJLinkInput()

{

// Reset PLL and LTC encoder state so other sources start clean.

pll.reset(); clearBeatGrid(); pdlTcFrozen = false; pdlLastPlayheadMs = 0; pdlLastAbsPosTs = 0.0;

pdlSnapMs = 0.0; pdlSnapTime = 0.0; pdlSnapSpeed = 1.0;

ltcOutput.setPitchMultiplier(1.0);

}

//==========================================================================

// StageLinQ input (shared across engines)

//==========================================================================

bool startStageLinQInput(int player = 1)

{

resetProDJLinkCache();

// Reset forward dedup

lastSentClockBpm = -1.0f;

lastSentOscBpm = -1.0f;

std::fill(std::begin(lastSentSlqMixer), std::end(lastSentSlqMixer), -1);

// Reset DMX buffer to avoid broadcasting stale Pioneer data

std::memset(dmxBuffer, 0, sizeof(dmxBuffer));

dmxHighWaterMark = 0;

lastDmxSendTime = 0.0;

// NOTE: do NOT overwrite currentFps here (see startProDJLinkInput).

proDJLinkPlayer = juce::jlimit(1, kPlayerXfB, player);

resolvedXfPlayer = 0;

// NOTE: lastSeenTrackVersion stays at 0 (set by resetProDJLinkCache).

// Same rationale as startProDJLinkInput -- forces track rediscovery

// on the first tick after switching back to StageLinQ.

if (sharedStageLinQ != nullptr && sharedStageLinQ->getIsRunning())

{

inputStatusText = "LISTENING | " + sharedStageLinQ->getBindInfo();

return true;

}

inputStatusText = "WAITING FOR STAGELINQ...";

return sharedStageLinQ != nullptr;

}

void stopStageLinQInput()

{

// Reset PLL and LTC encoder state so other sources start clean.

pll.reset(); clearBeatGrid(); pdlTcFrozen = false; pdlLastPlayheadMs = 0; pdlLastAbsPosTs = 0.0;

pdlSnapMs = 0.0; pdlSnapTime = 0.0; pdlSnapSpeed = 1.0;

ltcOutput.setPitchMultiplier(1.0);

}

//==========================================================================

// Hippotizer input (per-engine)

//==========================================================================

HippotizerInput& getHippotizerInput() { return hippotizerInput; }

HippotizerOutput& getHippotizerOutput() { return hippotizerOutput; }

bool startHippotizerInput(int interfaceIndex = 0, int port = 6091)

{

stopHippotizerInput();

hippotizerInput.refreshNetworkInterfaces();

if (interfaceIndex < 0) interfaceIndex = 0;

if (hippotizerInput.start(interfaceIndex, port))

{

inputStatusText = "RX ON " + hippotizerInput.getBindInfo();

if (hippotizerInput.didFallBackToAllInterfaces())

inputStatusText += " [FALLBACK]";

return true;

}

inputStatusText = "FAILED TO BIND PORT " + juce::String(port);

return false;

}

void stopHippotizerInput() { hippotizerInput.stop(); }

//==========================================================================

// TrackMap -- track-to-timecode-offset mapping

//==========================================================================

/// Set the TrackMap pointer (owned by AppSettings, not by the engine).

/// Must be called before enabling track mapping. Pass nullptr to disconnect.

void setTrackMap(TrackMap* map)

{

trackMapPtr = map;

if (map == nullptr)

{

// Clear pending flags to avoid stale operations on a null pointer

trackMapDirty = false;

trackMapAutoFilled = false;

}

}

void setMixerMap(MixerMap* map)

{

mixerMapPtr = map;

std::fill(std::begin(lastSentMixer), std::end(lastSentMixer), -1); lastMixerPktCount = 0;

}

void setSlqMixerMap(MixerMap* map)

{

slqMixerMapPtr = map;

std::fill(std::begin(lastSentSlqMixer), std::end(lastSentSlqMixer), -1);

}

/// Enable or disable TrackMap offset application.

/// Triggers fire independently of this setting.

void setTrackMapEnabled(bool enabled)

{

trackMapEnabled = enabled;

if (!enabled)

{

// Reset offset state only -- keep cachedTrackId for trigger use

trackMapped = false;

cachedOffH = cachedOffM = cachedOffS = cachedOffF = 0;

cachedBpmMultiplier = 0;

lastSentClockBpm = -1.0f;

lastSentOscBpm = -1.0f;

}

else if (trackMapPtr && activeInput == InputSource::ProDJLink

&& sharedProDJLink != nullptr && sharedProDJLink->getIsRunning())

{

lastSeenTrackVersion = sharedProDJLink->getTrackVersion(getEffectivePlayer());

uint32_t id = (cachedTrackId != 0) ? cachedTrackId : sharedProDJLink->getTrackID(getEffectivePlayer());

if (id != 0)

{

cachedTrackId = id;

auto tinfo = sharedProDJLink->getTrackInfo(getEffectivePlayer());

cachedTrackArtist = tinfo.artist;

cachedTrackTitle = tinfo.title;

cachedTrackDurationSec = (int)sharedProDJLink->getTrackLengthSec(getEffectivePlayer());

// Phase 2: check dbClient cache or request if missing

if (dbClient != nullptr && dbClient->getIsRunning())

{

auto meta = dbClient->getCachedMetadataLightById(id);

if (meta.isValid())

{

if (meta.artist.isNotEmpty()) cachedTrackArtist = meta.artist;

if (meta.title.isNotEmpty()) cachedTrackTitle = meta.title;

if (meta.durationSeconds > 0)

{

cachedTrackDurationSec = meta.durationSeconds;

if (sharedProDJLink != nullptr)

sharedProDJLink->setTrackLengthSec(getEffectivePlayer(),

(uint32_t)meta.durationSeconds);

}

}

else

{

requestDbMetadata(id);

}

}

lookupTrackInMap();

}

}

}

bool isTrackMapEnabled() const { return trackMapEnabled; }

/// Whether the currently playing track has a mapping in the TrackMap

bool isTrackMapped() const { return trackMapped; }

/// Get the Track ID currently being tracked (0 if none)

uint32_t getActiveTrackId() const { return cachedTrackId; }

/// Get the cached TrackMap entry info for the current track (for UI display).

/// Returns empty strings and zero offset if no track is mapped.

struct ActiveTrackInfo

{

uint32_t trackId = 0;

juce::String artist;

juce::String title;

juce::String offset = "00:00:00:00";

bool mapped = false;

// Phase 2 -- extended metadata from dbserver (empty if not yet resolved)

juce::String album;

juce::String genre;

juce::String key;

int bpmTimes100 = 0;

uint32_t artworkId = 0;

int durationSec = 0;

};

ActiveTrackInfo getActiveTrackInfo() const

{

ActiveTrackInfo info;

info.trackId = cachedTrackId;

info.artist = cachedTrackArtist;

info.title = cachedTrackTitle;

info.durationSec = cachedTrackDurationSec;

info.mapped = trackMapped;

if (trackMapped)

info.offset = TrackMapEntry::formatTimecodeString(

cachedOffH, cachedOffM, cachedOffS, cachedOffF);

// Phase 2: enrich with dbClient cache if available.

// Uses the lightweight lookup to avoid copying waveform data (~3600B)

// every frame at 60Hz.

if (dbClient != nullptr && cachedTrackId != 0)

{

auto meta = dbClient->getCachedMetadataLightById(cachedTrackId);

if (meta.isValid())

{

info.album = meta.album;

info.genre = meta.genre;

info.key = meta.key;

info.bpmTimes100 = meta.bpmTimes100;

info.artworkId = meta.artworkId;

// Ensure artist/title are from dbClient if available

if (info.artist.isEmpty() || info.title.startsWith("Track #"))

{

if (meta.artist.isNotEmpty()) info.artist = meta.artist;

if (meta.title.isNotEmpty()) info.title = meta.title;

}

}

}

return info;

}

/// Info about the next upcoming (unfired) cue point for UI display.

struct NextCueInfo

{

bool valid = false; // true if a next cue exists

juce::String name; // cue name ("DROP", "LIGHTS ON", etc.)

uint32_t positionMs = 0; // absolute position in track (ms)

int32_t remainingMs = 0; // ms until the cue fires (negative = overdue)

};

/// Returns info about the next unfired cue point relative to the current playhead.

/// Called from UI thread (timerCallback) for countdown display.

NextCueInfo getNextCueInfo() const

{

NextCueInfo info;

if (armedCues.empty()) return info;

uint32_t playhead = lastCueCheckMs; // last known playhead position

// armedCues is sorted by positionMs -- find the first unfired cue

for (const auto& ac : armedCues)

{

if (!ac.fired)

{

info.valid = true;

info.name = ac.cue.name;

info.positionMs = ac.cue.positionMs;

info.remainingMs = (int32_t)ac.cue.positionMs - (int32_t)playhead;

return info;

}

}

return info; // all cues fired

}

/// Force a re-lookup of the current track (e.g., after editing TrackMap)

void refreshTrackMapLookup()

{

if (!trackMapPtr || cachedTrackTitle.isEmpty()) return;

const auto* entry = lookupTrackInMap();

// Reload cue points (user may have added/edited/deleted cues).

// Preserve playhead position so cues behind the current playhead

// are marked as already fired (don't re-trigger on edit).

uint32_t savedPlayhead = lastCueCheckMs;

loadCuePointsForTrack(entry);

if (savedPlayhead > 0)

{

for (auto& ac : armedCues)

ac.fired = (ac.cue.positionMs < savedPlayhead);

lastCueCheckMs = savedPlayhead;

}

}

/// Re-request metadata for the current track (used when waveform data

/// hasn't arrived yet but metadata is already cached -- triggers the

/// waveform-only retry path in DbServerClient).

void retryWaveformRequest()

{

if (cachedTrackId != 0)

requestDbMetadata(cachedTrackId);

}

/// Returns true (once) if auto-fill modified the TrackMap and it was saved.

/// Used by MainComponent to refresh the TrackMapEditor window if open.

bool consumeTrackMapAutoFilled()

{

if (trackMapAutoFilled) { trackMapAutoFilled = false; return true; }

return false;

}

//==========================================================================

// Track change triggers (MIDI / OSC)

//==========================================================================

TriggerOutput& getTriggerOutput() { return triggerOutput; }

//==========================================================================

// Start / Stop output protocols

//==========================================================================

bool startMtcOutput(int deviceIndex)

{

stopMtcOutput();

mtcOutput.refreshDeviceList();

if (deviceIndex < 0 && mtcOutput.getDeviceCount() > 0) deviceIndex = 0;

if (deviceIndex >= 0 && mtcOutput.start(deviceIndex))

{

mtcOutput.setFrameRate(getEffectiveOutputFps());

mtcOutStatusText = "TX: " + mtcOutput.getCurrentDeviceName();

return true;

}

mtcOutStatusText = (deviceIndex < 0) ? "NO MIDI DEVICE" : "FAILED TO OPEN";

return false;

}

void stopMtcOutput() { mtcOutput.stop(); mtcOutStatusText = ""; }

bool startArtnetOutput(int interfaceIndex)

{

stopArtnetOutput();

artnetOutput.refreshNetworkInterfaces();

if (artnetOutput.start(interfaceIndex, 6454))

{

artnetOutput.setFrameRate(getEffectiveOutputFps());

artnetOutStatusText = "TX: " + artnetOutput.getBroadcastIp() + ":6454";

return true;

}

artnetOutStatusText = "FAILED TO BIND";

return false;

}

void stopArtnetOutput() { artnetOutput.stop(); artnetOutStatusText = ""; }

bool startLtcOutput(const juce::String& typeName, const juce::String& devName,

int channel, double sampleRate = 0, int bufferSize = 0)

{

stopLtcOutput();

if (devName.isEmpty()) { ltcOutStatusText = "NO AUDIO DEVICE AVAILABLE"; return false; }

// Check for AudioThru device conflict (primary engine only)

if (audioThru && audioThru->getIsRunning()

&& audioThru->getCurrentDeviceName() == devName

&& audioThru->getCurrentTypeName() == typeName)

{

stopThruOutput();

thruOutStatusText = "CONFLICT: same device as LTC OUT";

}

if (ltcOutput.start(typeName, devName, channel, sampleRate, bufferSize))

{

ltcOutput.setFrameRate(getEffectiveOutputFps());

juce::String chName = (channel == -1) ? "Ch 1 + Ch 2" : ("Ch " + juce::String(channel + 1));

ltcOutStatusText = "TX: " + ltcOutput.getCurrentDeviceName() + " " + chName;

return true;

}

ltcOutStatusText = "FAILED TO OPEN AUDIO DEVICE";

return false;

}

void stopLtcOutput() { ltcOutput.stop(); ltcOutStatusText = ""; }

bool startHippotizerOutput(const juce::String& targetIp, int interfaceIndex = -1)

{

stopHippotizerOutput();

hippotizerOutput.refreshNetworkInterfaces();

if (hippotizerOutput.start(targetIp, interfaceIndex, 6091))

{

hippotizerOutput.setFrameRate(getEffectiveOutputFps());

hippoOutStatusText = "TX: " + hippotizerOutput.getDestination();

return true;

}

hippoOutStatusText = "FAILED TO BIND";

return false;

}

void stopHippotizerOutput() { hippotizerOutput.stop(); hippoOutStatusText = ""; }

bool startThruOutput(const juce::String& typeName, const juce::String& devName,

int channel, double sampleRate = 0, int bufferSize = 0)

{

stopThruOutput();

if (!audioThru) return false; // not primary engine

if (!ltcInput.getIsRunning() || !ltcInput.hasPassthruChannel())

{

thruOutStatusText = "WAITING FOR LTC INPUT";

return false;

}

ltcInput.resetPassthruCounters();

ltcInput.syncPassthruReadPosition();

if (devName.isEmpty()) { thruOutStatusText = "NO AUDIO DEVICE"; return false; }

// Check for LTC output device conflict

if (outputLtcEnabled && ltcOutput.getIsRunning()

&& ltcOutput.getCurrentDeviceName() == devName

&& ltcOutput.getCurrentTypeName() == typeName)

{

thruOutStatusText = "CONFLICT: same device as LTC OUT";

return false;

}

if (audioThru->start(typeName, devName, channel, &ltcInput, sampleRate, bufferSize))

{

juce::String chName = (channel == -1) ? "Ch 1 + Ch 2" : ("Ch " + juce::String(channel + 1));

thruOutStatusText = "THRU: " + audioThru->getCurrentDeviceName() + " " + chName;

double inRate = ltcInput.getActualSampleRate();

double outRate = audioThru->getActualSampleRate();

if (std::abs(inRate - outRate) > 1.0)

thruOutStatusText += " [RATE MISMATCH: " + juce::String((int)inRate) + "/" + juce::String((int)outRate) + "]";

return true;

}

thruOutStatusText = "FAILED TO OPEN";

return false;

}

void stopThruOutput()

{

if (audioThru) audioThru->stop();

thruOutStatusText = "";

}

//==========================================================================

// tick() -- called from timerCallback each frame

//==========================================================================

void tick()

{

// Housekeeping: safely destroy MidiInput devices that were retired

// by MtcInput::stop(). See MtcInput.h for why this is deferred.

mtcInput.drainRetiredDevices();

switch (activeInput)

{

case InputSource::SystemTime:

updateGenerator();

if (genClockMode)

{

sourceActive = true;

if (statusTextVisible)

inputStatusText = "SYSTEM CLOCK";

}

else

{

sourceActive = (genState == GeneratorState::Playing);

if (statusTextVisible)

{

switch (genState)

{

case GeneratorState::Playing: inputStatusText = "PLAYING"; break;

case GeneratorState::Paused: inputStatusText = "PAUSED"; break;

case GeneratorState::Stopped: inputStatusText = "STOPPED"; break;

}

}

}

break;

case InputSource::MTC:

if (mtcInput.getIsRunning())

{

currentTimecode = mtcInput.getCurrentTimecode();

bool rx = mtcInput.isReceiving();

if (rx)

{

auto d = mtcInput.getDetectedFrameRate();

if (d != currentFps) setFrameRate(d);

if (statusTextVisible)

inputStatusText = "RX: " + mtcInput.getCurrentDeviceName();

}

else if (statusTextVisible)

inputStatusText = "PAUSED - " + mtcInput.getCurrentDeviceName();

sourceActive = rx;

}

else { sourceActive = false; if (statusTextVisible) inputStatusText = "WAITING FOR DEVICE..."; }

break;

case InputSource::ArtNet:

if (artnetInput.getIsRunning())

{

currentTimecode = artnetInput.getCurrentTimecode();

bool rx = artnetInput.isReceiving();

if (rx)

{

auto d = artnetInput.getDetectedFrameRate();

if (d != currentFps) setFrameRate(d);

if (statusTextVisible)

inputStatusText = "RX ON " + artnetInput.getBindInfo();

}

else if (statusTextVisible)

inputStatusText = "PAUSED - " + artnetInput.getBindInfo();

sourceActive = rx;

}

else { sourceActive = false; if (statusTextVisible) inputStatusText = "NOT LISTENING"; }

break;

case InputSource::LTC:

if (ltcInput.getIsRunning())

{

currentTimecode = ltcInput.getCurrentTimecode();

bool rx = ltcInput.isReceiving();

if (rx)

{

auto d = ltcInput.getDetectedFrameRate();

bool ambiguousOverride = userOverrodeLtcFps

&& ((currentFps == FrameRate::FPS_2398 && d == FrameRate::FPS_24)

|| (currentFps == FrameRate::FPS_2997 && d == FrameRate::FPS_30));

if (d != currentFps && !ambiguousOverride)

{

if (d != FrameRate::FPS_24 && d != FrameRate::FPS_30)

userOverrodeLtcFps = false;

setFrameRate(d);

}

if (statusTextVisible)

inputStatusText = "RX: " + ltcInput.getCurrentDeviceName()

+ " Ch " + juce::String(ltcInput.getSelectedChannel() + 1);

}

else if (statusTextVisible)

inputStatusText = "PAUSED - " + ltcInput.getCurrentDeviceName();

sourceActive = rx;