OSC sync back

2026-05-10 18:58:26 +10:00
parent d7ca42b51b
commit 198639ae3f
6 changed files with 190 additions and 109 deletions
--- a/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.cpp
@@ -102,6 +102,7 @@ bool RuntimeServices::ApplyPendingOscUpdates(std::vector<AppliedOscUpdate>& appl
 		}

 		AppliedOscUpdate appliedUpdate;
+		appliedUpdate.routeKey = entry.first;
 		appliedUpdate.layerKey = entry.second.layerKey;
 		appliedUpdate.parameterKey = entry.second.parameterKey;
 		appliedUpdate.targetValue = targetValue;
@@ -112,6 +113,35 @@ bool RuntimeServices::ApplyPendingOscUpdates(std::vector<AppliedOscUpdate>& appl
 	return true;
 }

+bool RuntimeServices::QueueOscCommit(const std::string& routeKey, const std::string& layerKey, const std::string& parameterKey, const JsonValue& value, uint64_t generation, std::string& error)
+{
+	(void)error;
+
+	PendingOscCommit commit;
+	commit.routeKey = routeKey;
+	commit.layerKey = layerKey;
+	commit.parameterKey = parameterKey;
+	commit.value = value;
+	commit.generation = generation;
+
+	{
+		std::lock_guard<std::mutex> lock(mPendingOscCommitMutex);
+		mPendingOscCommits[routeKey] = std::move(commit);
+	}
+	return true;
+}
+
+void RuntimeServices::ConsumeCompletedOscCommits(std::vector<CompletedOscCommit>& completedCommits)
+{
+	completedCommits.clear();
+
+	std::lock_guard<std::mutex> lock(mCompletedOscCommitMutex);
+	if (mCompletedOscCommits.empty())
+		return;
+
+	completedCommits.swap(mCompletedOscCommits);
+}
+
 RuntimePollEvents RuntimeServices::ConsumePollEvents()
 {
 	RuntimePollEvents events;
@@ -149,6 +179,33 @@ void RuntimeServices::PollLoop(RuntimeHost& runtimeHost)
 {
 	while (mPollRunning)
 	{
+		std::map<std::string, PendingOscCommit> pendingCommits;
+		{
+			std::lock_guard<std::mutex> lock(mPendingOscCommitMutex);
+			pendingCommits.swap(mPendingOscCommits);
+		}
+		for (const auto& entry : pendingCommits)
+		{
+			std::string commitError;
+			if (runtimeHost.UpdateLayerParameterByControlKey(
+				entry.second.layerKey,
+				entry.second.parameterKey,
+				entry.second.value,
+				false,
+				commitError))
+			{
+				CompletedOscCommit completedCommit;
+				completedCommit.routeKey = entry.second.routeKey;
+				completedCommit.generation = entry.second.generation;
+				std::lock_guard<std::mutex> lock(mCompletedOscCommitMutex);
+				mCompletedOscCommits.push_back(std::move(completedCommit));
+			}
+			else if (!commitError.empty())
+			{
+				OutputDebugStringA(("OSC commit failed: " + commitError + "\n").c_str());
+			}
+		}
+
 		bool registryChanged = false;
 		bool reloadRequested = false;
 		std::string runtimeError;
--- a/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.h
+++ b/apps/LoopThroughWithOpenGLCompositing/control/RuntimeServices.h
@@ -28,11 +28,18 @@ class RuntimeServices
 public:
 	struct AppliedOscUpdate
 	{
+		std::string routeKey;
 		std::string layerKey;
 		std::string parameterKey;
 		JsonValue targetValue;
 	};

+	struct CompletedOscCommit
+	{
+		std::string routeKey;
+		uint64_t generation = 0;
+	};
+
 	RuntimeServices();
 	~RuntimeServices();

@@ -43,6 +50,8 @@ public:
 	void RequestBroadcastState();
 	bool QueueOscUpdate(const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& error);
 	bool ApplyPendingOscUpdates(std::vector<AppliedOscUpdate>& appliedUpdates, std::string& error);
+	bool QueueOscCommit(const std::string& routeKey, const std::string& layerKey, const std::string& parameterKey, const JsonValue& value, uint64_t generation, std::string& error);
+	void ConsumeCompletedOscCommits(std::vector<CompletedOscCommit>& completedCommits);
 	RuntimePollEvents ConsumePollEvents();

 private:
@@ -53,6 +62,15 @@ private:
 		std::string valueJson;
 	};

+	struct PendingOscCommit
+	{
+		std::string routeKey;
+		std::string layerKey;
+		std::string parameterKey;
+		JsonValue value;
+		uint64_t generation = 0;
+	};
+
 	void StartPolling(RuntimeHost& runtimeHost);
 	void StopPolling();
 	void PollLoop(RuntimeHost& runtimeHost);
@@ -68,4 +86,8 @@ private:
 	std::string mPollError;
 	std::mutex mPendingOscMutex;
 	std::map<std::string, PendingOscUpdate> mPendingOscUpdates;
+	std::mutex mPendingOscCommitMutex;
+	std::map<std::string, PendingOscCommit> mPendingOscCommits;
+	std::mutex mCompletedOscCommitMutex;
+	std::vector<CompletedOscCommit> mCompletedOscCommits;
 };
--- a/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp
@@ -15,6 +15,7 @@
 #include <algorithm>
 #include <cctype>
 #include <chrono>
+#include <cmath>
 #include <ctime>
 #include <filesystem>
 #include <iomanip>
@@ -27,6 +28,8 @@
 namespace
 {
 constexpr auto kOscOverlayCommitDelay = std::chrono::milliseconds(150);
+constexpr double kOscSmoothingReferenceFps = 60.0;
+constexpr double kOscSmoothingMaxStepSeconds = 0.25;

 std::string SimplifyOscControlKey(const std::string& text)
 {
@@ -49,6 +52,22 @@ double ClampOscAlpha(double value)
 	return (std::max)(0.0, (std::min)(1.0, value));
 }

+double ComputeTimeBasedOscAlpha(double smoothing, double deltaSeconds)
+{
+	const double clampedSmoothing = ClampOscAlpha(smoothing);
+	if (clampedSmoothing <= 0.0)
+		return 0.0;
+	if (clampedSmoothing >= 1.0)
+		return 1.0;
+
+	const double clampedDeltaSeconds = (std::max)(0.0, (std::min)(kOscSmoothingMaxStepSeconds, deltaSeconds));
+	if (clampedDeltaSeconds <= 0.0)
+		return 0.0;
+
+	const double frameScale = clampedDeltaSeconds * kOscSmoothingReferenceFps;
+	return ClampOscAlpha(1.0 - std::pow(1.0 - clampedSmoothing, frameScale));
+}
+
 JsonValue BuildOscCommitValue(const ShaderParameterDefinition& definition, const ShaderParameterValue& value)
 {
 	switch (definition.type)
@@ -378,18 +397,35 @@ void OpenGLComposite::renderEffect()
 {
 	ProcessRuntimePollResults();
 	std::vector<RuntimeServices::AppliedOscUpdate> appliedOscUpdates;
+	std::vector<RuntimeServices::CompletedOscCommit> completedOscCommits;
 	if (mRuntimeHost && mRuntimeServices)
 	{
 		std::string oscError;
 		if (!mRuntimeServices->ApplyPendingOscUpdates(appliedOscUpdates, oscError) && !oscError.empty())
 			OutputDebugStringA(("OSC apply failed: " + oscError + "\n").c_str());
+		mRuntimeServices->ConsumeCompletedOscCommits(completedOscCommits);
+	}
+
+	for (const RuntimeServices::CompletedOscCommit& completedCommit : completedOscCommits)
+	{
+		auto overlayIt = mOscOverlayStates.find(completedCommit.routeKey);
+		if (overlayIt == mOscOverlayStates.end())
+			continue;
+
+		OscOverlayState& overlay = overlayIt->second;
+		if (overlay.commitQueued &&
+			overlay.pendingCommitGeneration == completedCommit.generation &&
+			overlay.generation == completedCommit.generation)
+		{
+			mOscOverlayStates.erase(overlayIt);
+		}
 	}

 	std::set<std::string> pendingOscRouteKeys;
 	const auto oscNow = std::chrono::steady_clock::now();
 	for (const RuntimeServices::AppliedOscUpdate& update : appliedOscUpdates)
 	{
-		const std::string routeKey = update.layerKey + "\n" + update.parameterKey;
+		const std::string routeKey = update.routeKey;
 		auto overlayIt = mOscOverlayStates.find(routeKey);
 		if (overlayIt == mOscOverlayStates.end())
 		{
@@ -398,12 +434,16 @@ void OpenGLComposite::renderEffect()
 			overlay.parameterKey = update.parameterKey;
 			overlay.targetValue = update.targetValue;
 			overlay.lastUpdatedTime = oscNow;
+			overlay.lastAppliedTime = oscNow;
+			overlay.generation = 1;
 			mOscOverlayStates[routeKey] = std::move(overlay);
 		}
 		else
 		{
 			overlayIt->second.targetValue = update.targetValue;
 			overlayIt->second.lastUpdatedTime = oscNow;
+			overlayIt->second.generation += 1;
+			overlayIt->second.commitQueued = false;
 		}
 		pendingOscRouteKeys.insert(routeKey);
 	}
@@ -465,11 +505,17 @@ void OpenGLComposite::renderEffect()
 				overlay.currentValue = targetValue;
 				overlay.hasCurrentValue = true;
 				stateIt->parameterValues[definitionIt->id] = overlay.currentValue;
-				if (allowCommit && oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay)
+				if (allowCommit &&
+					!overlay.commitQueued &&
+					oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay &&
+					mRuntimeServices)
 				{
 					std::string commitError;
-					if (mRuntimeHost->UpdateLayerParameterByControlKey(overlay.layerKey, overlay.parameterKey, overlay.targetValue, false, commitError))
-						overlayKeysToRemove.push_back(item.first);
+					if (mRuntimeServices->QueueOscCommit(item.first, overlay.layerKey, overlay.parameterKey, overlay.targetValue, overlay.generation, commitError))
+					{
+						overlay.pendingCommitGeneration = overlay.generation;
+						overlay.commitQueued = true;
+					}
 				}
 				continue;
 			}
@@ -486,6 +532,15 @@ void OpenGLComposite::renderEffect()
 			if (overlay.currentValue.numberValues.size() != targetValue.numberValues.size())
 				overlay.currentValue.numberValues = targetValue.numberValues;

+			double smoothingAlpha = smoothing;
+			if (overlay.lastAppliedTime != std::chrono::steady_clock::time_point())
+			{
+				const double deltaSeconds =
+					std::chrono::duration_cast<std::chrono::duration<double>>(oscNow - overlay.lastAppliedTime).count();
+				smoothingAlpha = ComputeTimeBasedOscAlpha(smoothing, deltaSeconds);
+			}
+			overlay.lastAppliedTime = oscNow;
+
 			ShaderParameterValue nextValue = targetValue;
 			bool converged = true;
 			for (std::size_t index = 0; index < targetValue.numberValues.size(); ++index)
@@ -493,7 +548,7 @@ void OpenGLComposite::renderEffect()
 				const double currentNumber = overlay.currentValue.numberValues[index];
 				const double targetNumber = targetValue.numberValues[index];
 				const double delta = targetNumber - currentNumber;
-				double nextNumber = currentNumber + delta * smoothing;
+				double nextNumber = currentNumber + delta * smoothingAlpha;
 				if (std::fabs(delta) <= 0.0005)
 					nextNumber = targetNumber;
 				else
@@ -507,20 +562,24 @@ void OpenGLComposite::renderEffect()
 			overlay.currentValue = nextValue;
 			overlay.hasCurrentValue = true;
 			stateIt->parameterValues[definitionIt->id] = overlay.currentValue;
-			if (allowCommit && converged && oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay)
+			if (allowCommit &&
+				converged &&
+				!overlay.commitQueued &&
+				oscNow - overlay.lastUpdatedTime >= kOscOverlayCommitDelay &&
+				mRuntimeServices)
 			{
 				std::string commitError;
 				JsonValue committedValue = BuildOscCommitValue(*definitionIt, overlay.currentValue);
-				if (mRuntimeHost->UpdateLayerParameterByControlKey(overlay.layerKey, overlay.parameterKey, committedValue, false, commitError))
-					overlayKeysToRemove.push_back(item.first);
+				if (mRuntimeServices->QueueOscCommit(item.first, overlay.layerKey, overlay.parameterKey, committedValue, overlay.generation, commitError))
+				{
+					overlay.pendingCommitGeneration = overlay.generation;
+					overlay.commitQueued = true;
+				}
 			}
 		}

-		if (allowCommit)
-		{
-			for (const std::string& overlayKey : overlayKeysToRemove)
-				mOscOverlayStates.erase(overlayKey);
-		}
+		for (const std::string& overlayKey : overlayKeysToRemove)
+			mOscOverlayStates.erase(overlayKey);
 	};

 	const bool hasInputSource = mVideoIO->HasInputSource();
--- a/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h
+++ b/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h
@@ -81,6 +81,10 @@ private:
 		ShaderParameterValue currentValue;
 		bool hasCurrentValue = false;
 		std::chrono::steady_clock::time_point lastUpdatedTime;
+		std::chrono::steady_clock::time_point lastAppliedTime;
+		uint64_t generation = 0;
+		uint64_t pendingCommitGeneration = 0;
+		bool commitQueued = false;
 	};

 	HWND									hGLWnd;
