Parallel card/hosts, attempt 1

Author: RedPanda4552

pcsx2/SIO/Memcard/Memcard.cpp

@@ -7,6 +7,7 @@
 #include "SIO/Memcard/MemcardPS2.h"
 #include "SIO/Memcard/MemcardPS1.h"
 #include "SIO/Memcard/MemcardNotConnected.h"
+#include "SIO/Memcard/MemcardHostBase.h"
 #include "SIO/Memcard/MemcardHostFile.h"
 #include "SIO/Memcard/MemcardHostFolder.h"
 
@@ -17,6 +18,7 @@
 
 namespace Memcard
 {
+	static std::array<std::unique_ptr<MemcardHostBase>, Memcard::MAX_SLOTS> s_memcardHosts;
 	static std::array<std::unique_ptr<MemcardBase>, Memcard::MAX_SLOTS> s_memcards;
 } // namespace Memcard
 
@@ -29,28 +31,41 @@ bool Memcard::Initialize()
 		if (fileName.empty())
 		{
 			s_memcards.at(i) = std::make_unique<MemcardNotConnected>(i);
+			s_memcardHosts.at(i) = nullptr;
 		}
 		else
 		{
 			const std::string fullPath = Path::Combine(EmuFolders::MemoryCards, fileName);
 
-			if (fullPath.ends_with(".ps2"))
+			// First, determine if the host is a file or folder, and set up a host object for it.
+			if (FileSystem::FileExists(fullPath.c_str()))
 			{
-				s_memcards.at(i) = std::make_unique<MemcardPS2>(i, fullPath);
+				s_memcardHosts.at(i) = std::make_unique<MemcardHostFile>(fullPath);
 			}
-			else if (fullPath.ends_with(".mcd"))
+			else if (FileSystem::DirectoryExists(fullPath.c_str()))
 			{
-				s_memcards.at(i) = std::make_unique<MemcardPS1>(i, fullPath);
+				s_memcardHosts.at(i) = std::make_unique<MemcardHostFolder>(fullPath);
+			}
+			else
+			{
+				s_memcardHosts.at(i) = nullptr;
+				s_memcards.at(i) = std::make_unique<MemcardNotConnected>(i);
+
+				Host::ReportFormattedErrorAsync("Memory Card", 
+					"Memory card not found: \n\n%s\n\n"
+					"PCSX2 will treat this memory card as ejected for this session.",
+					fullPath.c_str()
+				);
+				
+				continue;
 			}
 
-			// If a host was not built because no such file or folder existed,
-			// or a file card failed to open, then ditch the card
-			if (!s_memcards.at(i)->GetHost() || !s_memcards.at(i)->GetHost()->IsOpened())
+			// If the host failed to open, then ditch the card
+			if (!s_memcardHosts.at(i)->IsOpened())
 			{
+				s_memcardHosts.at(i) = nullptr;
 				s_memcards.at(i) = std::make_unique<MemcardNotConnected>(i);
 
-				// Translation note: detailed description should mention that the memory card will be disabled
-				// for the duration of this session.
 				Host::ReportFormattedErrorAsync("Memory Card", 
 					"Access denied to memory card: \n\n%s\n\n"
 					"PCSX2 will treat this memory card as ejected for this session. Another instance of PCSX2 may be using this memory card. Close any other instances of PCSX2, or restart your computer.%s",
@@ -61,6 +76,48 @@ bool Memcard::Initialize()
 					""
 #endif
 				);
+
+				continue;
+			}
+
+			// Now that we know the host is fine, determine what type of emulated memory card we are creating.
+			if (fullPath.ends_with(".ps2"))
+			{
+				s_memcards.at(i) = std::make_unique<MemcardPS2>(i);
+			}
+			else if (fullPath.ends_with(".mcd"))
+			{
+				s_memcards.at(i) = std::make_unique<MemcardPS1>(i);
+			}
+			else
+			{
+				s_memcardHosts.at(i) = nullptr;
+				s_memcards.at(i) = std::make_unique<MemcardNotConnected>(i);
+				
+				Host::ReportFormattedErrorAsync("Memory Card", 
+					"Unrecognized file extension: \n\n%s\n\n"
+					"Please check your memory card settings and insert a valid memory card.",
+					fullPath.c_str()
+				);
+
+				continue;
+			}
+
+			// Validate that the capacity is okay for the type of emulated card
+			MemcardBase* memcard = s_memcards.at(i).get();
+
+			if (!memcard->ValidateCapacity())
+			{
+				s_memcardHosts.at(i) = nullptr;
+				s_memcards.at(i) = std::make_unique<MemcardNotConnected>(i);
+				
+				Host::ReportFormattedErrorAsync("Memory Card", 
+					"Malformed memory card: \n\n%s\n\n"
+					"File size does not match a known memory card size. Please check your memory card settings and insert a valid memory card.",
+					fullPath.c_str()
+				);
+
+				continue;
 			}
 		}
 	}
