feat: improve config reading/writing

Author: f0e

src/common/config_app.cpp

@@ -71,8 +71,7 @@ std::string config_app::generate_config_string(const GlobalAppSettings& settings
 }
 
 void config_app::create(const std::filesystem::path& filepath, const GlobalAppSettings& settings) {
-	std::ofstream output(filepath);
-	output << generate_config_string(settings, false);
+	config_base::write_config_string(filepath, generate_config_string(settings, false));
 }
 
 std::string config_app::export_shareable(const GlobalAppSettings& settings) {
@@ -101,12 +100,9 @@ GlobalAppSettings config_app::parse(const std::string& config_content) {
 }
 
 GlobalAppSettings config_app::parse(const std::filesystem::path& config_filepath) {
-	std::ifstream file_stream(config_filepath);
-	auto config_map = config_base::read_config_map(file_stream);
+	auto settings = parse(config_base::read_config_file(config_filepath).value_or(""));
 
-	auto settings = parse_from_map(config_map);
-
-	// recreate the config file using the parsed values (keeps nice formatting)
+	// write formatted file
 	create(config_filepath, settings);
 
 	return settings;

src/common/config_base.h

@@ -60,6 +60,37 @@ namespace config_base {
 		}
 	}
 
+	inline std::mutex config_file_mutex;
+
+	inline std::optional<std::string> read_config_file(const std::filesystem::path& filepath) {
+		std::lock_guard lock(config_file_mutex);
+
+		std::ifstream file(filepath);
+		if (!file)
+			return {};
+
+		return std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+	}
+
+	inline bool write_config_string(const std::filesystem::path& filepath, const std::string& content) {
+		std::lock_guard lock(config_file_mutex);
+
+		// don't write if the content is the same
+		{
+			std::ifstream existing(filepath);
+			if (existing) {
+				std::string current((std::istreambuf_iterator<char>(existing)), std::istreambuf_iterator<char>());
+				if (current == content)
+					return false;
+			}
+		}
+
+		std::ofstream output(filepath);
+		output << content;
+
+		return true;
+	}
+
 	template<typename ConfigType>
 	ConfigType load_config(
 		const std::filesystem::path& config_path,

src/common/config_blur.cpp

@@ -181,8 +181,7 @@ std::string config_blur::generate_config_string(const BlurSettings& settings, bo
 }
 
 void config_blur::create(const std::filesystem::path& filepath, const BlurSettings& current_settings) {
-	std::ofstream output(filepath);
-	output << generate_config_string(current_settings, false);
+	config_base::write_config_string(filepath, generate_config_string(current_settings, false));
 }
 
 std::string config_blur::export_concise(const BlurSettings& settings) {
@@ -281,14 +280,15 @@ BlurSettings config_blur::parse(const std::string& config_content) {
 }
 
 BlurSettings config_blur::parse(const std::filesystem::path& config_filepath) {
-	std::ifstream file_stream(config_filepath);
-	auto config_map = config_base::read_config_map(file_stream);
-	return parse_from_map(config_map, config_filepath);
+	auto settings = parse(config_base::read_config_file(config_filepath).value_or(""));
+
+	// write formatted file
+	create(config_filepath, settings);
+
+	return settings;
 }
 
-BlurSettings config_blur::parse_from_map(
-	const std::map<std::string, std::string>& config_map, const std::optional<std::filesystem::path>& config_filepath
-) {
+BlurSettings config_blur::parse_from_map(const std::map<std::string, std::string>& config_map) {
 	BlurSettings settings;
 
 	config_base::extract_config_value(config_map, "blur", settings.blur);
@@ -383,11 +383,6 @@ BlurSettings config_blur::parse_from_map(
 	u::verify_gpu_encoding(settings);
 	u::set_fastest_devices(settings);
 
-	if (config_filepath) {
-		// rewrite config with proper structure and default values
-		create(*config_filepath, settings);
-	}
-
 	return settings;
 }
 

src/common/config_blur.h

@@ -152,10 +152,7 @@ namespace config_blur {
 
 	BlurSettings parse(const std::string& config_content);
 	BlurSettings parse(const std::filesystem::path& config_filepath);
-	BlurSettings parse_from_map(
-		const std::map<std::string, std::string>& config_map,
-		const std::optional<std::filesystem::path>& config_filepath = {}
-	);
+	BlurSettings parse_from_map(const std::map<std::string, std::string>& config_map);
 
 	BlurSettings parse_global_config();
 

src/common/config_presets.cpp

@@ -2,12 +2,6 @@
 #include "config_base.h"
 
 namespace {
-	constexpr auto CACHE_RELOAD_INTERVAL = std::chrono::seconds(5);
-
-	std::mutex cache_mutex;
-	PresetSettings cached_config;
-	std::optional<std::chrono::steady_clock::time_point> cache_time;
-
 	std::vector<std::string> get_ffmpeg_args(std::string params_str, int quality) {
 		// replace quality placeholder
 		params_str = u::replace_all(params_str, "{quality}", std::to_string(quality));
@@ -108,20 +102,17 @@ std::string config_presets::generate_config_string(const PresetSettings& setting
 }
 
 void config_presets::create(const std::filesystem::path& filepath, const PresetSettings& current_settings) {
-	std::ofstream output(filepath);
-	output << generate_config_string(current_settings);
+	config_base::write_config_string(filepath, generate_config_string(current_settings));
 }
 
 PresetSettings config_presets::parse(const std::filesystem::path& config_filepath) {
-	std::ifstream file(config_filepath);
-	if (!file)
+	auto content = config_base::read_config_file(config_filepath);
+	if (!content)
 		return DEFAULT_CONFIG; // defaults if file couldn't be opened
 
-	std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-
-	auto settings = parse(content);
+	auto settings = parse(*content);
 
-	// recreate the config file using the parsed values (keeps nice formatting)
+	// write formatted file
 	create(config_filepath, settings);
 
 	return settings;
@@ -210,33 +201,26 @@ std::filesystem::path config_presets::get_preset_config_path() {
 }
 
 PresetSettings config_presets::get_preset_config() {
-	std::lock_guard lock(cache_mutex);
-
-	auto now = std::chrono::steady_clock::now();
-	if (!cache_time || now - *cache_time >= CACHE_RELOAD_INTERVAL) {
-		cached_config = config_base::load_config<PresetSettings>(get_preset_config_path(), create, parse);
-		cache_time = now;
-	}
-
-	return cached_config;
+	return config_base::load_config<PresetSettings>(get_preset_config_path(), create, parse);
 }
 
 void config_presets::save(const PresetSettings& settings) {
 	create(get_preset_config_path(), settings);
-
-	std::lock_guard lock(cache_mutex);
-	cached_config = settings;
-	cache_time = std::chrono::steady_clock::now();
 }
 
 std::vector<config_presets::PresetDetails> config_presets::get_available_presets(
 	bool gpu_encoding, const std::string& gpu_type
+) {
+	return get_available_presets(get_preset_config(), gpu_encoding, gpu_type);
+}
+
+std::vector<config_presets::PresetDetails> config_presets::get_available_presets(
+	const PresetSettings& config, bool gpu_encoding, const std::string& gpu_type
 ) {
 	std::vector<PresetDetails> available_presets;
 
 	std::string type_to_check = gpu_encoding ? gpu_type : "cpu";
 
-	PresetSettings config = get_preset_config();
 	const auto* preset_group = config.find_preset_group(type_to_check);
 
 	if (preset_group) {

src/common/config_presets.h

@@ -126,8 +126,6 @@ namespace config_presets {
 
 	PresetSettings get_preset_config();
 
-	// writes the presets to disk and refreshes the cache get_preset_config reads from, so renders started right
-	// after saving use the new presets
 	void save(const PresetSettings& settings);
 
 	struct PresetDetails {
@@ -136,6 +134,9 @@ namespace config_presets {
 	};
 
 	std::vector<PresetDetails> get_available_presets(bool gpu_encoding, const std::string& gpu_type);
+	std::vector<PresetDetails> get_available_presets(
+		const PresetSettings& config, bool gpu_encoding, const std::string& gpu_type
+	);
 
 	std::vector<std::string> get_preset_params(const std::string& gpu_type, const std::string& preset, int quality);
 	std::vector<std::string> get_preset_params(

src/common/utils.cpp

@@ -609,10 +609,16 @@ std::set<std::string> u::get_available_codecs(const std::set<std::string>& codec
 }
 
 std::vector<std::string> u::get_supported_presets(bool gpu_encoding, const std::string& gpu_type) {
+	return get_supported_presets(config_presets::get_preset_config(), gpu_encoding, gpu_type);
+}
+
+std::vector<std::string> u::get_supported_presets(
+	const PresetSettings& presets, bool gpu_encoding, const std::string& gpu_type
+) {
 	if (!init_hw)
 		get_hardware_encoding_devices();
 
-	auto available_presets = config_presets::get_available_presets(gpu_encoding, gpu_type);
+	auto available_presets = config_presets::get_available_presets(presets, gpu_encoding, gpu_type);
 
 	std::set<std::string> all_codecs;
 	for (const auto& preset : available_presets) {

src/common/utils.h

@@ -503,6 +503,9 @@ namespace u {
 	std::set<std::string> get_available_codecs(const std::set<std::string>& codecs);
 
 	std::vector<std::string> get_supported_presets(bool gpu_encoding, const std::string& gpu_type);
+	std::vector<std::string> get_supported_presets(
+		const PresetSettings& presets, bool gpu_encoding, const std::string& gpu_type
+	);
 
 	std::vector<std::string> ffmpeg_string_to_args(const std::string& str);
 

src/gui/components/configs/options.cpp

@@ -274,7 +274,7 @@ void configs::options(ui::Container& container) {
 	*/
 	section_component("rendering");
 
-	auto presets = u::get_supported_presets(settings.gpu_encoding, app_settings.gpu_type);
+	auto presets = u::get_supported_presets(preset_settings, settings.gpu_encoding, app_settings.gpu_type);
 
 	if (!presets.empty() && !u::contains(presets, settings.encode_preset)) {
 		settings.encode_preset = presets[0];
@@ -304,6 +304,7 @@ void configs::options(ui::Container& container) {
 
 	if (settings.advanced.ffmpeg_override.empty()) {
 		std::vector<std::string> preset_args = config_presets::get_preset_params(
+			preset_settings,
 			settings.gpu_encoding ? app_settings.gpu_type : "cpu",
 			u::to_lower(settings.encode_preset.empty() ? "h264" : settings.encode_preset),
 			settings.quality

src/gui/sdl.cpp

@@ -3,6 +3,7 @@
 #include "render/render.h"
 #include "os/desktop_notification.h"
 #include "os/window.h"
+#include "ui/ui.h"
 #include "renderer.h"
 #include "gui.h"
 
@@ -35,7 +36,18 @@ namespace {
 		SDL_SetWindowSize(window, new_w, new_h);
 	}
 
+	// returns true if something that's already on screen needs redrawing
 	bool apply_app_config(const GlobalAppSettings& config) {
+		bool highlight_color_changed = false;
+
+#ifdef BLUR_COLOR_THEMES
+		auto parsed_highlight_color = gfx::Color::from_hex_string(config.gui_color_hex, false);
+		auto highlight_color = parsed_highlight_color.value_or(ui::DEFAULT_HIGHLIGHT_COLOR);
+
+		highlight_color_changed = highlight_color != ui::highlight_color;
+		ui::highlight_color = highlight_color;
+#endif
+
 		float previous_scale = render::dpi_scale_override;
 		float previous_content_scale = sdl::window ? render::get_content_scale(sdl::window) : 1.f;
 
@@ -65,7 +77,7 @@ namespace {
 			}
 		}
 
-		return scale_changed;
+		return scale_changed || highlight_color_changed;
 	}
 }
 
@@ -274,9 +286,9 @@ bool sdl::poll_config_reload() {
 		return false; // unchanged since we last looked
 
 	auto config = config_app::get_app_config();
-	bool scale_changed = apply_app_config(config);
-	remember_config_write_time(); // note: store modified time after get_app_config since it itself edits the file
+	bool needs_redraw = apply_app_config(config);
+	remember_config_write_time(); // note: store modified time after get_app_config, since parsing can rewrite the file
 
 	// only force a redraw if something visible actually changed
-	return scale_changed;
+	return needs_redraw;
 }