DiscIO: Add functions CreateDisc and CreateWAD

...in addition to the existing function CreateVolume
(renamed from CreateVolumeFromFilename).

Lets code easily add constraints such as not letting the user
select a WAD file when using the disc changing functionality.

Source/Core/Core/Boot/Boot.cpp

@@ -161,10 +161,10 @@ BootParameters::GenerateFromFile(std::vector<std::string> paths,
       {".gcm", ".iso", ".tgc", ".wbfs", ".ciso", ".gcz", ".dol", ".elf"}};
   if (disc_image_extensions.find(extension) != disc_image_extensions.end() || is_drive)
   {
-    std::unique_ptr<DiscIO::Volume> volume = DiscIO::CreateVolumeFromFilename(path);
+    std::unique_ptr<DiscIO::VolumeDisc> disc = DiscIO::CreateDisc(path);
-    if (volume)
+    if (disc)
     {
-      return std::make_unique<BootParameters>(Disc{std::move(path), std::move(volume), paths},
+      return std::make_unique<BootParameters>(Disc{std::move(path), std::move(disc), paths},
                                               savestate_path);
     }
 
@@ -221,19 +221,19 @@ BootParameters::IPL::IPL(DiscIO::Region region_, Disc&& disc_) : IPL(region_)
 // Inserts a disc into the emulated disc drive and returns a pointer to it.
 // The returned pointer must only be used while we are still booting,
 // because DVDThread can do whatever it wants to the disc after that.
-static const DiscIO::Volume* SetDisc(std::unique_ptr<DiscIO::Volume> volume,
+static const DiscIO::VolumeDisc* SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
-                                     std::vector<std::string> auto_disc_change_paths = {})
+                                         std::vector<std::string> auto_disc_change_paths = {})
 {
-  const DiscIO::Volume* pointer = volume.get();
+  const DiscIO::VolumeDisc* pointer = disc.get();
-  DVDInterface::SetDisc(std::move(volume), auto_disc_change_paths);
+  DVDInterface::SetDisc(std::move(disc), auto_disc_change_paths);
   return pointer;
 }
 
-bool CBoot::DVDRead(const DiscIO::Volume& volume, u64 dvd_offset, u32 output_address, u32 length,
+bool CBoot::DVDRead(const DiscIO::VolumeDisc& disc, u64 dvd_offset, u32 output_address, u32 length,
                     const DiscIO::Partition& partition)
 {
   std::vector<u8> buffer(length);
-  if (!volume.Read(dvd_offset, length, buffer.data(), partition))
+  if (!disc.Read(dvd_offset, length, buffer.data(), partition))
     return false;
   Memory::CopyToEmu(output_address, buffer.data(), length);
   return true;
@@ -365,7 +365,7 @@ static void SetDefaultDisc()
 {
   const std::string default_iso = Config::Get(Config::MAIN_DEFAULT_ISO);
   if (!default_iso.empty())
-    SetDisc(DiscIO::CreateVolumeFromFilename(default_iso));
+    SetDisc(DiscIO::CreateDisc(default_iso));
 }
 
 static void CopyDefaultExceptionHandlers()
@@ -401,7 +401,8 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
     bool operator()(BootParameters::Disc& disc) const
     {
       NOTICE_LOG(BOOT, "Booting from disc: %s", disc.path.c_str());
-      const DiscIO::Volume* volume = SetDisc(std::move(disc.volume), disc.auto_disc_change_paths);
+      const DiscIO::VolumeDisc* volume =
+          SetDisc(std::move(disc.volume), disc.auto_disc_change_paths);
 
       if (!volume)
         return false;
@@ -495,7 +496,7 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
       if (ipl.disc)
       {
         NOTICE_LOG(BOOT, "Inserting disc: %s", ipl.disc->path.c_str());
-        SetDisc(DiscIO::CreateVolumeFromFilename(ipl.disc->path), ipl.disc->auto_disc_change_paths);
+        SetDisc(DiscIO::CreateDisc(ipl.disc->path), ipl.disc->auto_disc_change_paths);
       }
 
       if (LoadMapFromFilename())

Source/Core/Core/Boot/Boot.h

@@ -39,7 +39,7 @@ struct BootParameters
   struct Disc
   {
     std::string path;
-    std::unique_ptr<DiscIO::Volume> volume;
+    std::unique_ptr<DiscIO::VolumeDisc> volume;
     std::vector<std::string> auto_disc_change_paths;
   };
 
@@ -102,8 +102,8 @@ public:
   static bool LoadMapFromFilename();
 
 private:
-  static bool DVDRead(const DiscIO::Volume& volume, u64 dvd_offset, u32 output_address, u32 length,
+  static bool DVDRead(const DiscIO::VolumeDisc& disc, u64 dvd_offset, u32 output_address,
-                      const DiscIO::Partition& partition);
+                      u32 length, const DiscIO::Partition& partition);
   static void RunFunction(u32 address);
 
   static void UpdateDebugger_MapLoaded();
@@ -113,10 +113,10 @@ private:
 
   static void SetupMSR();
   static void SetupBAT(bool is_wii);
-  static bool RunApploader(bool is_wii, const DiscIO::Volume& volume);
+  static bool RunApploader(bool is_wii, const DiscIO::VolumeDisc& volume);
-  static bool EmulatedBS2_GC(const DiscIO::Volume& volume);
+  static bool EmulatedBS2_GC(const DiscIO::VolumeDisc& volume);
-  static bool EmulatedBS2_Wii(const DiscIO::Volume& volume);
+  static bool EmulatedBS2_Wii(const DiscIO::VolumeDisc& volume);
-  static bool EmulatedBS2(bool is_wii, const DiscIO::Volume& volume);
+  static bool EmulatedBS2(bool is_wii, const DiscIO::VolumeDisc& volume);
   static bool Load_BS2(const std::string& boot_rom_filename);
 
   static void SetupGCMemory();

Source/Core/Core/Boot/Boot_BS2Emu.cpp

@@ -85,7 +85,7 @@ void CBoot::SetupBAT(bool is_wii)
   PowerPC::IBATUpdated();
 }
 
-bool CBoot::RunApploader(bool is_wii, const DiscIO::Volume& volume)
+bool CBoot::RunApploader(bool is_wii, const DiscIO::VolumeDisc& volume)
 {
   const DiscIO::Partition partition = volume.GetGamePartition();
 
@@ -200,7 +200,7 @@ void CBoot::SetupGCMemory()
 // GameCube Bootstrap 2 HLE:
 // copy the apploader to 0x81200000
 // execute the apploader, function by function, using the above utility.
-bool CBoot::EmulatedBS2_GC(const DiscIO::Volume& volume)
+bool CBoot::EmulatedBS2_GC(const DiscIO::VolumeDisc& volume)
 {
   INFO_LOG(BOOT, "Faking GC BS2...");
 
@@ -366,7 +366,7 @@ static void WriteEmptyPlayRecord()
 // Wii Bootstrap 2 HLE:
 // copy the apploader to 0x81200000
 // execute the apploader
-bool CBoot::EmulatedBS2_Wii(const DiscIO::Volume& volume)
+bool CBoot::EmulatedBS2_Wii(const DiscIO::VolumeDisc& volume)
 {
   INFO_LOG(BOOT, "Faking Wii BS2...");
   if (volume.GetVolumeType() != DiscIO::Platform::WiiDisc)
@@ -426,7 +426,7 @@ bool CBoot::EmulatedBS2_Wii(const DiscIO::Volume& volume)
 
 // Returns true if apploader has run successfully. If is_wii is true, the disc
 // that volume refers to must currently be inserted into the emulated disc drive.
-bool CBoot::EmulatedBS2(bool is_wii, const DiscIO::Volume& volume)
+bool CBoot::EmulatedBS2(bool is_wii, const DiscIO::VolumeDisc& volume)
 {
   return is_wii ? EmulatedBS2_Wii(volume) : EmulatedBS2_GC(volume);
 }

Source/Core/Core/HW/DVD/DVDInterface.cpp

@@ -470,7 +470,7 @@ void Shutdown()
   DVDThread::Stop();
 }
 
-void SetDisc(std::unique_ptr<DiscIO::Volume> disc,
+void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
              std::optional<std::vector<std::string>> auto_disc_change_paths = {})
 {
   if (disc)
@@ -506,11 +506,10 @@ static void EjectDiscCallback(u64 userdata, s64 cyclesLate)
 
 static void InsertDiscCallback(u64 userdata, s64 cyclesLate)
 {
-  std::unique_ptr<DiscIO::Volume> new_volume =
+  std::unique_ptr<DiscIO::VolumeDisc> new_disc = DiscIO::CreateDisc(s_disc_path_to_insert);
-      DiscIO::CreateVolumeFromFilename(s_disc_path_to_insert);
 
-  if (new_volume)
+  if (new_disc)
-    SetDisc(std::move(new_volume), {});
+    SetDisc(std::move(new_disc), {});
   else
     PanicAlertT("The disc that was about to be inserted couldn't be found.");
 

Source/Core/Core/HW/DVD/DVDInterface.h

@@ -14,7 +14,7 @@
 class PointerWrap;
 namespace DiscIO
 {
-class Volume;
+class VolumeDisc;
 struct Partition;
 }  // namespace DiscIO
 namespace MMIO
@@ -81,7 +81,7 @@ void DoState(PointerWrap& p);
 
 void RegisterMMIO(MMIO::Mapping* mmio, u32 base);
 
-void SetDisc(std::unique_ptr<DiscIO::Volume> disc,
+void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
              std::optional<std::vector<std::string>> auto_disc_change_paths);
 bool IsDiscInside();
 void EjectDisc();                                        // Must only be called on the CPU thread

Source/Core/Core/WiiUtils.cpp

@@ -581,8 +581,7 @@ class DiscSystemUpdater final : public SystemUpdater
 {
 public:
   DiscSystemUpdater(UpdateCallback update_callback, const std::string& image_path)
-      : m_update_callback{std::move(update_callback)}, m_volume{DiscIO::CreateVolumeFromFilename(
+      : m_update_callback{std::move(update_callback)}, m_volume{DiscIO::CreateDisc(image_path)}
-                                                           image_path)}
   {
   }
   UpdateResult DoDiscUpdate();
@@ -621,7 +620,7 @@ private:
                             std::string_view path);
 
   UpdateCallback m_update_callback;
-  std::unique_ptr<DiscIO::Volume> m_volume;
+  std::unique_ptr<DiscIO::VolumeDisc> m_volume;
   DiscIO::Partition m_partition;
 };
 

Source/Core/DiscIO/CompressedBlob.cpp

@@ -182,10 +182,10 @@ bool CompressFileToBlob(const std::string& infile_path, const std::string& outfi
   }
 
   DiscScrubber disc_scrubber;
-  std::unique_ptr<Volume> volume;
+  std::unique_ptr<VolumeDisc> volume;
   if (sub_type == 1)
   {
-    volume = CreateVolumeFromFilename(infile_path);
+    volume = CreateDisc(infile_path);
     if (!volume || !disc_scrubber.SetupScrub(volume.get(), block_size))
     {
       PanicAlertT("\"%s\" failed to be scrubbed. Probably the image is corrupt.",

Source/Core/DiscIO/FileSystemGCWii.cpp

@@ -223,7 +223,7 @@ bool FileInfoGCWii::IsValid(u64 fst_size, const FileInfoGCWii& parent_directory)
   return true;
 }
 
-FileSystemGCWii::FileSystemGCWii(const Volume* volume, const Partition& partition)
+FileSystemGCWii::FileSystemGCWii(const VolumeDisc* volume, const Partition& partition)
     : m_valid(false), m_root(nullptr, 0, 0, 0)
 {
   u8 offset_shift;

Source/Core/DiscIO/FileSystemGCWii.h

@@ -17,7 +17,7 @@
 
 namespace DiscIO
 {
-class Volume;
+class VolumeDisc;
 struct Partition;
 
 class FileInfoGCWii : public FileInfo
@@ -87,7 +87,7 @@ private:
 class FileSystemGCWii : public FileSystem
 {
 public:
-  FileSystemGCWii(const Volume* volume, const Partition& partition);
+  FileSystemGCWii(const VolumeDisc* volume, const Partition& partition);
   ~FileSystemGCWii() override;
 
   bool IsValid() const override { return m_valid; }

Source/Core/DiscIO/Volume.cpp

@@ -43,23 +43,13 @@ std::map<Language, std::string> Volume::ReadWiiNames(const std::vector<char16_t>
   return names;
 }
 
-std::unique_ptr<Volume> CreateVolumeFromFilename(const std::string& filename)
+static std::unique_ptr<VolumeDisc> CreateDisc(std::unique_ptr<BlobReader>& reader)
 {
-  std::unique_ptr<BlobReader> reader(CreateBlobReader(filename));
-  if (reader == nullptr)
-    return nullptr;
-
   // Check for Wii
   const std::optional<u32> wii_magic = reader->ReadSwapped<u32>(0x18);
   if (wii_magic == u32(0x5D1C9EA3))
     return std::make_unique<VolumeWii>(std::move(reader));
 
-  // Check for WAD
-  // 0x206962 for boot2 wads
-  const std::optional<u32> wad_magic = reader->ReadSwapped<u32>(0x02);
-  if (wad_magic == u32(0x00204973) || wad_magic == u32(0x00206962))
-    return std::make_unique<VolumeWAD>(std::move(reader));
-
   // Check for GC
   const std::optional<u32> gc_magic = reader->ReadSwapped<u32>(0x1C);
   if (gc_magic == u32(0xC2339F3D))
@@ -69,4 +59,45 @@ std::unique_ptr<Volume> CreateVolumeFromFilename(const std::string& filename)
   return nullptr;
 }
 
+std::unique_ptr<VolumeDisc> CreateDisc(const std::string& path)
+{
+  std::unique_ptr<BlobReader> reader(CreateBlobReader(path));
+  return reader ? CreateDisc(reader) : nullptr;
+}
+
+static std::unique_ptr<VolumeWAD> CreateWAD(std::unique_ptr<BlobReader>& reader)
+{
+  // Check for WAD
+  // 0x206962 for boot2 wads
+  const std::optional<u32> wad_magic = reader->ReadSwapped<u32>(0x02);
+  if (wad_magic == u32(0x00204973) || wad_magic == u32(0x00206962))
+    return std::make_unique<VolumeWAD>(std::move(reader));
+
+  // No known magic words found
+  return nullptr;
+}
+
+std::unique_ptr<VolumeWAD> CreateWAD(const std::string& path)
+{
+  std::unique_ptr<BlobReader> reader(CreateBlobReader(path));
+  return reader ? CreateWAD(reader) : nullptr;
+}
+
+std::unique_ptr<Volume> CreateVolume(const std::string& path)
+{
+  std::unique_ptr<BlobReader> reader(CreateBlobReader(path));
+  if (reader == nullptr)
+    return nullptr;
+
+  std::unique_ptr<VolumeDisc> disc = CreateDisc(reader);
+  if (disc)
+    return disc;
+
+  std::unique_ptr<VolumeWAD> wad = CreateWAD(reader);
+  if (wad)
+    return wad;
+
+  return nullptr;
+}
+
 }  // namespace DiscIO

Source/Core/DiscIO/Volume.h

@@ -22,6 +22,7 @@ namespace DiscIO
 {
 enum class BlobType;
 class FileSystem;
+class VolumeWAD;
 
 struct Partition final
 {
@@ -141,6 +142,12 @@ protected:
   static const std::vector<u8> INVALID_CERT_CHAIN;
 };
 
-std::unique_ptr<Volume> CreateVolumeFromFilename(const std::string& filename);
+class VolumeDisc : public Volume
+{
+};
+
+std::unique_ptr<VolumeDisc> CreateDisc(const std::string& path);
+std::unique_ptr<VolumeWAD> CreateWAD(const std::string& path);
+std::unique_ptr<Volume> CreateVolume(const std::string& path);
 
 }  // namespace DiscIO

Source/Core/DiscIO/VolumeGC.h

@@ -25,7 +25,7 @@ enum class Language;
 enum class Region;
 enum class Platform;
 
-class VolumeGC : public Volume
+class VolumeGC : public VolumeDisc
 {
 public:
   VolumeGC(std::unique_ptr<BlobReader> reader);

Source/Core/DiscIO/VolumeWii.h

@@ -27,7 +27,7 @@ enum class Language;
 enum class Region;
 enum class Platform;
 
-class VolumeWii : public Volume
+class VolumeWii : public VolumeDisc
 {
 public:
   VolumeWii(std::unique_ptr<BlobReader> reader);

Source/Core/DolphinQt/Config/PropertiesDialog.cpp

@@ -60,7 +60,7 @@ PropertiesDialog::PropertiesDialog(QWidget* parent, const UICommon::GameFile& ga
 
   if (game.GetPlatform() != DiscIO::Platform::ELFOrDOL)
   {
-    std::shared_ptr<DiscIO::Volume> volume = DiscIO::CreateVolumeFromFilename(game.GetFilePath());
+    std::shared_ptr<DiscIO::Volume> volume = DiscIO::CreateVolume(game.GetFilePath());
     if (volume)
     {
       VerifyWidget* verify = new VerifyWidget(volume);

Source/Core/UICommon/GameFile.cpp

@@ -121,7 +121,7 @@ GameFile::GameFile(std::string path) : m_file_path(std::move(path))
     SplitPath(m_file_path, nullptr, &name, &extension);
     m_file_name = name + extension;
 
-    std::unique_ptr<DiscIO::Volume> volume(DiscIO::CreateVolumeFromFilename(m_file_path));
+    std::unique_ptr<DiscIO::Volume> volume(DiscIO::CreateVolume(m_file_path));
     if (volume != nullptr)
     {
       m_platform = volume->GetVolumeType();