@@ -78,11 +135,22 @@ void Memcard::Shutdown()
 
 MemcardBase* Memcard::GetMemcard(const u32 unifiedSlot)
 {
-	return s_memcards[unifiedSlot].get();
+	return s_memcards.at(unifiedSlot).get();
 }
 
 MemcardBase* Memcard::GetMemcard(const u32 port, const u32 slot)
 {
 	const u32 unifiedSlot = sioConvertPortAndSlotToPad(port, slot);
-	return s_memcards[unifiedSlot].get();
+	return s_memcards.at(unifiedSlot).get();
+}
+
+MemcardHostBase* Memcard::GetMemcardHost(const u32 unifiedSlot)
+{
+	return s_memcardHosts.at(unifiedSlot).get();
+}
+
+MemcardHostBase* Memcard::GetMemcardHost(const u32 port, const u32 slot)
+{
+	const u32 unifiedSlot = sioConvertPortAndSlotToPad(port, slot);
+	return s_memcardHosts.at(unifiedSlot).get();
 }

pcsx2/SIO/Memcard/Memcard.h

@@ -55,4 +55,6 @@ namespace Memcard
 
 	MemcardBase* GetMemcard(const u32 unifiedSlot);
 	MemcardBase* GetMemcard(const u32 port, const u32 slot);
+	MemcardHostBase* GetMemcardHost(const u32 unifiedSlot);
+	MemcardHostBase* GetMemcardHost(const u32 port, const u32 slot);
 } // namespace Memcard

pcsx2/SIO/Memcard/MemcardBase.cpp

@@ -12,26 +12,11 @@
 #include "fmt/core.h"
 #include "IconsFontAwesome5.h"
 
-MemcardBase::MemcardBase(u32 unifiedSlot, std::string fullPath)
+MemcardBase::MemcardBase(u32 unifiedSlot)
 {
 	this->unifiedSlot = unifiedSlot;
 	this->autoEjectTicks = 0;
 	this->lastWriteTime = std::chrono::system_clock::now();
-	
-	if (fullPath == "")
-	{
-		return;
-	}
-	else if (FileSystem::FileExists(fullPath.c_str()))
-	{
-		this->hostType = Memcard::HostType::FILE;
-		this->memcardHost = std::make_unique<MemcardHostFile>(fullPath);
-	}
-	else if (FileSystem::DirectoryExists(fullPath.c_str()))
-	{
-		this->hostType = Memcard::HostType::FOLDER;
-		this->memcardHost = std::make_unique<MemcardHostFolder>(fullPath);
-	}
 }
 
 MemcardBase::~MemcardBase() = default;
@@ -41,11 +26,6 @@ u32 MemcardBase::GetUnifiedSlot()
 	return this->unifiedSlot;
 }
 
-MemcardHostBase* MemcardBase::GetHost()
-{
-	return this->memcardHost.get();
-}
-
 void MemcardBase::SendWriteMessageToHost()
 {
 	const std::chrono::duration<float> elapsed = std::chrono::system_clock::now() - this->lastWriteTime;
@@ -59,7 +39,7 @@ void MemcardBase::SendWriteMessageToHost()
 			ICON_FA_SD_CARD,
 			fmt::format(
 				TRANSLATE_FS("MemoryCard", "Memory Card '{}' written to storage."),
-				Path::GetFileName(this->memcardHost->GetPath())),
+				Path::GetFileName(this->GetMemcardHost()->GetPath())),
 			Host::OSD_INFO_DURATION);
 		this->lastWriteTime = std::chrono::system_clock::now();
 	}
