feat: tensorrt engine building progress text & safety

Author: f0e

.gitignore

@@ -22,6 +22,20 @@ out/
 
 # cmake
 compile_commands.json
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+CTestTestfile.cmake
+DartConfiguration.tcl
+*_include.cmake
+build.ninja
+.ninja_deps
+.ninja_log
+*.a
+
+# vcpkg
+vcpkg_installed/
+vcpkg-manifest-install.log
 
 # Keep .gitkeep files
 !.gitkeep

src/common/common_pch.h

@@ -23,6 +23,7 @@
 #include <ranges>
 #include <cfloat>
 #include <csignal>
+#include <deque>
 
 // libs
 #include <nlohmann/json.hpp>

src/common/rendering/render_pipeline.cpp

@@ -58,10 +58,15 @@ namespace {
 
 					if (progress_callback)
 						progress_callback();
-
-					line.clear();
+				}
+				else {
+					// not a frame update - e.g. a \r-terminated status line from a
+					// TensorRT engine build. surface it as a log line instead of
+					// silently gluing it onto whatever comes next.
+					state->report_log_line(line);
 				}
 
+				line.clear();
 				continue;
 			}
 
@@ -70,6 +75,8 @@ namespace {
 
 				DEBUG_LOG("[vspipe error] {}", line);
 
+				state->report_log_line(line);
+
 				line.clear();
 				continue;
 			}
@@ -80,6 +87,7 @@ namespace {
 		if (!line.empty()) {
 			vspipe_errors << line << '\n';
 			DEBUG_LOG("[vspipe error] {}", line);
+			state->report_log_line(line);
 		}
 	}
 
@@ -199,14 +207,22 @@ tl::expected<rendering::detail::PipelineResult, rendering::RenderError> renderin
 		std::thread ffmpeg_stderr_thread(pump_ffmpeg_stderr, std::ref(ffmpeg_stderr), std::ref(ffmpeg_errors));
 		std::thread ffmpeg_stdout_thread(extract_jpeg_stream, std::ref(ffmpeg_stdout), state);
 
+		// vspipe's tensorrt backend shells out to trtexec as a *grandchild* process
+		// (blur.py -> vsmlrt.py -> subprocess.run). a plain child.terminate() only
+		// kills vspipe itself, leaving trtexec running an engine build in the
+		// background after cancel. put vspipe in a process group (job object on
+		// windows) so terminating the group takes the whole tree down with it.
+		bp::group vspipe_group;
+
 		auto vspipe_process = u::run_command(
 			blur.vspipe_path,
 			commands.vspipe_video,
 			env,
 			bp::std_out > vspipe_stdout,
 			bp::std_err > vspipe_stderr,
-			bp::std_in < bp::null // stdin is an invalid handle otherwise, which breaks
-		                          // subprocess.run(stdout=sys.stderr) in rife-trt (FUN!)
+			bp::std_in < bp::null, // stdin is an invalid handle otherwise, which breaks
+		                           // subprocess.run(stdout=sys.stderr) in rife-trt (FUN!)
+			vspipe_group
 		);
 
 		auto ffmpeg_process =
