Pacing problems

apps/LoopThroughWithOpenGLCompositing/runtime/RuntimeHost.cpp

@@ -1155,6 +1155,21 @@ void RuntimeHost::SetCompileStatus(bool succeeded, const std::string& message)
 void RuntimeHost::SetSignalStatus(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
 {
 	std::lock_guard<std::mutex> lock(mMutex);
+	SetSignalStatusLocked(hasSignal, width, height, modeName);
+}
+
+bool RuntimeHost::TrySetSignalStatus(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
+{
+	std::unique_lock<std::mutex> lock(mMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return false;
+
+	SetSignalStatusLocked(hasSignal, width, height, modeName);
+	return true;
+}
+
+void RuntimeHost::SetSignalStatusLocked(bool hasSignal, unsigned width, unsigned height, const std::string& modeName)
+{
 	mHasSignal = hasSignal;
 	mSignalWidth = width;
 	mSignalHeight = height;
@@ -1177,6 +1192,21 @@ void RuntimeHost::SetDeckLinkOutputStatus(const std::string& modelName, bool sup
 void RuntimeHost::SetPerformanceStats(double frameBudgetMilliseconds, double renderMilliseconds)
 {
 	std::lock_guard<std::mutex> lock(mMutex);
+	SetPerformanceStatsLocked(frameBudgetMilliseconds, renderMilliseconds);
+}
+
+bool RuntimeHost::TrySetPerformanceStats(double frameBudgetMilliseconds, double renderMilliseconds)
+{
+	std::unique_lock<std::mutex> lock(mMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return false;
+
+	SetPerformanceStatsLocked(frameBudgetMilliseconds, renderMilliseconds);
+	return true;
+}
+
+void RuntimeHost::SetPerformanceStatsLocked(double frameBudgetMilliseconds, double renderMilliseconds)
+{
 	mFrameBudgetMilliseconds = std::max(frameBudgetMilliseconds, 0.0);
 	mRenderMilliseconds = std::max(renderMilliseconds, 0.0);
 	if (mSmoothedRenderMilliseconds <= 0.0)
@@ -1189,6 +1219,25 @@ void RuntimeHost::SetFramePacingStats(double completionIntervalMilliseconds, dou
 	double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount)
 {
 	std::lock_guard<std::mutex> lock(mMutex);
+	SetFramePacingStatsLocked(completionIntervalMilliseconds, smoothedCompletionIntervalMilliseconds,
+		maxCompletionIntervalMilliseconds, lateFrameCount, droppedFrameCount, flushedFrameCount);
+}
+
+bool RuntimeHost::TrySetFramePacingStats(double completionIntervalMilliseconds, double smoothedCompletionIntervalMilliseconds,
+	double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount)
+{
+	std::unique_lock<std::mutex> lock(mMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return false;
+
+	SetFramePacingStatsLocked(completionIntervalMilliseconds, smoothedCompletionIntervalMilliseconds,
+		maxCompletionIntervalMilliseconds, lateFrameCount, droppedFrameCount, flushedFrameCount);
+	return true;
+}
+
+void RuntimeHost::SetFramePacingStatsLocked(double completionIntervalMilliseconds, double smoothedCompletionIntervalMilliseconds,
+	double maxCompletionIntervalMilliseconds, uint64_t lateFrameCount, uint64_t droppedFrameCount, uint64_t flushedFrameCount)
+{
 	mCompletionIntervalMilliseconds = std::max(completionIntervalMilliseconds, 0.0);
 	mSmoothedCompletionIntervalMilliseconds = std::max(smoothedCompletionIntervalMilliseconds, 0.0);
 	mMaxCompletionIntervalMilliseconds = std::max(maxCompletionIntervalMilliseconds, 0.0);
@@ -1203,6 +1252,16 @@ void RuntimeHost::AdvanceFrame()
 	++mFrameCounter;
 }
 
+bool RuntimeHost::TryAdvanceFrame()
+{
+	std::unique_lock<std::mutex> lock(mMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return false;
+
+	++mFrameCounter;
+	return true;
+}
+
 bool RuntimeHost::BuildLayerFragmentShaderSource(const std::string& layerId, std::string& fragmentShaderSource, std::string& error)
 {
 	try
@@ -1245,7 +1304,23 @@ std::vector<RuntimeRenderState> RuntimeHost::GetLayerRenderStates(unsigned outpu
 {
 	std::lock_guard<std::mutex> lock(mMutex);
 	std::vector<RuntimeRenderState> states;
+	BuildLayerRenderStatesLocked(outputWidth, outputHeight, states);
+	return states;
+}
 
+bool RuntimeHost::TryGetLayerRenderStates(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const
+{
+	std::unique_lock<std::mutex> lock(mMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return false;
+
+	states.clear();
+	BuildLayerRenderStatesLocked(outputWidth, outputHeight, states);
+	return true;
+}
+
+void RuntimeHost::BuildLayerRenderStatesLocked(unsigned outputWidth, unsigned outputHeight, std::vector<RuntimeRenderState>& states) const
+{
 	for (const LayerPersistentState& layer : mPersistentState.layers)
 	{
 		auto shaderIt = mPackagesById.find(layer.shaderId);
@@ -1282,8 +1357,6 @@ std::vector<RuntimeRenderState> RuntimeHost::GetLayerRenderStates(unsigned outpu
 
 		states.push_back(state);
 	}
-
-	return states;
 }
 
 std::string RuntimeHost::BuildStateJson() const