@@ -74,3 +54,8 @@ void MemcardBase::SetAutoEject()
 {
 	this->autoEjectTicks = 100;
 }
+
+MemcardHostBase* MemcardBase::GetMemcardHost()
+{
+	return Memcard::GetMemcardHost(this->unifiedSlot);
+}

pcsx2/SIO/Memcard/MemcardBase.h

@@ -2,29 +2,27 @@
 #pragma once
 
 #include "SIO/Memcard/Memcard.h"
-#include "SIO/Memcard/MemcardHostBase.h"
 
 class MemcardBase
 {
 private:
 	u32 unifiedSlot;
 
 protected:
-	Memcard::HostType hostType;
-	std::unique_ptr<MemcardHostBase> memcardHost;
 	u32 autoEjectTicks;
 	std::chrono::time_point<std::chrono::system_clock> lastWriteTime;
 
 public:
-	MemcardBase(u32 unifiedSlot, std::string fullPath);
+	MemcardBase(u32 unifiedSlot);
 	virtual ~MemcardBase();
 
 	u32 GetUnifiedSlot();
-	MemcardHostBase* GetHost();
 	void SendWriteMessageToHost();
 	u32 GetAutoEjectTicks();
 	void SetAutoEject();
+	MemcardHostBase* GetMemcardHost();
 
 	virtual Memcard::Type GetType() = 0;
+	virtual bool ValidateCapacity() = 0;
 	virtual void ExecuteCommand() = 0;
 };

pcsx2/SIO/Memcard/MemcardNotConnected.cpp

@@ -7,7 +7,7 @@
 #include "SIO/Sio0.h"
 
 MemcardNotConnected::MemcardNotConnected(u32 unifiedSlot)
-	: MemcardBase(unifiedSlot, "")
+	: MemcardBase(unifiedSlot)
 {
 
 }
@@ -18,6 +18,11 @@ Memcard::Type MemcardNotConnected::GetType()
 	return Memcard::Type::NOT_CONNECTED;
 }
 
+bool MemcardNotConnected::ValidateCapacity()
+{
+	return true;
+}
+
 // No-op. Let SIO2 and SIO0 sit with no response.
 void MemcardNotConnected::ExecuteCommand()
 {

pcsx2/SIO/Memcard/MemcardNotConnected.h

@@ -13,5 +13,6 @@ class MemcardNotConnected : public MemcardBase
 	~MemcardNotConnected();
 
 	Memcard::Type GetType() override;
+	bool ValidateCapacity() override;
 	void ExecuteCommand() override;
 };

pcsx2/SIO/Memcard/MemcardPS1.cpp

@@ -3,8 +3,8 @@
 
 #include "SIO/Memcard/MemcardPS1.h"
 
-MemcardPS1::MemcardPS1(u32 unifiedSlot, std::string fullPath)
-	: MemcardBase(unifiedSlot, fullPath)
+MemcardPS1::MemcardPS1(u32 unifiedSlot)
+	: MemcardBase(unifiedSlot)
 {
 
 }

pcsx2/SIO/Memcard/MemcardPS1.h

@@ -11,7 +11,7 @@ class MemcardPS1 : public MemcardBase
 	Memcard::Command currentCommand = Memcard::Command::NOT_SET;
 
 public:
-	MemcardPS1(u32 unifiedSlot, std::string fullPath);
+	MemcardPS1(u32 unifiedSlot);
 	~MemcardPS1();
 
 	Memcard::Type GetType() override;

pcsx2/SIO/Memcard/MemcardPS2.cpp

@@ -2,6 +2,7 @@
 #include "PrecompiledHeader.h"
 
 #include "SIO/Memcard/MemcardPS2.h"
+#include "SIO/Memcard/MemcardHostBase.h"
 
 #include "SIO/Sio.h"
 #include "SIO/Sio2.h"
@@ -144,7 +145,7 @@ void MemcardPS2::WriteData()
 		g_Sio2FifoOut.push_back(0x00);
 	}
 
-	this->memcardHost->Write(this->currentAddr, buf);
+	this->GetMemcardHost()->Write(this->currentAddr, buf);
 	g_Sio2FifoOut.push_back(checksum);
 	g_Sio2FifoOut.push_back(this->terminator);
 	this->currentAddr += writeLength;
