Move unspecific Emulator code out of System.cpp

rpcs3/Emu/system_utils.cpp

@@ -0,0 +1,240 @@
+#include "stdafx.h"
+#include "system_utils.hpp"
+#include "system_config.h"
+#include "util/sysinfo.hpp"
+#include "Utilities/File.h"
+#include "Utilities/StrUtil.h"
+#include "Utilities/Thread.h"
+#include "Crypto/unpkg.h"
+
+#include <charconv>
+#include <thread>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+LOG_CHANNEL(sys_log, "SYS");
+
+namespace rpcs3::utils
+{
+	u32 get_max_threads()
+	{
+		const u32 max_threads = static_cast<u32>(g_cfg.core.llvm_threads);
+		const u32 hw_threads = ::utils::get_thread_count();
+		const u32 thread_count = max_threads > 0 ? std::min(max_threads, hw_threads) : hw_threads;
+		return thread_count;
+	}
+
+	void configure_logs()
+	{
+		static bool was_silenced = false;
+
+		const bool silenced = g_cfg.misc.silence_all_logs.get();
+
+		if (silenced)
+		{
+			if (!was_silenced)
+			{
+				sys_log.notice("Disabling logging...");
+			}
+
+			logs::silence();
+		}
+		else
+		{
+			logs::reset();
+			logs::set_channel_levels(g_cfg.log.get_map());
+
+			if (was_silenced)
+			{
+				sys_log.notice("Logging enabled");
+			}
+		}
+
+		was_silenced = silenced;
+	}
+
+	u32 check_user(const std::string& user)
+	{
+		u32 id = 0;
+	
+		if (user.size() == 8)
+		{
+			std::from_chars(&user.front(), &user.back() + 1, id);
+		}
+	
+		return id;
+	}
+
+	bool install_pkg(const std::string& path)
+	{
+		sys_log.success("Installing package: %s", path);
+
+		atomic_t<double> progress(0.);
+		int int_progress = 0;
+
+		// Run PKG unpacking asynchronously
+		named_thread worker("PKG Installer", [&]
+		{
+			package_reader reader(path);
+			return reader.extract_data(progress);
+		});
+
+		// Wait for the completion
+		while (std::this_thread::sleep_for(5ms), worker <= thread_state::aborting)
+		{
+			// TODO: update unified progress dialog
+			double pval = progress;
+			pval < 0 ? pval += 1. : pval;
+			pval *= 100.;
+
+			if (static_cast<int>(pval) > int_progress)
+			{
+				int_progress = static_cast<int>(pval);
+				sys_log.success("... %u%%", int_progress);
+			}
+		}
+
+		return worker();
+	}
+
+#ifdef _WIN32
+	std::string get_exe_dir()
+	{
+		wchar_t buffer[32767];
+		GetModuleFileNameW(nullptr, buffer, sizeof(buffer) / 2);
+
+		const std::string path_to_exe = wchar_to_utf8(buffer);
+		const usz last = path_to_exe.find_last_of('\\');
+		return last == std::string::npos ? std::string("") : path_to_exe.substr(0, last + 1);
+	}
+#endif
+
+	std::string get_emu_dir()
+	{
+		const std::string& emu_dir_ = g_cfg.vfs.emulator_dir;
+		return emu_dir_.empty() ? fs::get_config_dir() : emu_dir_;
+	}
+
+	std::string get_hdd0_dir()
+	{
+		return g_cfg.vfs.get(g_cfg.vfs.dev_hdd0, get_emu_dir());
+	}
+
+	std::string get_hdd1_dir()
+	{
+		return g_cfg.vfs.get(g_cfg.vfs.dev_hdd1, get_emu_dir());
+	}
+
+	std::string get_cache_dir()
+	{
+		return fs::get_cache_dir() + "cache/";
+	}
+
+	std::string get_rap_file_path(const std::string& rap)
+	{
+		const std::string home_dir = get_hdd0_dir() + "/home";
+
+		for (auto&& entry : fs::dir(home_dir))
+		{
+			if (entry.is_directory && check_user(entry.name))
+			{
+				std::string rap_path = fmt::format("%s/%s/exdata/%s.rap", home_dir, entry.name, rap);
+				if (fs::is_file(rap_path))
+				{
+					return rap_path;
+				}
+			}
+		}
+
+		return {};
+	}
+
+	std::string get_sfo_dir_from_game_path(const std::string& game_path, const std::string& title_id)
+	{
+		if (fs::is_file(game_path + "/PS3_DISC.SFB"))
+		{
+			// This is a disc game.
+			if (!title_id.empty())
+			{
+				for (auto&& entry : fs::dir{game_path})
+				{
+					if (entry.name == "." || entry.name == "..")
+					{
+						continue;
+					}
+
+					const std::string sfo_path = game_path + "/" + entry.name + "/PARAM.SFO";
+
+					if (entry.is_directory && fs::is_file(sfo_path))
+					{
+						const auto psf = psf::load_object(fs::file(sfo_path));
+						const auto serial = psf::get_string(psf, "TITLE_ID");
+						if (serial == title_id)
+						{
+							return game_path + "/" + entry.name;
+						}
+					}
+				}
+			}
+
+			return game_path + "/PS3_GAME";
+		}
+
+		const auto psf = psf::load_object(fs::file(game_path + "/PARAM.SFO"));
+
+		const auto category = psf::get_string(psf, "CATEGORY");
+		const auto content_id = std::string(psf::get_string(psf, "CONTENT_ID"));
+
+		if (category == "HG" && !content_id.empty())
+		{
+			// This is a trial game. Check if the user has a RAP file to unlock it.
+			if (fs::is_file(game_path + "/C00/PARAM.SFO") && fs::is_file(get_rap_file_path(content_id)))
+			{
+				// Load full game data.
+				sys_log.notice("Found RAP file %s.rap for trial game %s", content_id, title_id);
+				return game_path + "/C00";
+			}
+		}
+
+		return game_path;
+	}
+
+	std::string get_custom_config_dir()
+	{
+#ifdef _WIN32
+		return fs::get_config_dir() + "config/custom_configs/";
+#else
+		return fs::get_config_dir() + "custom_configs/";
+#endif
+	}
+
+	std::string get_custom_config_path(const std::string& title_id, bool get_deprecated_path)
+	{
+		std::string path;
+
+		if (get_deprecated_path)
+			path = fs::get_config_dir() + "data/" + title_id + "/config.yml";
+		else
+			path = get_custom_config_dir() + "config_" + title_id + ".yml";
+
+		return path;
+	}
+
+	std::string get_custom_input_config_dir(const std::string& title_id)
+	{
+		// Notice: the extra folder for each title id may be removed at a later stage
+		// Warning: make sure to change any function that removes this directory as well
+#ifdef _WIN32
+		return fs::get_config_dir() + "config/custom_input_configs/" + title_id + "/";
+#else
+		return fs::get_config_dir() + "custom_input_configs/" + title_id + "/";
+#endif
+	}
+
+	std::string get_custom_input_config_path(const std::string& title_id)
+	{
+		return get_custom_input_config_dir(title_id) + "/config_input_" + title_id + ".yml";
+	}
+}