@@ -226,7 +242,12 @@ tl::expected<rendering::detail::PipelineResult, rendering::RenderError> renderin
 		bool killed = false;
 		while (ffmpeg_process.running()) {
 			if (state->wants_stop()) {
-				vspipe_process.terminate();
+				// non-throwing: terminate() invalidates the group handle, and we
+				// terminate it again unconditionally below - a throwing call there
+				// on an already-invalid handle would escape as a generic error
+				// instead of a clean "stopped" result.
+				std::error_code ec;
+				vspipe_group.terminate(ec);
 				ffmpeg_process.terminate();
 				killed = true;
 				break;
@@ -240,8 +261,11 @@ tl::expected<rendering::detail::PipelineResult, rendering::RenderError> renderin
 			std::this_thread::sleep_for(std::chrono::milliseconds(50));
 		}
 
-		// stop stuff if they're stuck
-		vspipe_process.terminate();
+		// stop stuff if they're stuck (no-op if already terminated above)
+		{
+			std::error_code ec;
+			vspipe_group.terminate(ec);
+		}
 
 		// wait for threads to finish
 		if (ffmpeg_stdout_thread.joinable())

src/common/rendering/render_state.cpp

@@ -1,5 +1,26 @@
 #include "render_state.h"
 
+namespace {
+	constexpr size_t MAX_LOG_LINES = 6;
+
+	// printed by vsmlrt.py right before it shells out to trtexec/tensorrt_rtx
+	constexpr std::string_view ENGINE_BUILD_SENTINEL = "[blur] Building TensorRT engine";
+}
+
+void rendering::RenderState::report_log_line(const std::string& line) {
+	if (line.empty())
+		return;
+
+	std::lock_guard lock(m_mutex);
+
+	if (line.find(ENGINE_BUILD_SENTINEL) != std::string::npos)
+		m_progress.building_engine = true;
+
+	m_progress.recent_log_lines.push_back(line);
+	if (m_progress.recent_log_lines.size() > MAX_LOG_LINES)
+		m_progress.recent_log_lines.pop_front();
+}
+
 void rendering::RenderState::report_frame_progress(int current_frame, int total_frames) {
 	std::lock_guard lock(m_mutex);
 

src/common/rendering/render_state.h

@@ -18,6 +18,14 @@ namespace rendering {
 			float fps = 0.f;
 
 			std::string string;
+
+			// set once a one-time TensorRT engine build is detected happening in place
+			// of frame rendering (see RenderState::report_log_line)
+			bool building_engine = false;
+
+			// tail of raw vspipe/child-process stderr lines, shown to the user while
+			// there's no frame progress yet (e.g. during an engine build)
+			std::deque<std::string> recent_log_lines;
 		};
 
 		// -- control (called from the UI thread) --
@@ -71,6 +79,10 @@ namespace rendering {
 		// fold a vspipe "Frame: n/m" update into progress + the status string
 		void report_frame_progress(int current_frame, int total_frames);
 
+		// record a raw stderr line for display while there's no frame progress yet;
+		// also flips building_engine on when the known TensorRT build sentinel appears
+		void report_log_line(const std::string& line);
+
 		// -- preview frames (jpeg piped out of ffmpeg) --
 
 		void enable_preview_capture() {

src/gui/components/main.cpp

@@ -215,11 +215,37 @@ void main::render_progress(
 			ui::add_text(
 				"initialising render text",
 				container,
-				"Initialising render...",
+				progress.building_engine ? "Building TensorRT engine..." : "Initialising render...",
 				gfx::Color::white(),
 				fonts::dejavu,
 				FONT_CENTERED_X
 			);
+
+			if (progress.building_engine) {
+				ui::add_text(
+					"initialising render subtext",
+					container,
+					"this only happens once per settings, and may take a few minutes",
+					gfx::Color::white(renderer::MUTED_SHADE),
+					fonts::dejavu,
+					FONT_CENTERED_X
+				);
+			}
+
+			if (!progress.recent_log_lines.empty()) {
+				container.push_element_gap(6);
+
+				for (const auto [i, log_line] : u::enumerate(progress.recent_log_lines)) {
+					ui::add_text(
+						std::format("initialising render log line {}", i),
+						container,
+						u::truncate_with_ellipsis(log_line, 90),
+						gfx::Color::white(renderer::MUTED_SHADE),
+						fonts::dejavu,
+						FONT_CENTERED_X
+					);
+				}
+			}
 		}
 	}
 }

src/vapoursynth/blur/interpolate.py

@@ -5,13 +5,19 @@
 
 import json
 import math
+import sys
 from fractions import Fraction
 from typing import Any, Callable
 from pathlib import Path
 
 import blur.utils as u
 
-from external.vsmlrt import RIFE as VSMLRT_RIFE, BackendV2, RIFEModel
+# vsmlrt's plugin filters (trt/ort/ncnn/etc.) aren't available on macOS, and
+# importing it there raises "vsmlrt: cannot load any filters" at import time
+if sys.platform in ("win32", "linux"):
+    from external.vsmlrt import RIFE as VSMLRT_RIFE, BackendV2, RIFEModel
+else:
+    VSMLRT_RIFE = BackendV2 = RIFEModel = None
 
 LEGACY_PRESETS = ["weak", "film", "smooth", "animation"]
 NEW_PRESETS = ["default", "test"]
@@ -293,6 +299,11 @@ def prepare_rife_vsmlrt(
     device_index: int,
     override_format: str | None = None,
 ):
+    if VSMLRT_RIFE is None:
+        raise u.BlurException(
+            "RIFE (TensorRT) is only supported on Windows and Linux."
+        )
+
     pad_mult: int | None = None
     target_format = vs.RGBH