video-shader-toys/apps/RenderCadenceCompositor/app/RenderCadenceApp.h

#pragma once

#include "AppConfig.h"
#include "../logging/Logger.h"
#include "../runtime/RuntimeShaderBridge.h"
#include "../telemetry/TelemetryPrinter.h"
#include "../video/DeckLinkOutput.h"
#include "../video/DeckLinkOutputThread.h"

#include <chrono>
#include <string>
#include <thread>
#include <type_traits>

namespace RenderCadenceCompositor
{
namespace detail
{
template <typename RenderThread>
auto StartRenderThread(RenderThread& renderThread, std::string& error, int) -> decltype(renderThread.Start(error), bool())
{
	return renderThread.Start(error);
}

template <typename RenderThread>
bool StartRenderThreadWithoutError(RenderThread& renderThread, std::true_type)
{
	return renderThread.Start();
}

template <typename RenderThread>
bool StartRenderThreadWithoutError(RenderThread& renderThread, std::false_type)
{
	renderThread.Start();
	return true;
}

template <typename RenderThread>
auto StartRenderThread(RenderThread& renderThread, std::string&, long) -> decltype(renderThread.Start(), bool())
{
	return StartRenderThreadWithoutError(renderThread, std::is_same<decltype(renderThread.Start()), bool>());
}
}

template <typename RenderThread, typename SystemFrameExchange>
class RenderCadenceApp
{
public:
	RenderCadenceApp(RenderThread& renderThread, SystemFrameExchange& frameExchange, AppConfig config = DefaultAppConfig()) :
		mRenderThread(renderThread),
		mFrameExchange(frameExchange),
		mConfig(config),
		mOutputThread(mOutput, mFrameExchange, mConfig.outputThread),
		mTelemetry(mConfig.telemetry)
	{
	}

	RenderCadenceApp(const RenderCadenceApp&) = delete;
	RenderCadenceApp& operator=(const RenderCadenceApp&) = delete;

	~RenderCadenceApp()
	{
		Stop();
	}

	bool Start(std::string& error)
	{
		Log("app", "Initializing DeckLink output.");
		if (!mOutput.Initialize(
			mConfig.deckLink,
			[this](const VideoIOCompletion& completion) {
				mFrameExchange.ReleaseScheduledByBytes(completion.outputFrameBuffer);
			},
			error))
		{
			LogError("app", "DeckLink output initialization failed: " + error);
			return false;
		}

		Log("app", "Starting render thread.");
		if (!detail::StartRenderThread(mRenderThread, error, 0))
		{
			LogError("app", "Render thread start failed: " + error);
			Stop();
			return false;
		}
		StartRuntimeShaderBuild();

		Log("app", "Waiting for rendered warmup frames.");
		if (!mFrameExchange.WaitForCompletedDepth(mConfig.warmupCompletedFrames, mConfig.warmupTimeout))
		{
			error = "Timed out waiting for rendered warmup frames.";
			LogError("app", error);
			Stop();
			return false;
		}

		Log("app", "Starting DeckLink output thread.");
		if (!mOutputThread.Start())
		{
			error = "DeckLink output thread failed to start.";
			LogError("app", error);
			Stop();
			return false;
		}

		Log("app", "Waiting for DeckLink preroll frames.");
		if (!WaitForPreroll())
		{
			error = "Timed out waiting for DeckLink preroll frames.";
			LogError("app", error);
			Stop();
			return false;
		}

		Log("app", "Starting DeckLink scheduled playback.");
		if (!mOutput.StartScheduledPlayback(error))
		{
			LogError("app", "DeckLink scheduled playback failed: " + error);
			Stop();
			return false;
		}

		mTelemetry.Start(mFrameExchange, mOutput, mOutputThread, mRenderThread);
		Log("app", "RenderCadenceCompositor started.");
		mStarted = true;
		return true;
	}

	void Stop()
	{
		mTelemetry.Stop();
		mOutputThread.Stop();
		mOutput.Stop();
		StopRuntimeShaderBuild();
		mRenderThread.Stop();
		mOutput.ReleaseResources();
		if (mStarted)
			Log("app", "RenderCadenceCompositor shutdown complete.");
		mStarted = false;
	}

	bool Started() const { return mStarted; }
	const DeckLinkOutput& Output() const { return mOutput; }

private:
	bool WaitForPreroll() const
	{
		const auto deadline = std::chrono::steady_clock::now() + mConfig.prerollTimeout;
		while (std::chrono::steady_clock::now() < deadline)
		{
			if (mFrameExchange.Metrics().scheduledCount >= mConfig.outputThread.targetBufferedFrames)
				return true;
			std::this_thread::sleep_for(mConfig.prerollPoll);
		}
		return false;
	}

	void StartRuntimeShaderBuild()
	{
		if (mConfig.runtimeShaderId.empty())
		{
			Log("runtime-shader", "Runtime shader build disabled.");
			return;
		}

		Log("runtime-shader", "Starting background Slang build for shader '" + mConfig.runtimeShaderId + "'.");
		mShaderBridge.Start(
			mConfig.runtimeShaderId,
			[this](const RuntimeShaderArtifact& artifact) {
				mRenderThread.SubmitRuntimeShaderArtifact(artifact);
			},
			[](const std::string& message) {
				LogError("runtime-shader", "Runtime Slang build failed: " + message);
			});
	}

	void StopRuntimeShaderBuild()
	{
		mShaderBridge.Stop();
	}

	RenderThread& mRenderThread;
	SystemFrameExchange& mFrameExchange;
	AppConfig mConfig;
	DeckLinkOutput mOutput;
	DeckLinkOutputThread<SystemFrameExchange> mOutputThread;
	TelemetryPrinter mTelemetry;
	RuntimeShaderBridge mShaderBridge;
	bool mStarted = false;
};
}