feat: rife tensorrt via vs-mlrt

Author: f0e

src/common/blur.cpp

@@ -107,7 +107,7 @@ tl::expected<void, std::string> Blur::initialise(bool _verbose, bool _using_prev
 	initialised = true;
 
 	std::thread([this] {
-		initialise_rife_gpus();
+		initialise_device_lists();
 	}).detach();
 
 	return {};
@@ -198,20 +198,31 @@ void Blur::update(
 	updates::update_to_tag(tag, progress_callback);
 }
 
-void Blur::initialise_rife_gpus() {
-	rife_gpus = u::get_rife_gpus();
+void Blur::initialise_device_lists() {
+	rife_devices = u::get_devices("rife");
+	tensorrt_devices = u::get_devices("tensorrt");
 
 	std::ranges::copy(
 		std::ranges::transform_view(
-			rife_gpus,
+			rife_devices,
 			[](const auto& pair) {
 				return pair.second;
 			}
 		),
-		std::back_inserter(rife_gpu_names)
+		std::back_inserter(rife_device_names)
 	);
 
-	initialised_rife_gpus = true;
+	std::ranges::copy(
+		std::ranges::transform_view(
+			tensorrt_devices,
+			[](const auto& pair) {
+				return pair.second;
+			}
+		),
+		std::back_inserter(tensorrt_device_names)
+	);
+
+	initialised_devices = true;
 }
 
 void cleanup_handler(int signal) {

src/common/blur.h

@@ -41,12 +41,15 @@ class Blur { // todo: switch all the classes which could be namespaces into name
 		const std::optional<std::function<void(const std::string& text, bool done)>>& progress_callback = {}
 	);
 
-	std::map<int, std::string> rife_gpus;
-	std::vector<std::string> rife_gpu_names;
-	bool initialised_rife_gpus = false;
+	// TODO: this stuff probably shouldn't be here
+	std::map<int, std::string> rife_devices;
+	std::vector<std::string> rife_device_names;
 
-	void initialise_rife_gpus();
-	void pick_fastest_rife_gpu(BlurSettings& settings);
+	std::map<int, std::string> tensorrt_devices;
+	std::vector<std::string> tensorrt_device_names;
+	bool initialised_devices = false;
+
+	void initialise_device_lists();
 
 	void setup_signal_handlers();
 };

src/common/config_app.cpp

@@ -10,7 +10,8 @@ void config_app::create(const std::filesystem::path& filepath, const GlobalAppSe
 	output << "- pc-specific blur settings" << "\n";
 	output << "output prefix: " << settings.output_prefix << "\n";
 	output << "gpu type (nvidia/amd/intel): " << settings.gpu_type << "\n";
-	output << "rife gpu number: " << settings.rife_gpu_index << "\n";
+	output << "rife gpu number: " << settings.rife_device_index << "\n";
+	output << "rife (tensorrt) gpu number: " << settings.tensorrt_device_index << "\n";
 
 	output << "\n";
 	output << "- gui" << "\n";
@@ -51,7 +52,8 @@ GlobalAppSettings config_app::parse(const std::filesystem::path& config_filepath
 
 	config_base::extract_config_value(config_map, "output prefix", settings.output_prefix);
 	config_base::extract_config_value(config_map, "gpu type (nvidia/amd/intel)", settings.gpu_type);
-	config_base::extract_config_value(config_map, "rife gpu number", settings.rife_gpu_index);
+	config_base::extract_config_value(config_map, "rife gpu number", settings.rife_device_index);
+	config_base::extract_config_value(config_map, "rife (tensorrt) gpu number", settings.tensorrt_device_index);
 
 	config_base::extract_config_value(config_map, "window width", settings.gui_width);
 	config_base::extract_config_value(config_map, "window height", settings.gui_height);
@@ -95,7 +97,8 @@ tl::expected<nlohmann::json, std::string> GlobalAppSettings::to_json() const {
 	nlohmann::json j;
 
 	j["gpu_type"] = this->gpu_type;
-	j["rife_gpu_index"] = this->rife_gpu_index;
+	j["rife_device_index"] = this->rife_device_index;
+	j["tensorrt_device_index"] = this->tensorrt_device_index;
 
 	return j;
 }

src/common/config_app.h

@@ -4,7 +4,8 @@ struct GlobalAppSettings {
 	std::string output_prefix;
 
 	std::string gpu_type;
-	int rife_gpu_index = -1;
+	int rife_device_index = -1;
+	int tensorrt_device_index = -1;
 
 	int gui_width = 591;
 	int gui_height = 381;

src/common/config_blur.cpp

@@ -37,6 +37,7 @@ std::string config_blur::generate_config_string(const BlurSettings& settings, bo
 		output << "pre-interpolate: " << (settings.pre_interpolate ? "true" : "false") << "\n";
 		if (!concise || settings.pre_interpolate) {
 			output << "pre-interpolated fps: " << settings.pre_interpolated_fps << "\n";
+			output << "pre-interpolation method: " << settings.pre_interpolation_method << "\n";
 		}
 	}
 
@@ -142,6 +143,7 @@ std::string config_blur::generate_config_string(const BlurSettings& settings, bo
 			output << "interpolation block size: " << settings.advanced.interpolation_blocksize << "\n";
 			output << "interpolation mask area: " << settings.advanced.interpolation_mask_area << "\n";
 			output << "rife model: " << settings.advanced.rife_model << "\n";
+			output << "rife (tensorrt) model: " << settings.advanced.rife_trt_model << "\n";
 
 			if (!concise || settings.advanced.manual_svp) {
 				output << "\n";
@@ -241,6 +243,7 @@ BlurSettings config_blur::parse_from_map(
 
 	config_base::extract_config_value(config_map, "pre-interpolate", settings.pre_interpolate);
 	config_base::extract_config_value(config_map, "pre-interpolated fps", settings.pre_interpolated_fps);
+	config_base::extract_config_value(config_map, "pre-interpolation method", settings.pre_interpolation_method);
 
 	config_base::extract_config_value(config_map, "deduplicate", settings.deduplicate);
 	config_base::extract_config_value(config_map, "deduplicate method", settings.deduplicate_method);
@@ -308,14 +311,15 @@ BlurSettings config_blur::parse_from_map(
 			config_map, "interpolation mask area", settings.advanced.interpolation_mask_area
 		);
 		config_base::extract_config_value(config_map, "rife model", settings.advanced.rife_model);
+		config_base::extract_config_value(config_map, "rife (tensorrt) model", settings.advanced.rife_trt_model);
 		config_base::extract_config_value(config_map, "manual svp", settings.advanced.manual_svp);
 		config_base::extract_config_value(config_map, "super string", settings.advanced.super_string);
 		config_base::extract_config_value(config_map, "vectors string", settings.advanced.vectors_string);
 		config_base::extract_config_value(config_map, "smooth string", settings.advanced.smooth_string);
 	}
 
 	u::verify_gpu_encoding(settings);
-	u::set_fastest_rife_gpu(settings);
+	u::set_fastest_devices(settings);
 
 	if (config_filepath) {
 		// rewrite config with proper structure and default values
@@ -388,6 +392,7 @@ tl::expected<nlohmann::json, std::string> BlurSettings::to_json() const {
 
 	j["pre_interpolate"] = this->pre_interpolate;
 	j["pre_interpolated_fps"] = this->pre_interpolated_fps;
+	j["pre_interpolation_method"] = this->pre_interpolation_method;
 
 	j["deduplicate"] = this->deduplicate;
 	j["deduplicate_method"] = this->deduplicate_method;
@@ -445,6 +450,8 @@ tl::expected<nlohmann::json, std::string> BlurSettings::to_json() const {
 
 	j["rife_model"] = *rife_model_path;
 
+	j["rife_trt_model"] = this->advanced.rife_trt_model;
+
 	j["manual_svp"] = this->advanced.manual_svp;
 	j["super_string"] = this->advanced.super_string;
 	j["vectors_string"] = this->advanced.vectors_string;

src/common/config_blur.h

@@ -19,6 +19,7 @@ struct AdvancedSettings {
 	std::string interpolation_blocksize = "8";
 	int interpolation_mask_area = 0;
 	std::string rife_model = "rife-v4.26_ensembleFalse";
+	std::string rife_trt_model = "4.26";
 
 	bool manual_svp = false;
 	std::string super_string;
@@ -46,6 +47,7 @@ struct BlurSettings {
 
 	bool pre_interpolate = false;
 	std::string pre_interpolated_fps = "360";
+	std::string pre_interpolation_method = "rife";
 
 	bool timescale = false;
 	float input_timescale = 1.f;

src/common/rendering.cpp

@@ -261,7 +261,13 @@ tl::expected<rendering::detail::PipelineResult, rendering::RenderError> renderin
 		});
 
 		auto vspipe_process = u::run_command(
-			blur.vspipe_path, commands.vspipe_video, env, bp::std_out > vspipe_stdout, bp::std_err > vspipe_stderr
+			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!)
 		);
 
 		auto ffmpeg_process = u::run_command(