CPU optimisations

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.cpp

@@ -841,6 +841,8 @@ bool RuntimeHost::PollFileChanges(bool& registryChanged, bool& reloadRequested,
 		}
 
 		reloadRequested = mReloadRequested;
+		if (registryChanged || reloadRequested)
+			MarkRenderStateDirtyLocked();
 		return true;
 	}
 	catch (const std::exception& exception)
@@ -884,6 +886,7 @@ bool RuntimeHost::AddLayer(const std::string& shaderId, std::string& error)
 	EnsureLayerDefaultsLocked(layer, shaderIt->second);
 	mPersistentState.layers.push_back(layer);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -900,6 +903,7 @@ bool RuntimeHost::RemoveLayer(const std::string& layerId, std::string& error)
 
 	mPersistentState.layers.erase(it);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -921,6 +925,7 @@ bool RuntimeHost::MoveLayer(const std::string& layerId, int direction, std::stri
 
 	std::swap(mPersistentState.layers[index], mPersistentState.layers[newIndex]);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -949,6 +954,7 @@ bool RuntimeHost::MoveLayerToIndex(const std::string& layerId, std::size_t targe
 	mPersistentState.layers.erase(mPersistentState.layers.begin() + static_cast<std::ptrdiff_t>(sourceIndex));
 	mPersistentState.layers.insert(mPersistentState.layers.begin() + static_cast<std::ptrdiff_t>(targetIndex), movedLayer);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -964,6 +970,7 @@ bool RuntimeHost::SetLayerBypass(const std::string& layerId, bool bypassed, std:
 
 	layer->bypass = bypassed;
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -988,6 +995,7 @@ bool RuntimeHost::SetLayerShader(const std::string& layerId, const std::string&
 	layer->parameterValues.clear();
 	EnsureLayerDefaultsLocked(*layer, shaderIt->second);
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1024,6 +1032,7 @@ bool RuntimeHost::UpdateLayerParameter(const std::string& layerId, const std::st
 		const double previousCount = value.numberValues.empty() ? 0.0 : value.numberValues[0];
 		const double triggerTime = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mStartTime).count();
 		value.numberValues = { previousCount + 1.0, triggerTime };
+		MarkRenderStateDirtyLocked();
 		return true;
 	}
 
@@ -1032,6 +1041,7 @@ bool RuntimeHost::UpdateLayerParameter(const std::string& layerId, const std::st
 		return false;
 
 	layer->parameterValues[parameterId] = normalized;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1079,6 +1089,7 @@ bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey,
 		const double previousCount = value.numberValues.empty() ? 0.0 : value.numberValues[0];
 		const double triggerTime = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - mStartTime).count();
 		value.numberValues = { previousCount + 1.0, triggerTime };
+		MarkRenderStateDirtyLocked();
 		return true;
 	}
 
@@ -1087,6 +1098,7 @@ bool RuntimeHost::UpdateLayerParameterByControlKey(const std::string& layerKey,
 		return false;
 
 	matchedLayer->parameterValues[parameterIt->id] = normalized;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1110,6 +1122,7 @@ bool RuntimeHost::ResetLayerParameters(const std::string& layerId, std::string&
 
 	layer->parameterValues.clear();
 	EnsureLayerDefaultsLocked(*layer, shaderIt->second);
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1169,6 +1182,7 @@ bool RuntimeHost::LoadStackPreset(const std::string& presetName, std::string& er
 
 	mPersistentState.layers = nextLayers;
 	mReloadRequested = true;
+	MarkRenderStateDirtyLocked();
 	return SavePersistentState(error);
 }
 
@@ -1197,10 +1211,21 @@ bool RuntimeHost::TrySetSignalStatus(bool hasSignal, unsigned width, unsigned he
 
 void RuntimeHost::SetSignalStatusLocked(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
 {
+	const bool changed = mHasSignal != hasSignal ||
+		mSignalWidth != width ||
+		mSignalHeight != height ||
+		mSignalModeName != modeName;
 	mHasSignal = hasSignal;
 	mSignalWidth = width;
 	mSignalHeight = height;
 	mSignalModeName = modeName;
+	if (changed)
+		MarkRenderStateDirtyLocked();
+}
+
+void RuntimeHost::MarkRenderStateDirtyLocked()
+{
+	mRenderStateVersion.fetch_add(1, std::memory_order_relaxed);
 }
 
 void RuntimeHost::SetDeckLinkOutputStatus(const std::string& modelName, bool supportsInternalKeying, bool supportsExternalKeying,
@@ -1456,6 +1481,11 @@ bool RuntimeHost::LoadConfig(std::string& error)
 		const double configuredValue = maxTemporalHistoryFramesValue->asNumber(static_cast<double>(mConfig.maxTemporalHistoryFrames));
 		mConfig.maxTemporalHistoryFrames = configuredValue <= 0.0 ? 0u : static_cast<unsigned>(configuredValue);
 	}
+	if (const JsonValue* previewFpsValue = configJson.find("previewFps"))
+	{
+		const double configuredValue = previewFpsValue->asNumber(static_cast<double>(mConfig.previewFps));
+		mConfig.previewFps = configuredValue <= 0.0 ? 0u : static_cast<unsigned>(configuredValue);
+	}
 	if (const JsonValue* enableExternalKeyingValue = configJson.find("enableExternalKeying"))
 		mConfig.enableExternalKeying = enableExternalKeyingValue->asBoolean(mConfig.enableExternalKeying);
 	if (const JsonValue* videoFormatValue = configJson.find("videoFormat"))
@@ -1674,6 +1704,8 @@ bool RuntimeHost::ScanShaderPackages(std::string& error)
 			++it;
 	}
 
+	MarkRenderStateDirtyLocked();
+
 	return true;
 }
 
@@ -1840,6 +1872,7 @@ JsonValue RuntimeHost::BuildStateValue() const
 	app.set("oscPort", JsonValue(static_cast<double>(mConfig.oscPort)));
 	app.set("autoReload", JsonValue(mAutoReloadEnabled));
 	app.set("maxTemporalHistoryFrames", JsonValue(static_cast<double>(mConfig.maxTemporalHistoryFrames)));
+	app.set("previewFps", JsonValue(static_cast<double>(mConfig.previewFps)));
 	app.set("enableExternalKeying", JsonValue(mConfig.enableExternalKeying));
 	app.set("inputVideoFormat", JsonValue(mConfig.inputVideoFormat));
 	app.set("inputFrameRate", JsonValue(mConfig.inputFrameRate));

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.h

@@ -56,6 +56,7 @@ public:
 	bool TryGetLayerRenderStates(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const;
 	void RefreshDynamicRenderStateFields(std::vector<RuntimeRenderState>& states) const;
 	std::string BuildStateJson() const;
+	uint64_t GetRenderStateVersion() const { return mRenderStateVersion.load(std::memory_order_relaxed); }
 
 	const std::filesystem::path& GetRepoRoot() const { return mRepoRoot; }
 	const std::filesystem::path& GetUiRoot() const { return mUiRoot; }
@@ -64,6 +65,7 @@ public:
 	unsigned short GetServerPort() const { return mServerPort; }
 	unsigned short GetOscPort() const { return mConfig.oscPort; }
 	unsigned GetMaxTemporalHistoryFrames() const { return mConfig.maxTemporalHistoryFrames; }
+	unsigned GetPreviewFps() const { return mConfig.previewFps; }
 	bool ExternalKeyingEnabled() const { return mConfig.enableExternalKeying; }
 	const std::string& GetInputVideoFormat() const { return mConfig.inputVideoFormat; }
 	const std::string& GetInputFrameRate() const { return mConfig.inputFrameRate; }
@@ -80,6 +82,7 @@ private:
 		unsigned short oscPort = 9000;
 		bool autoReload = true;
 		unsigned maxTemporalHistoryFrames = 4;
+		unsigned previewFps = 30;
 		bool enableExternalKeying = false;
 		std::string inputVideoFormat = "1080p";
 		std::string inputFrameRate = "59.94";
@@ -135,6 +138,7 @@ private:
 	const LayerPersistentState* FindLayerById(const std::string& layerId) const;
 	std::string GenerateLayerId();
 	void SetSignalStatusLocked(bool hasSignal, unsigned width, unsigned height, const std::string& modeName);
+	void MarkRenderStateDirtyLocked();
 	void SetPerformanceStatsLocked(double frameBudgetMilliseconds, double renderMilliseconds);
 	void SetFramePacingStatsLocked(double completionIntervalMilliseconds, double smoothedCompletionIntervalMilliseconds,
 		double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount);
@@ -179,6 +183,7 @@ private:
 	bool mAutoReloadEnabled;
 	std::chrono::steady_clock::time_point mStartTime;
 	std::chrono::steady_clock::time_point mLastScanTime;
-	std::atomic<uint64_t> mFrameCounter;
+	std::atomic<uint64_t> mFrameCounter{ 0 };
+	std::atomic<uint64_t> mRenderStateVersion{ 0 };
 	uint64_t mNextLayerId;
 };