OSC sync back

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();

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;

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);
 }