Pacing problems

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -53,12 +53,17 @@
 
 #include <memory>
 #include <string>
+#include <thread>
 #include <vector>
 
 OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	hGLWnd(hWnd), hGLDC(hDC), hGLRC(hRC),
 	mDeckLink(std::make_unique<DeckLinkSession>()),
-	mRenderer(std::make_unique<OpenGLRenderer>())
+	mRenderer(std::make_unique<OpenGLRenderer>()),
+	mRuntimePollRunning(false),
+	mRuntimeRegistryChanged(false),
+	mRuntimeReloadRequested(false),
+	mRuntimePollFailed(false)
 {
 	InitializeCriticalSection(&pMutex);
 	mRuntimeHost = std::make_unique<RuntimeHost>();
@@ -79,6 +84,7 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 
 OpenGLComposite::~OpenGLComposite()
 {
+	StopRuntimePolling();
 	mDeckLink->ReleaseResources();
 	mRenderer->DestroyResources();
 	if (mOscServer)
@@ -284,6 +290,7 @@ bool OpenGLComposite::InitOpenGLState()
 	}
 
 	broadcastRuntimeState();
+	StartRuntimePolling();
 	return true;
 }
 
@@ -305,6 +312,8 @@ bool OpenGLComposite::Start()
 
 bool OpenGLComposite::Stop()
 {
+	StopRuntimePolling();
+
 	if (mOscServer)
 		mOscServer->Stop();
 
@@ -351,10 +360,17 @@ bool OpenGLComposite::ReloadShader()
 
 void OpenGLComposite::renderEffect()
 {
-	PollRuntimeChanges();
+	ProcessRuntimePollResults();
 
 	const bool hasInputSource = mDeckLink->HasInputSource();
-	const std::vector<RuntimeRenderState> layerStates = mRuntimeHost ? mRuntimeHost->GetLayerRenderStates(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight()) : std::vector<RuntimeRenderState>();
+	std::vector<RuntimeRenderState> layerStates;
+	if (mRuntimeHost)
+	{
+		if (mRuntimeHost->TryGetLayerRenderStates(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), layerStates))
+			mCachedLayerRenderStates = layerStates;
+		else
+			layerStates = mCachedLayerRenderStates;
+	}
 	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
 	mRenderPass->Render(
 		hasInputSource,
@@ -370,25 +386,72 @@ void OpenGLComposite::renderEffect()
 		});
 }
 
-bool OpenGLComposite::PollRuntimeChanges()
+void OpenGLComposite::StartRuntimePolling()
+{
+	if (!mRuntimeHost || mRuntimePollRunning.exchange(true))
+		return;
+
+	mRuntimePollThread = std::thread([this]() { RuntimePollLoop(); });
+}
+
+void OpenGLComposite::StopRuntimePolling()
+{
+	if (!mRuntimePollRunning.exchange(false))
+		return;
+
+	if (mRuntimePollThread.joinable())
+		mRuntimePollThread.join();
+}
+
+void OpenGLComposite::RuntimePollLoop()
+{
+	while (mRuntimePollRunning)
+	{
+		bool registryChanged = false;
+		bool reloadRequested = false;
+		std::string runtimeError;
+		if (!mRuntimeHost->PollFileChanges(registryChanged, reloadRequested, runtimeError))
+		{
+			{
+				std::lock_guard<std::mutex> lock(mRuntimePollErrorMutex);
+				mRuntimePollError = runtimeError;
+			}
+			mRuntimePollFailed = true;
+		}
+		else
+		{
+			if (registryChanged)
+				mRuntimeRegistryChanged = true;
+			if (reloadRequested)
+				mRuntimeReloadRequested = true;
+		}
+
+		for (int i = 0; i < 25 && mRuntimePollRunning; ++i)
+			Sleep(10);
+	}
+}
+
+bool OpenGLComposite::ProcessRuntimePollResults()
 {
 	if (!mRuntimeHost)
 		return true;
 
-	bool registryChanged = false;
-	bool reloadRequested = false;
-	std::string runtimeError;
-	if (!mRuntimeHost->PollFileChanges(registryChanged, reloadRequested, runtimeError))
+	if (mRuntimePollFailed.exchange(false))
 	{
+		std::string runtimeError;
+		{
+			std::lock_guard<std::mutex> lock(mRuntimePollErrorMutex);
+			runtimeError = mRuntimePollError;
+		}
 		mRuntimeHost->SetCompileStatus(false, runtimeError);
 		broadcastRuntimeState();
 		return false;
 	}
 
-	if (registryChanged)
+	if (mRuntimeRegistryChanged.exchange(false))
 		broadcastRuntimeState();
 
-	if (!reloadRequested)
+	if (!mRuntimeReloadRequested.exchange(false))
 		return true;
 
 	char compilerErrorMessage[1024] = {};