more seperation

apps/LoopThroughWithOpenGLCompositing/videoio/VideoBackend.cpp

@@ -2,12 +2,15 @@
 
 #include "DeckLinkSession.h"
 #include "OpenGLVideoIOBridge.h"
-#include "RenderEngine.h"
 #include "HealthTelemetry.h"
+#include "RenderEngine.h"
+
+#include <chrono>
 
 VideoBackend::VideoBackend(RenderEngine& renderEngine, HealthTelemetry& healthTelemetry) :
+	mHealthTelemetry(healthTelemetry),
 	mVideoIODevice(std::make_unique<DeckLinkSession>()),
-	mBridge(std::make_unique<OpenGLVideoIOBridge>(*mVideoIODevice, renderEngine, healthTelemetry))
+	mBridge(std::make_unique<OpenGLVideoIOBridge>(renderEngine))
 {
 }
 
@@ -35,7 +38,7 @@ bool VideoBackend::SelectPreferredFormats(const VideoFormatSelection& videoModes
 bool VideoBackend::ConfigureInput(const VideoFormat& inputVideoMode, std::string& error)
 {
 	return mVideoIODevice->ConfigureInput(
-		[this](const VideoIOFrame& frame) { mBridge->VideoFrameArrived(frame); },
+		[this](const VideoIOFrame& frame) { HandleInputFrame(frame); },
 		inputVideoMode,
 		error);
 }
@@ -43,7 +46,7 @@ bool VideoBackend::ConfigureInput(const VideoFormat& inputVideoMode, std::string
 bool VideoBackend::ConfigureOutput(const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error)
 {
 	return mVideoIODevice->ConfigureOutput(
-		[this](const VideoIOCompletion& completion) { mBridge->PlayoutFrameCompleted(completion); },
+		[this](const VideoIOCompletion& completion) { HandleOutputFrameCompletion(completion); },
 		outputVideoMode,
 		externalKeyingEnabled,
 		error);
@@ -173,3 +176,63 @@ void VideoBackend::SetStatusMessage(const std::string& message)
 {
 	mVideoIODevice->SetStatusMessage(message);
 }
+
+void VideoBackend::HandleInputFrame(const VideoIOFrame& frame)
+{
+	const VideoIOState& state = mVideoIODevice->State();
+	mHealthTelemetry.TryReportSignalStatus(!frame.hasNoInputSource, state.inputFrameSize.width, state.inputFrameSize.height, state.inputDisplayModeName);
+
+	if (mBridge)
+		mBridge->UploadInputFrame(frame, state);
+}
+
+void VideoBackend::HandleOutputFrameCompletion(const VideoIOCompletion& completion)
+{
+	RecordFramePacing(completion.result);
+
+	VideoIOOutputFrame outputFrame;
+	if (!BeginOutputFrame(outputFrame))
+		return;
+
+	const VideoIOState& state = mVideoIODevice->State();
+	if (mBridge)
+		mBridge->RenderScheduledFrame(state, completion, outputFrame);
+
+	EndOutputFrame(outputFrame);
+	AccountForCompletionResult(completion.result);
+
+	// Schedule the next frame after render work is complete so device-side
+	// bookkeeping stays with the backend seam and the bridge stays render-only.
+	ScheduleOutputFrame(outputFrame);
+}
+
+void VideoBackend::RecordFramePacing(VideoIOCompletionResult completionResult)
+{
+	const auto now = std::chrono::steady_clock::now();
+	if (mLastPlayoutCompletionTime != std::chrono::steady_clock::time_point())
+	{
+		mCompletionIntervalMilliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(now - mLastPlayoutCompletionTime).count();
+		if (mSmoothedCompletionIntervalMilliseconds <= 0.0)
+			mSmoothedCompletionIntervalMilliseconds = mCompletionIntervalMilliseconds;
+		else
+			mSmoothedCompletionIntervalMilliseconds = mSmoothedCompletionIntervalMilliseconds * 0.9 + mCompletionIntervalMilliseconds * 0.1;
+		if (mCompletionIntervalMilliseconds > mMaxCompletionIntervalMilliseconds)
+			mMaxCompletionIntervalMilliseconds = mCompletionIntervalMilliseconds;
+	}
+	mLastPlayoutCompletionTime = now;
+
+	if (completionResult == VideoIOCompletionResult::DisplayedLate)
+		++mLateFrameCount;
+	else if (completionResult == VideoIOCompletionResult::Dropped)
+		++mDroppedFrameCount;
+	else if (completionResult == VideoIOCompletionResult::Flushed)
+		++mFlushedFrameCount;
+
+	mHealthTelemetry.TryRecordFramePacingStats(
+		mCompletionIntervalMilliseconds,
+		mSmoothedCompletionIntervalMilliseconds,
+		mMaxCompletionIntervalMilliseconds,
+		mLateFrameCount,
+		mDroppedFrameCount,
+		mFlushedFrameCount);
+}