@@ -158,7 +159,7 @@ void MemcardPS2::ReadData()
 	g_Sio2FifoOut.push_back(0x2B);
 	std::vector<u8> buf;
 	buf.resize(readLength);
-	this->memcardHost->Read(this->currentAddr, buf);
+	this->GetMemcardHost()->Read(this->currentAddr, buf);
 	u8 checksum = 0x00;
 
 	for (const u8 readByte : buf)
@@ -191,7 +192,7 @@ void MemcardPS2::EraseBlock()
 	std::vector<u8> clearData;
 	clearData.resize(MemcardPS2::ERASE_BLOCK_LENGTH);
 	memset(clearData.data(), 0xFF, clearData.size());
-	this->memcardHost->Write(this->currentAddr, clearData);
+	this->GetMemcardHost()->Write(this->currentAddr, clearData);
 	this->lastClearedEraseBlockAddr = this->currentAddr;
 
 	g_Sio2FifoOut.push_back(0x2B);
@@ -299,23 +300,29 @@ void MemcardPS2::AuthF7()
 	g_Sio2FifoOut.push_back(this->terminator);
 }
 
-MemcardPS2::MemcardPS2(u32 unifiedSlot, std::string fullPath)
-	: MemcardBase(unifiedSlot, fullPath)
+MemcardPS2::MemcardPS2(u32 unifiedSlot)
+	: MemcardBase(unifiedSlot)
 {
-	const s64 standardFileSize = (static_cast<u32>(ClusterCount::x8MB) * MemcardPS2::PAGES_PER_CLUSTER) * (MemcardPS2::PAGE_LENGTH + ECC_LENGTH);
-	const s64 maxFileSize = (static_cast<u32>(ClusterCount::x2048MB) * MemcardPS2::PAGES_PER_CLUSTER) * (MemcardPS2::PAGE_LENGTH + ECC_LENGTH);
+	this->clusterCount = static_cast<ClusterCount>(this->GetMemcardHost()->GetSize() / (MemcardPS2::PAGE_LENGTH + ECC_LENGTH) / MemcardPS2::PAGES_PER_CLUSTER);
+}
+
+MemcardPS2::~MemcardPS2() = default;
+
+Memcard::Type MemcardPS2::GetType()
+{
+	return Memcard::Type::PS2;
+}
+
+bool MemcardPS2::ValidateCapacity()
+{
+	const u32 standardFileSize = (static_cast<u32>(ClusterCount::x8MB) * MemcardPS2::PAGES_PER_CLUSTER) * (MemcardPS2::PAGE_LENGTH + ECC_LENGTH);
+	const u32 maxFileSize = (static_cast<u32>(ClusterCount::x2048MB) * MemcardPS2::PAGES_PER_CLUSTER) * (MemcardPS2::PAGE_LENGTH + ECC_LENGTH);
 
-	if (this->memcardHost)
+	if (this->GetMemcardHost() != nullptr)
 	{
-		s64 fileSize = this->memcardHost->GetSize();
+		const u32 fileSize = this->GetMemcardHost()->GetSize();
 
-		// If the host was a folder and reported -1, then we will have the card report 8 MB capacity to the PS2.
-		if (fileSize < 0)
-		{
-			fileSize = standardFileSize;
-		}
-		// If the host was a file, verify that its size hasn't been tampered with.
-		else if (fileSize > 0)
+		if (fileSize > 0)
 		{
 			u32 compareSize = standardFileSize;
 			bool sizeMatches = false;
@@ -331,21 +338,11 @@ MemcardPS2::MemcardPS2(u32 unifiedSlot, std::string fullPath)
 				compareSize *= 2;
 			} while (compareSize <= maxFileSize);
 
-			if (!sizeMatches)
-			{
-				Console.Warning("%s Irregular memcard file size detected (%s)", __FUNCTION__, fullPath);
-			}
+			return sizeMatches;
 		}
-
-		this->clusterCount = static_cast<ClusterCount>(fileSize / (MemcardPS2::PAGE_LENGTH + ECC_LENGTH) / MemcardPS2::PAGES_PER_CLUSTER);
 	}
-}
 
-MemcardPS2::~MemcardPS2() = default;
-
-Memcard::Type MemcardPS2::GetType()
-{
-	return Memcard::Type::PS2;
+	return false;
 }
 
 void MemcardPS2::ExecuteCommand()