overlays: Fix iso media path loading

Author: Megamouse

rpcs3/Emu/CMakeLists.txt

@@ -522,6 +522,7 @@ target_sources(rpcs3_emu PRIVATE
     RSX/Overlays/BigPicture/overlay_big_picture.cpp
     RSX/Overlays/BigPicture/overlay_big_picture_game_details.cpp
     RSX/Overlays/BigPicture/overlay_big_picture_game_grid.cpp
+    RSX/Overlays/BigPicture/overlay_big_picture_game_info.cpp
     RSX/Overlays/BigPicture/overlay_big_picture_main_menu.cpp
     RSX/Overlays/Network/overlay_recvmessage_dialog.cpp
     RSX/Overlays/Network/overlay_sendmessage_dialog.cpp

rpcs3/Emu/RSX/Overlays/BigPicture/overlay_big_picture_game_details.cpp

@@ -44,16 +44,16 @@ namespace rsx
 			m_back_hint.set_pos(x + 40 + 120 + 20, y + height - 80);
 		}
 
-		void big_picture_game_details::show(const GameInfo& info, const image_info* icon_data)
+		void big_picture_game_details::show(const big_picture_game_info& info, const image_info* icon_data)
 		{
 			m_title.set_text(info.name.empty() ? info.serial : info.name);
 			m_title.auto_resize(false, m_w - 80);
 
 			m_info_text.set_text(fmt::format("%s\n%s\n%s", info.serial, info.category, info.app_ver));
 
-			if (const std::string pic1_path = rpcs3::utils::get_game_content_path(game_content_type::background_picture, info); !pic1_path.empty())
+			if (const auto res = rpcs3::utils::get_game_content_path(game_content_type::background_picture, info); !res.first.empty())
 			{
-				m_pic_data = std::make_unique<image_info>(pic1_path);
+				m_pic_data = info.load_icon(res.first, res.second);
 				// The renderer's texture cache is keyed by this object's address, which can be reused by an
 				// unrelated image after the old one is freed - force a re-upload instead of trusting the cache.
 				m_pic_data->dirty = true;
@@ -71,7 +71,7 @@ namespace rsx
 
 			if (!info.movie_path.empty())
 			{
-				m_video = std::make_unique<video_view>(info.movie_path, info.audio_path, info.icon_path);
+				m_video = std::make_unique<video_view>(info);
 				m_video->set_pos(m_icon.x, m_icon.y);
 				m_video->set_size(m_icon.w, m_icon.h);
 				m_video->set_active(true);

rpcs3/Emu/RSX/Overlays/BigPicture/overlay_big_picture_game_details.h

@@ -3,7 +3,7 @@
 #include "Emu/RSX/Overlays/overlays.h"
 #include "Emu/RSX/Overlays/overlay_controls.h"
 #include "Emu/RSX/Overlays/overlay_video.h"
-#include "Emu/GameInfo.h"
+#include "overlay_big_picture_game_info.h"
 
 namespace rsx
 {
@@ -22,7 +22,7 @@ namespace rsx
 				start
 			};
 
-			void show(const GameInfo& info, const image_info* icon_data);
+			void show(const big_picture_game_info& info, const image_info* icon_data);
 			void hide();
 			bool is_visible() const { return m_visible; }
 

rpcs3/Emu/RSX/Overlays/BigPicture/overlay_big_picture_game_grid.cpp

@@ -1,7 +1,6 @@
 #include "stdafx.h"
 #include "overlay_big_picture_game_grid.h"
 #include "overlay_big_picture_game_details.h"
-#include "Emu/System.h"
 #include "Emu/system_config.h"
 #include "Utilities/Thread.h"
 
@@ -11,7 +10,7 @@ namespace rsx
 {
 	namespace overlays
 	{
-		big_picture_game_tile::big_picture_game_tile(const big_picture_game_entry& entry, u16 tile_width)
+		big_picture_game_tile::big_picture_game_tile(const big_picture_game_info& entry, u16 tile_width)
 		{
 			pack_padding = 8;
 			back_color.a = 0.f;
@@ -22,9 +21,9 @@ namespace rsx
 			icon->set_size(tile_width, icon_h);
 			icon->back_color = color4f(1.f, 1.f, 1.f, 0.08f);
 
-			if (fs::exists(entry.icon_path))
+			if (auto icon_data = entry.load_icon())
 			{
-				m_icon_data = std::make_unique<image_info>(entry.icon_path);
+				m_icon_data = std::move(icon_data);
 				// The renderer's texture cache is keyed by this object's address, which can be reused by an
 				// unrelated image after the old one is freed - force a re-upload instead of trusting the cache.
 				m_icon_data->dirty = true;
@@ -119,7 +118,7 @@ namespace rsx
 				m_game_enumeration.remove_duplicates();
 
 				// Parse entries (multithreaded)
-				const std::vector<game_enumeration<big_picture_game_entry>::path_entry>& entries = m_game_enumeration.path_entries();
+				const std::vector<game_enumeration<big_picture_game_info>::path_entry>& entries = m_game_enumeration.path_entries();
 				usz thread_count = std::min<usz>(utils::get_thread_count(), entries.size());
 				map_workload("BPM Parser "sv, thread_count, entries.size(), [this, &entries](usz index)
 				{
@@ -131,7 +130,7 @@ namespace rsx
 				m_game_enumeration.apply_patches();
 
 				// Get final enumerated games
-				for (big_picture_game_entry& game : m_game_enumeration.take_games())
+				for (big_picture_game_info& game : m_game_enumeration.take_games())
 				{
 					if (!game.bootable) continue; // Let's restrict this to bootable entries
 
@@ -142,7 +141,7 @@ namespace rsx
 				m_game_enumeration.clear(true);
 
 				// Sort by name
-				std::sort(m_games.begin(), m_games.end(), [](const big_picture_game_entry& a, const big_picture_game_entry& b)
+				std::sort(m_games.begin(), m_games.end(), [](const big_picture_game_info& a, const big_picture_game_info& b)
 				{
 					return a.name < b.name;
 				});
@@ -288,7 +287,7 @@ namespace rsx
 				case big_picture_game_details::result::start:
 				{
 					rsx_log.notice("Big Picture Mode: Start pressed for index=%d", m_selected_index);
-					const big_picture_game_entry& info = m_games[m_selected_index];
+					const big_picture_game_info& info = m_games[m_selected_index];
 					rsx_log.notice("Big Picture Mode: selected game path='%s' serial='%s'", info.path, info.serial);
 					m_details->hide();
 					if (m_on_game_selected)

rpcs3/Emu/RSX/Overlays/BigPicture/overlay_big_picture_game_grid.h

@@ -2,7 +2,7 @@
 
 #include "Emu/RSX/Overlays/HomeMenu/overlay_home_menu_page.h"
 #include "Emu/game_enumeration.h"
-#include "Emu/GameInfo.h"
+#include "overlay_big_picture_game_info.h"
 
 #include <functional>
 
@@ -12,14 +12,10 @@ namespace rsx
 	{
 		struct big_picture_game_details;
 
-		struct big_picture_game_entry : public GameInfo
-		{
-		};
-
 		// A single selectable tile (icon + title) inside the game grid.
 		struct big_picture_game_tile : public vertical_layout
 		{
-			big_picture_game_tile(const big_picture_game_entry& entry, u16 tile_width);
+			big_picture_game_tile(const big_picture_game_info& entry, u16 tile_width);
 
 			// PS3 ICON0.PNG is always 320x176 - keep tiles at that exact aspect ratio instead of stretching it.
 			static constexpr u16 icon_height(u16 tile_width) { return static_cast<u16>(tile_width * 176 / 320); }
@@ -56,8 +52,8 @@ namespace rsx
 			std::mutex m_reload_mutex;
 			std::unique_ptr<named_thread<std::function<void()>>> m_game_enumeration_thread;
 
-			game_enumeration<big_picture_game_entry> m_game_enumeration;
-			std::vector<big_picture_game_entry> m_games;
+			game_enumeration<big_picture_game_info> m_game_enumeration;
+			std::vector<big_picture_game_info> m_games;
 			std::vector<big_picture_game_tile*> m_tiles; // non-owning, owned by m_grid
 			std::unique_ptr<vertical_layout> m_grid;
 			std::unique_ptr<label> m_placeholder_text;

rpcs3/Emu/RSX/Overlays/BigPicture/overlay_big_picture_game_info.cpp

@@ -0,0 +1,19 @@
+#include "stdafx.h"
+#include "overlay_big_picture_game_info.h"
+#include "Emu/RSX/Overlays/overlay_controls.h"
+
+namespace rsx
+{
+	namespace overlays
+	{
+		std::unique_ptr<image_info> big_picture_game_info::load_icon(const std::string& icon_path, bool in_archive) const
+		{
+			return image_info::load_icon(icon_path, in_archive ? path : "");
+		}
+
+		std::unique_ptr<image_info> big_picture_game_info::load_icon() const
+		{
+			return image_info::load_icon(icon_path, icon_in_archive ? path : "");
+		}
+	}
+}

rpcs3/Emu/RSX/Overlays/BigPicture/overlay_big_picture_game_info.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Emu/GameInfo.h"
+
+namespace rsx
+{
+	namespace overlays
+	{
+		struct image_info;
+
+		struct big_picture_game_info : public GameInfo
+		{
+			std::unique_ptr<image_info> load_icon(const std::string& icon_path, bool in_archive) const;
+			std::unique_ptr<image_info> load_icon() const;
+		};
+}
+}

rpcs3/Emu/RSX/Overlays/overlay_audio.cpp

@@ -6,17 +6,22 @@ namespace rsx
 {
 	namespace overlays
 	{
-		audio_player::audio_player(const std::string& audio_path)
+		audio_player::audio_player(const std::string& audio_path, bool audio_in_archive, const std::string& iso_path)
 		{
-			init_audio(audio_path);
+			init_audio(audio_path, audio_in_archive, iso_path);
 		}
 
-		void audio_player::init_audio(const std::string& audio_path)
+		void audio_player::init_audio(const std::string& audio_path, bool audio_in_archive, const std::string& iso_path)
 		{
 			if (audio_path.empty()) return;
 
 			m_video_source = ensure(Emu.GetCallbacks().make_video_source());
-			m_video_source->set_audio_path(audio_path);
+			m_video_source->set_audio_path(audio_path, audio_in_archive);
+
+			if (audio_in_archive)
+			{
+				m_video_source->set_iso_path(iso_path);
+			}
 		}
 
 		void audio_player::set_active(bool active)

rpcs3/Emu/RSX/Overlays/overlay_audio.h

@@ -9,13 +9,13 @@ namespace rsx
 		class audio_player
 		{
 		public:
-			audio_player(const std::string& audio_path);
+			audio_player(const std::string& audio_path, bool audio_in_archive, const std::string& iso_path);
 			~audio_player() = default;
 
 			void set_active(bool active);
 
 		private:
-			void init_audio(const std::string& audio_path);
+			void init_audio(const std::string& audio_path, bool audio_in_archive, const std::string& iso_path);
 
 			std::unique_ptr<video_source> m_video_source;
 		};

rpcs3/Emu/RSX/Overlays/overlay_controls.cpp

@@ -6,6 +6,7 @@
 #include "Utilities/geometry.h"
 #include "Utilities/File.h"
 #include "Emu/Cell/timers.hpp"
+#include "Loader/ISO.h"
 
 #include <numbers>
 
@@ -143,6 +144,34 @@ namespace rsx
 			}
 		}
 
+		std::unique_ptr<image_info> image_info::load_icon(const std::string& icon_path, const std::string& archive_path)
+		{
+			if (icon_path.empty()) return nullptr;
+
+			if (archive_path.empty())
+			{
+				if (!fs::exists(icon_path)) return nullptr;
+				return std::make_unique<image_info>(icon_path);
+			}
+
+			const bool is_archive = is_iso_file(archive_path);
+			if (!is_archive) return nullptr;
+
+			iso_archive archive(archive_path);
+			if (!archive.exists(icon_path)) return nullptr;
+
+			auto icon_file = archive.open(icon_path);
+			if (!icon_file) return nullptr;
+
+			const auto icon_size = icon_file->size();
+			if (icon_size == 0) return nullptr;
+
+			std::vector<u8> data(icon_size);
+			icon_file->read(data.data(), icon_size);
+
+			return std::make_unique<image_info>(data);
+		}
+
 		resource_config::resource_config()
 		{
 		}