--- a/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/gl/pipeline/OpenGLVideoIOBridge.cpp
@@ -65,7 +65,10 @@ void OpenGLVideoIOBridge::VideoFrameArrived(const VideoIOFrame& inputFrame)

 	const long textureSize = inputFrame.rowBytes * static_cast<long>(inputFrame.height);

-	EnterCriticalSection(&mMutex);
+	// Never let input upload stall the playout/render callback. If the GL bridge
+	// is busy producing an output frame, skip this upload and use the next input.
+	if (!TryEnterCriticalSection(&mMutex))
+		return;

 	wglMakeCurrent(mHdc, mHglrc);		// make OpenGL context current in this thread

@@ -93,32 +96,29 @@ void OpenGLVideoIOBridge::PlayoutFrameCompleted(const VideoIOCompletion& complet
 {
 	RecordFramePacing(completion.result);

-	EnterCriticalSection(&mMutex);
-
 	VideoIOOutputFrame outputFrame;
 	if (!mVideoIO.BeginOutputFrame(outputFrame))
-	{
-		LeaveCriticalSection(&mMutex);
 		return;
-	}
 	const VideoIOState& state = mVideoIO.State();
 	RenderPipelineFrameContext frameContext;
 	frameContext.videoState = state;
 	frameContext.completion = completion;

+	EnterCriticalSection(&mMutex);
+
 	// make GL context current in this thread
 	wglMakeCurrent(mHdc, mHglrc);

 	mRenderPipeline.RenderFrame(frameContext, outputFrame);
+	wglMakeCurrent(NULL, NULL);
+
+	LeaveCriticalSection(&mMutex);

 	mVideoIO.EndOutputFrame(outputFrame);

 	mVideoIO.AccountForCompletionResult(completion.result);

-	// Schedule the next frame for playout
+	// Schedule the next frame for playout after the GL bridge is released so
+	// input uploads are not blocked by non-GL output bookkeeping.
 	mVideoIO.ScheduleOutputFrame(outputFrame);
-
-	wglMakeCurrent(NULL, NULL);
-
-	LeaveCriticalSection(&mMutex);
 }