Move DiscIO enums to a new file

At first there weren't many enums in Volume.h, but the number has been
growing, and I'm planning to add one more for regions. To not make
Volume.h too large, and to avoid needing to include Volume.h in code
that doesn't use volume objects, I'm moving the enums to a new file.
I'm also turning them into enum classes while I'm at it.

Source/Android/jni/MainAndroid.cpp

@@ -33,6 +33,7 @@
 #include "Core/PowerPC/Profiler.h"
 #include "Core/State.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 
@@ -226,15 +227,14 @@ static int GetCountry(std::string filename)
 
   if (pVolume != nullptr)
   {
-    DiscIO::IVolume::ECountry country = pVolume->GetCountry();
+    int country = static_cast<int>(pVolume->GetCountry());
 
     __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Country Code: %i", country);
 
     return country;
   }
 
-  // Return UNKNOWN
+  return static_cast<int>(DiscIO::Country::COUNTRY_UNKNOWN);
-  return 13;
 }
 
 static int GetPlatform(std::string filename)
@@ -245,13 +245,13 @@ static int GetPlatform(std::string filename)
   {
     switch (pVolume->GetVolumeType())
     {
-    case DiscIO::IVolume::GAMECUBE_DISC:
+    case DiscIO::Platform::GAMECUBE_DISC:
       __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a GameCube disc.");
       return 0;
-    case DiscIO::IVolume::WII_DISC:
+    case DiscIO::Platform::WII_DISC:
       __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a Wii disc.");
       return 1;
-    case DiscIO::IVolume::WII_WAD:
+    case DiscIO::Platform::WII_WAD:
       __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a Wii WAD.");
       return 2;
     }
@@ -269,13 +269,13 @@ static std::string GetTitle(std::string filename)
 
   if (pVolume != nullptr)
   {
-    std::map<DiscIO::IVolume::ELanguage, std::string> titles = pVolume->GetLongNames();
+    std::map<DiscIO::Language, std::string> titles = pVolume->GetLongNames();
     if (titles.empty())
       titles = pVolume->GetShortNames();
 
     /*
-    bool is_wii_title = pVolume->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
+    bool is_wii_title = pVolume->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC;
-    DiscIO::IVolume::ELanguage language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
+    DiscIO::Language language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
 
     auto it = titles.find(language);
     if (it != end)
@@ -284,8 +284,8 @@ static std::string GetTitle(std::string filename)
     auto end = titles.end();
 
     // English tends to be a good fallback when the requested language isn't available
-    // if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH) {
+    // if (language != DiscIO::Language::LANGUAGE_ENGLISH) {
-    auto it = titles.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
+    auto it = titles.find(DiscIO::Language::LANGUAGE_ENGLISH);
     if (it != end)
       return it->second;
     //}
@@ -312,11 +312,11 @@ static std::string GetDescription(std::string filename)
 
   if (volume != nullptr)
   {
-    std::map<DiscIO::IVolume::ELanguage, std::string> descriptions = volume->GetDescriptions();
+    std::map<DiscIO::Language, std::string> descriptions = volume->GetDescriptions();
 
     /*
-    bool is_wii_title = pVolume->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
+    bool is_wii_title = pVolume->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC;
-    DiscIO::IVolume::ELanguage language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
+    DiscIO::Language language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
 
     auto it = descriptions.find(language);
     if (it != end)
@@ -325,8 +325,8 @@ static std::string GetDescription(std::string filename)
     auto end = descriptions.end();
 
     // English tends to be a good fallback when the requested language isn't available
-    // if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH) {
+    // if (language != DiscIO::Language::LANGUAGE_ENGLISH) {
-    auto it = descriptions.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
+    auto it = descriptions.find(DiscIO::Language::LANGUAGE_ENGLISH);
     if (it != end)
       return it->second;
     //}

Source/Core/Core/Boot/Boot.cpp

@@ -31,7 +31,9 @@
 #include "Core/PowerPC/PowerPC.h"
 #include "Core/PowerPC/SignatureDB.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/NANDContentLoader.h"
+#include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 
 bool CBoot::DVDRead(u64 dvd_offset, u32 output_address, u32 length, bool decrypt)
@@ -263,7 +265,7 @@ bool CBoot::BootUp()
 
     const DiscIO::IVolume& pVolume = DVDInterface::GetVolume();
 
-    if ((pVolume.GetVolumeType() == DiscIO::IVolume::WII_DISC) != _StartupPara.bWii)
+    if ((pVolume.GetVolumeType() == DiscIO::Platform::WII_DISC) != _StartupPara.bWii)
     {
       PanicAlertT("Warning - starting ISO in wrong console mode!");
     }
@@ -278,7 +280,7 @@ bool CBoot::BootUp()
       WII_IPC_HLE_Interface::ES_DIVerify(tmd_buffer);
     }
 
-    _StartupPara.bWii = pVolume.GetVolumeType() == DiscIO::IVolume::WII_DISC;
+    _StartupPara.bWii = pVolume.GetVolumeType() == DiscIO::Platform::WII_DISC;
 
     // HLE BS2 or not
     if (_StartupPara.bHLE_BS2)
@@ -338,7 +340,7 @@ bool CBoot::BootUp()
       BS2Success = EmulatedBS2(dolWii);
     }
     else if ((!DVDInterface::VolumeIsValid() ||
-              DVDInterface::GetVolume().GetVolumeType() != DiscIO::IVolume::WII_DISC) &&
+              DVDInterface::GetVolume().GetVolumeType() != DiscIO::Platform::WII_DISC) &&
              !_StartupPara.m_strDefaultISO.empty())
     {
       DVDInterface::SetVolumeName(_StartupPara.m_strDefaultISO);
@@ -409,7 +411,7 @@ bool CBoot::BootUp()
 
     // Poor man's bootup
     if (_StartupPara.bWii)
-      SetupWiiMemory(DiscIO::IVolume::COUNTRY_UNKNOWN);
+      SetupWiiMemory(DiscIO::Country::COUNTRY_UNKNOWN);
     else
       EmulatedBS2_GC(true);
 

Source/Core/Core/Boot/Boot.h

@@ -7,7 +7,10 @@
 #include <cstdlib>
 #include <string>
 
-#include "DiscIO/Volume.h"
+namespace DiscIO
+{
+enum class Country;
+}
 
 struct CountrySetting
 {
@@ -54,5 +57,5 @@ private:
   static bool Load_BS2(const std::string& _rBootROMFilename);
   static void Load_FST(bool _bIsWii);
 
-  static bool SetupWiiMemory(DiscIO::IVolume::ECountry country);
+  static bool SetupWiiMemory(DiscIO::Country country);
 };

Source/Core/Core/Boot/Boot_BS2Emu.cpp

@@ -20,6 +20,9 @@
 #include "Core/PatchEngine.h"
 #include "Core/PowerPC/PowerPC.h"
 
+#include "DiscIO/Enums.h"
+#include "DiscIO/Volume.h"
+
 void CBoot::RunFunction(u32 _iAddr)
 {
   PC = _iAddr;
@@ -178,21 +181,21 @@ bool CBoot::EmulatedBS2_GC(bool skipAppLoader)
   return true;
 }
 
-bool CBoot::SetupWiiMemory(DiscIO::IVolume::ECountry country)
+bool CBoot::SetupWiiMemory(DiscIO::Country country)
 {
   static const CountrySetting SETTING_EUROPE = {"EUR", "PAL", "EU", "LE"};
   static const CountrySetting SETTING_USA = {"USA", "NTSC", "US", "LU"};
   static const CountrySetting SETTING_JAPAN = {"JPN", "NTSC", "JP", "LJ"};
   static const CountrySetting SETTING_KOREA = {"KOR", "NTSC", "KR", "LKH"};
-  static const std::map<DiscIO::IVolume::ECountry, const CountrySetting> country_settings = {
+  static const std::map<DiscIO::Country, const CountrySetting> country_settings = {
-      {DiscIO::IVolume::COUNTRY_EUROPE, SETTING_EUROPE},
+      {DiscIO::Country::COUNTRY_EUROPE, SETTING_EUROPE},
-      {DiscIO::IVolume::COUNTRY_USA, SETTING_USA},
+      {DiscIO::Country::COUNTRY_USA, SETTING_USA},
-      {DiscIO::IVolume::COUNTRY_JAPAN, SETTING_JAPAN},
+      {DiscIO::Country::COUNTRY_JAPAN, SETTING_JAPAN},
-      {DiscIO::IVolume::COUNTRY_KOREA, SETTING_KOREA},
+      {DiscIO::Country::COUNTRY_KOREA, SETTING_KOREA},
       // TODO: Determine if Taiwan have their own specific settings.
       //      Also determine if there are other specific settings
       //      for other countries.
-      {DiscIO::IVolume::COUNTRY_TAIWAN, SETTING_JAPAN}};
+      {DiscIO::Country::COUNTRY_TAIWAN, SETTING_JAPAN}};
   auto entryPos = country_settings.find(country);
   const CountrySetting& country_setting =
       (entryPos != country_settings.end()) ?
@@ -333,7 +336,7 @@ bool CBoot::EmulatedBS2_Wii()
   INFO_LOG(BOOT, "Faking Wii BS2...");
 
   // Setup Wii memory
-  DiscIO::IVolume::ECountry country_code = DiscIO::IVolume::COUNTRY_UNKNOWN;
+  DiscIO::Country country_code = DiscIO::Country::COUNTRY_UNKNOWN;
   if (DVDInterface::VolumeIsValid())
     country_code = DVDInterface::GetVolume().GetCountry();
   if (SetupWiiMemory(country_code) == false)
@@ -342,7 +345,7 @@ bool CBoot::EmulatedBS2_Wii()
   // Execute the apploader
   bool apploaderRan = false;
   if (DVDInterface::VolumeIsValid() &&
-      DVDInterface::GetVolume().GetVolumeType() == DiscIO::IVolume::WII_DISC)
+      DVDInterface::GetVolume().GetVolumeType() == DiscIO::Platform::WII_DISC)
   {
     // This is some kind of consistency check that is compared to the 0x00
     // values as the game boots. This location keeps the 4 byte ID for as long

Source/Core/Core/Boot/Boot_ELF.cpp

@@ -4,6 +4,7 @@
 
 #include <memory>
 
+#include "Common/CommonFuncs.h"
 #include "Common/FileUtil.h"
 #include "Core/Boot/Boot.h"
 #include "Core/Boot/ElfReader.h"

Source/Core/Core/Boot/Boot_WiiWAD.cpp

@@ -20,6 +20,7 @@
 #include "Core/PatchEngine.h"
 #include "Core/PowerPC/PowerPC.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/NANDContentLoader.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
@@ -92,7 +93,7 @@ bool CBoot::Boot_WiiWAD(const std::string& _pFilename)
   if (!SetupWiiMemory(ContentLoader.GetCountry()))
     return false;
   // this sets a bit that is used to detect NTSC-J
-  if (ContentLoader.GetCountry() == DiscIO::IVolume::COUNTRY_JAPAN)
+  if (ContentLoader.GetCountry() == DiscIO::Country::COUNTRY_JAPAN)
   {
     VideoInterface::SetRegionReg('J');
   }

Source/Core/Core/ConfigManager.cpp

@@ -19,7 +19,9 @@
 #include "Core/HW/SI.h"
 #include "Core/PowerPC/PowerPC.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/NANDContentLoader.h"
+#include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 
 SConfig* SConfig::m_Instance;
@@ -672,31 +674,31 @@ void SConfig::LoadDefaults()
   m_revision = 0;
 }
 
-static const char* GetRegionOfCountry(DiscIO::IVolume::ECountry country)
+static const char* GetRegionOfCountry(DiscIO::Country country)
 {
   switch (country)
   {
-  case DiscIO::IVolume::COUNTRY_USA:
+  case DiscIO::Country::COUNTRY_USA:
     return USA_DIR;
 
-  case DiscIO::IVolume::COUNTRY_TAIWAN:
+  case DiscIO::Country::COUNTRY_TAIWAN:
-  case DiscIO::IVolume::COUNTRY_KOREA:
+  case DiscIO::Country::COUNTRY_KOREA:
   // TODO: Should these have their own Region Dir?
-  case DiscIO::IVolume::COUNTRY_JAPAN:
+  case DiscIO::Country::COUNTRY_JAPAN:
     return JAP_DIR;
 
-  case DiscIO::IVolume::COUNTRY_AUSTRALIA:
+  case DiscIO::Country::COUNTRY_AUSTRALIA:
-  case DiscIO::IVolume::COUNTRY_EUROPE:
+  case DiscIO::Country::COUNTRY_EUROPE:
-  case DiscIO::IVolume::COUNTRY_FRANCE:
+  case DiscIO::Country::COUNTRY_FRANCE:
-  case DiscIO::IVolume::COUNTRY_GERMANY:
+  case DiscIO::Country::COUNTRY_GERMANY:
-  case DiscIO::IVolume::COUNTRY_ITALY:
+  case DiscIO::Country::COUNTRY_ITALY:
-  case DiscIO::IVolume::COUNTRY_NETHERLANDS:
+  case DiscIO::Country::COUNTRY_NETHERLANDS:
-  case DiscIO::IVolume::COUNTRY_RUSSIA:
+  case DiscIO::Country::COUNTRY_RUSSIA:
-  case DiscIO::IVolume::COUNTRY_SPAIN:
+  case DiscIO::Country::COUNTRY_SPAIN:
-  case DiscIO::IVolume::COUNTRY_WORLD:
+  case DiscIO::Country::COUNTRY_WORLD:
     return EUR_DIR;
 
-  case DiscIO::IVolume::COUNTRY_UNKNOWN:
+  case DiscIO::Country::COUNTRY_UNKNOWN:
   default:
     return nullptr;
   }
@@ -745,7 +747,7 @@ bool SConfig::AutoSetup(EBootBS2 _BootBS2)
       m_revision = pVolume->GetRevision();
 
       // Check if we have a Wii disc
-      bWii = pVolume->GetVolumeType() == DiscIO::IVolume::WII_DISC;
+      bWii = pVolume->GetVolumeType() == DiscIO::Platform::WII_DISC;
 
       const char* retrieved_region_dir = GetRegionOfCountry(pVolume->GetCountry());
       if (!retrieved_region_dir)
@@ -947,17 +949,19 @@ void SConfig::CheckMemcardPath(std::string& memcardPath, const std::string& game
   }
 }
 
-DiscIO::IVolume::ELanguage SConfig::GetCurrentLanguage(bool wii) const
+DiscIO::Language SConfig::GetCurrentLanguage(bool wii) const
 {
-  DiscIO::IVolume::ELanguage language;
+  int language_value;
   if (wii)
-    language = (DiscIO::IVolume::ELanguage)SConfig::GetInstance().m_SYSCONF->GetData<u8>("IPL.LNG");
+    language_value = SConfig::GetInstance().m_SYSCONF->GetData<u8>("IPL.LNG");
   else
-    language = (DiscIO::IVolume::ELanguage)(SConfig::GetInstance().SelectedLanguage + 1);
+    language_value = SConfig::GetInstance().SelectedLanguage + 1;
+  DiscIO::Language language = static_cast<DiscIO::Language>(language_value);
 
   // Get rid of invalid values (probably doesn't matter, but might as well do it)
-  if (language > DiscIO::IVolume::ELanguage::LANGUAGE_UNKNOWN || language < 0)
+  if (language > DiscIO::Language::LANGUAGE_UNKNOWN ||
-    language = DiscIO::IVolume::ELanguage::LANGUAGE_UNKNOWN;
+      language < DiscIO::Language::LANGUAGE_JAPANESE)
+    language = DiscIO::Language::LANGUAGE_UNKNOWN;
   return language;
 }
 

Source/Core/Core/ConfigManager.h

@@ -12,7 +12,11 @@
 #include "Common/SysConf.h"
 #include "Core/HW/EXI_Device.h"
 #include "Core/HW/SI_Device.h"
-#include "DiscIO/Volume.h"
+
+namespace DiscIO
+{
+enum class Language;
+}
 
 // DSP Backend Types
 #define BACKEND_NULLSOUND _trans("No audio output")
@@ -177,7 +181,7 @@ struct SConfig : NonCopyable
   bool AutoSetup(EBootBS2 _BootBS2);
   const std::string& GetUniqueID() const { return m_strUniqueID; }
   void CheckMemcardPath(std::string& memcardPath, const std::string& gameRegion, bool isSlotA);
-  DiscIO::IVolume::ELanguage GetCurrentLanguage(bool wii) const;
+  DiscIO::Language GetCurrentLanguage(bool wii) const;
 
   IniFile LoadDefaultGameIni() const;
   IniFile LoadLocalGameIni() const;

Source/Core/Core/HW/DVDInterface.cpp

@@ -28,6 +28,7 @@
 #include "Core/IPC_HLE/WII_IPC_HLE_Device_DI.h"
 #include "Core/Movie.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 
@@ -1417,7 +1418,7 @@ s64 CalculateRawDiscReadTime(u64 offset, s64 length)
   // Note that the speed at a track (in bytes per second) is the same as
   // the radius of that track because of the length unit used.
   double speed;
-  if (s_inserted_volume->GetVolumeType() == DiscIO::IVolume::WII_DISC)
+  if (s_inserted_volume->GetVolumeType() == DiscIO::Platform::WII_DISC)
   {
     speed = std::sqrt(((average_offset - WII_DISC_LOCATION_1_OFFSET) / WII_BYTES_PER_AREA_UNIT +
                        WII_DISC_AREA_UP_TO_LOCATION_1) /

Source/Core/Core/HW/EXI_DeviceMemoryCard.cpp

@@ -27,6 +27,7 @@
 #include "Core/HW/Sram.h"
 #include "Core/HW/SystemTimers.h"
 #include "Core/Movie.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/NANDContentLoader.h"
 
 #define MC_STATUS_BUSY 0x80
@@ -135,7 +136,7 @@ CEXIMemoryCard::CEXIMemoryCard(const int index, bool gciFolder) : card_index(ind
 
 void CEXIMemoryCard::SetupGciFolder(u16 sizeMb)
 {
-  DiscIO::IVolume::ECountry country_code = DiscIO::IVolume::COUNTRY_UNKNOWN;
+  DiscIO::Country country_code = DiscIO::Country::COUNTRY_UNKNOWN;
   auto strUniqueID = SConfig::GetInstance().m_strUniqueID;
 
   u32 CurrentGameId = 0;
@@ -158,14 +159,14 @@ void CEXIMemoryCard::SetupGciFolder(u16 sizeMb)
   std::string strDirectoryName = File::GetUserPath(D_GCUSER_IDX);
   switch (country_code)
   {
-  case DiscIO::IVolume::COUNTRY_JAPAN:
+  case DiscIO::Country::COUNTRY_JAPAN:
     ascii = false;
     strDirectoryName += JAP_DIR DIR_SEP;
     break;
-  case DiscIO::IVolume::COUNTRY_USA:
+  case DiscIO::Country::COUNTRY_USA:
     strDirectoryName += USA_DIR DIR_SEP;
     break;
-  case DiscIO::IVolume::COUNTRY_UNKNOWN:
+  case DiscIO::Country::COUNTRY_UNKNOWN:
   {
     // The current game's region is not passed down to the EXI device level.
     // Usually, we can retrieve the region from SConfig::GetInstance().m_strUniqueId.
@@ -185,20 +186,20 @@ void CEXIMemoryCard::SetupGciFolder(u16 sizeMb)
     std::string region = memcardFilename.substr(memcardFilename.size() - 7, 3);
     if (region == JAP_DIR)
     {
-      country_code = DiscIO::IVolume::COUNTRY_JAPAN;
+      country_code = DiscIO::Country::COUNTRY_JAPAN;
       ascii = false;
       strDirectoryName += JAP_DIR DIR_SEP;
       break;
     }
     else if (region == USA_DIR)
     {
-      country_code = DiscIO::IVolume::COUNTRY_USA;
+      country_code = DiscIO::Country::COUNTRY_USA;
       strDirectoryName += USA_DIR DIR_SEP;
       break;
     }
   }
   default:
-    country_code = DiscIO::IVolume::COUNTRY_EUROPE;
+    country_code = DiscIO::Country::COUNTRY_EUROPE;
     strDirectoryName += EUR_DIR DIR_SEP;
   }
   strDirectoryName += StringFromFormat("Card %c", 'A' + card_index);

Source/Core/Core/HW/GCMemcardDirectory.cpp

@@ -24,7 +24,7 @@
 const int NO_INDEX = -1;
 static const char* MC_HDR = "MC_SYSTEM_AREA";
 
-int GCMemcardDirectory::LoadGCI(const std::string& fileName, DiscIO::IVolume::ECountry card_region,
+int GCMemcardDirectory::LoadGCI(const std::string& fileName, DiscIO::Country card_region,
                                 bool currentGameOnly)
 {
   File::IOFile gcifile(fileName, "rb");
@@ -39,15 +39,15 @@ int GCMemcardDirectory::LoadGCI(const std::string& fileName, DiscIO::IVolume::EC
       return NO_INDEX;
     }
 
-    DiscIO::IVolume::ECountry gci_region;
+    DiscIO::Country gci_region;
     // check region
     switch (gci.m_gci_header.Gamecode[3])
     {
     case 'J':
-      gci_region = DiscIO::IVolume::COUNTRY_JAPAN;
+      gci_region = DiscIO::Country::COUNTRY_JAPAN;
       break;
     case 'E':
-      gci_region = DiscIO::IVolume::COUNTRY_USA;
+      gci_region = DiscIO::Country::COUNTRY_USA;
       break;
     case 'C':
       // Used by Datel Action Replay Save
@@ -55,7 +55,7 @@ int GCMemcardDirectory::LoadGCI(const std::string& fileName, DiscIO::IVolume::EC
       gci_region = card_region;
       break;
     default:
-      gci_region = DiscIO::IVolume::COUNTRY_EUROPE;
+      gci_region = DiscIO::Country::COUNTRY_EUROPE;
       break;
     }
 
@@ -146,8 +146,7 @@ int GCMemcardDirectory::LoadGCI(const std::string& fileName, DiscIO::IVolume::EC
 }
 
 GCMemcardDirectory::GCMemcardDirectory(const std::string& directory, int slot, u16 sizeMb,
-                                       bool ascii, DiscIO::IVolume::ECountry card_region,
+                                       bool ascii, DiscIO::Country card_region, int gameId)
-                                       int gameId)
     : MemoryCardBase(slot, sizeMb), m_GameId(gameId), m_LastBlock(-1), m_hdr(slot, sizeMb, ascii),
       m_bat1(sizeMb), m_saves(0), m_SaveDirectory(directory), m_exiting(false)
 {

Source/Core/Core/HW/GCMemcardDirectory.h

@@ -14,7 +14,7 @@
 #include "Common/Event.h"
 #include "Common/NonCopyable.h"
 #include "Core/HW/GCMemcard.h"
-#include "DiscIO/Volume.h"
+#include "DiscIO/Enums.h"
 
 // Uncomment this to write the system data of the memorycard from directory to disc
 //#define _WRITE_MC_HEADER 1
@@ -25,8 +25,7 @@ class GCMemcardDirectory : public MemoryCardBase, NonCopyable
 public:
   GCMemcardDirectory(const std::string& directory, int slot = 0, u16 sizeMb = MemCard2043Mb,
                      bool ascii = true,
-                     DiscIO::IVolume::ECountry card_region = DiscIO::IVolume::COUNTRY_EUROPE,
+                     DiscIO::Country card_region = DiscIO::Country::COUNTRY_EUROPE, int gameId = 0);
-                     int gameId = 0);
   ~GCMemcardDirectory();
   void FlushToFile();
   void FlushThread();
@@ -37,8 +36,7 @@ public:
   void DoState(PointerWrap& p) override;
 
 private:
-  int LoadGCI(const std::string& fileName, DiscIO::IVolume::ECountry card_region,
+  int LoadGCI(const std::string& fileName, DiscIO::Country card_region, bool currentGameOnly);
-              bool currentGameOnly);
   inline s32 SaveAreaRW(u32 block, bool writing = false);
   // s32 DirectoryRead(u32 offset, u32 length, u8* destaddress);
   s32 DirectoryWrite(u32 destaddress, u32 length, u8* srcaddress);

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_DI.cpp

@@ -15,6 +15,7 @@
 #include "Core/HW/SystemTimers.h"
 #include "Core/IPC_HLE/WII_IPC_HLE.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_Device_DI.h"
+#include "DiscIO/Volume.h"
 
 CWII_IPC_HLE_Device_di::CWII_IPC_HLE_Device_di(u32 _DeviceID, const std::string& _rDeviceName)
     : IWII_IPC_HLE_Device(_DeviceID, _rDeviceName)

Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_es.cpp

@@ -53,6 +53,7 @@
 #include "Core/PowerPC/PowerPC.h"
 #include "Core/ec_wii.h"
 #include "DiscIO/NANDContentLoader.h"
+#include "DiscIO/Volume.h"
 
 #ifdef _WIN32
 #include <Windows.h>

Source/Core/Core/Movie.cpp

@@ -34,6 +34,7 @@
 #include "Core/NetPlayProto.h"
 #include "Core/PowerPC/PowerPC.h"
 #include "Core/State.h"
+#include "DiscIO/Enums.h"
 #include "InputCommon/GCPadStatus.h"
 #include "VideoCommon/Fifo.h"
 #include "VideoCommon/VideoBackendBase.h"
@@ -82,7 +83,7 @@ static u8 s_bongos, s_memcards;
 static u8 s_revision[20];
 static u32 s_DSPiromHash = 0;
 static u32 s_DSPcoefHash = 0;
-static u8 s_language = 10;  // Set to unknown until language is known
+static u8 s_language = static_cast<u8>(DiscIO::Language::LANGUAGE_UNKNOWN);
 
 static bool s_bRecordingFromSaveState = false;
 static bool s_bPolled = false;

Source/Core/DiscIO/Blob.h

@@ -22,7 +22,7 @@
 
 namespace DiscIO
 {
-// Increment CACHE_REVISION if the enum below is modified (ISOFile.cpp & GameFile.cpp)
+// Increment CACHE_REVISION (ISOFile.cpp & GameFile.cpp) if the enum below is modified
 enum class BlobType
 {
   PLAIN,

Source/Core/DiscIO/CMakeLists.txt

@@ -4,12 +4,13 @@ set(SRCS	Blob.cpp
 			CompressedBlob.cpp
 			DiscScrubber.cpp
 			DriveBlob.cpp
+			Enums.cpp
 			FileBlob.cpp
 			FileMonitor.cpp
 			FileSystemGCWii.cpp
 			Filesystem.cpp
 			NANDContentLoader.cpp
-			VolumeCommon.cpp
+			Volume.cpp
 			VolumeCreator.cpp
 			VolumeDirectory.cpp
 			VolumeGC.cpp

Source/Core/DiscIO/DiscIO.vcxproj

@@ -40,12 +40,13 @@
     <ClCompile Include="CompressedBlob.cpp" />
     <ClCompile Include="DiscScrubber.cpp" />
     <ClCompile Include="DriveBlob.cpp" />
+    <ClCompile Include="Enums.cpp" />
     <ClCompile Include="FileBlob.cpp" />
     <ClCompile Include="FileMonitor.cpp" />
     <ClCompile Include="Filesystem.cpp" />
     <ClCompile Include="FileSystemGCWii.cpp" />
     <ClCompile Include="NANDContentLoader.cpp" />
-    <ClCompile Include="VolumeCommon.cpp" />
+    <ClCompile Include="Volume.cpp" />
     <ClCompile Include="VolumeCreator.cpp" />
     <ClCompile Include="VolumeDirectory.cpp" />
     <ClCompile Include="VolumeGC.cpp" />
@@ -60,6 +61,7 @@
     <ClInclude Include="CompressedBlob.h" />
     <ClInclude Include="DiscScrubber.h" />
     <ClInclude Include="DriveBlob.h" />
+    <ClInclude Include="Enums.h" />
     <ClInclude Include="FileBlob.h" />
     <ClInclude Include="FileMonitor.h" />
     <ClInclude Include="Filesystem.h" />

Source/Core/DiscIO/DiscIO.vcxproj.filters

@@ -54,9 +54,6 @@
     <ClCompile Include="FileMonitor.cpp">
       <Filter>Volume</Filter>
     </ClCompile>
-    <ClCompile Include="VolumeCommon.cpp">
-      <Filter>Volume</Filter>
-    </ClCompile>
     <ClCompile Include="VolumeCreator.cpp">
       <Filter>Volume</Filter>
     </ClCompile>
@@ -72,6 +69,12 @@
     <ClCompile Include="VolumeWiiCrypted.cpp">
       <Filter>Volume</Filter>
     </ClCompile>
+    <ClCompile Include="Enums.cpp">
+      <Filter>Volume</Filter>
+    </ClCompile>
+    <ClCompile Include="Volume.cpp">
+      <Filter>Volume</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DiscScrubber.h">
@@ -128,6 +131,9 @@
     <ClInclude Include="VolumeWiiCrypted.h">
       <Filter>Volume</Filter>
     </ClInclude>
+    <ClInclude Include="Enums.h">
+      <Filter>Volume</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Text Include="CMakeLists.txt" />

Source/Core/DiscIO/Enums.cpp

@@ -1,146 +1,83 @@
-// Copyright 2009 Dolphin Emulator Project
+// Copyright 2016 Dolphin Emulator Project
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <map>
 #include <string>
-#include <utility>
-#include <vector>
 
-#include "Common/ColorUtil.h"
+#include "DiscIO/Enums.h"
-#include "Common/CommonFuncs.h"
 #include "Common/CommonTypes.h"
-#include "Common/FileUtil.h"
 #include "Common/Logging/Log.h"
-#include "Common/StringUtil.h"
-#include "DiscIO/Volume.h"
 
 namespace DiscIO
 {
-static const unsigned int WII_BANNER_WIDTH = 192;
+// Increment CACHE_REVISION (ISOFile.cpp & GameFile.cpp) if the code below is modified
-static const unsigned int WII_BANNER_HEIGHT = 64;
-static const unsigned int WII_BANNER_SIZE = WII_BANNER_WIDTH * WII_BANNER_HEIGHT * 2;
-static const unsigned int WII_BANNER_OFFSET = 0xA0;
 
-std::vector<u32> IVolume::GetWiiBanner(int* width, int* height, u64 title_id)
+Country CountrySwitch(u8 country_code)
-{
-  *width = 0;
-  *height = 0;
-
-  std::string file_name = StringFromFormat("%s/title/%08x/%08x/data/banner.bin",
-                                           File::GetUserPath(D_WIIROOT_IDX).c_str(),
-                                           (u32)(title_id >> 32), (u32)title_id);
-  if (!File::Exists(file_name))
-    return std::vector<u32>();
-
-  if (File::GetSize(file_name) < WII_BANNER_OFFSET + WII_BANNER_SIZE)
-    return std::vector<u32>();
-
-  File::IOFile file(file_name, "rb");
-  if (!file.Seek(WII_BANNER_OFFSET, SEEK_SET))
-    return std::vector<u32>();
-
-  std::vector<u8> banner_file(WII_BANNER_SIZE);
-  if (!file.ReadBytes(banner_file.data(), banner_file.size()))
-    return std::vector<u32>();
-
-  std::vector<u32> image_buffer(WII_BANNER_WIDTH * WII_BANNER_HEIGHT);
-  ColorUtil::decode5A3image(image_buffer.data(), (u16*)banner_file.data(), WII_BANNER_WIDTH,
-                            WII_BANNER_HEIGHT);
-
-  *width = WII_BANNER_WIDTH;
-  *height = WII_BANNER_HEIGHT;
-  return image_buffer;
-}
-
-std::map<IVolume::ELanguage, std::string> IVolume::ReadWiiNames(const std::vector<u8>& data)
-{
-  std::map<IVolume::ELanguage, std::string> names;
-  for (size_t i = 0; i < NUMBER_OF_LANGUAGES; ++i)
-  {
-    size_t name_start = NAME_BYTES_LENGTH * i;
-    size_t name_end = name_start + NAME_BYTES_LENGTH;
-    if (data.size() >= name_end)
-    {
-      u16* temp = (u16*)(data.data() + name_start);
-      std::wstring out_temp(NAME_STRING_LENGTH, '\0');
-      std::transform(temp, temp + out_temp.size(), out_temp.begin(), (u16(&)(u16))Common::swap16);
-      out_temp.erase(std::find(out_temp.begin(), out_temp.end(), 0x00), out_temp.end());
-      std::string name = UTF16ToUTF8(out_temp);
-      if (!name.empty())
-        names[(IVolume::ELanguage)i] = name;
-    }
-  }
-  return names;
-}
-
-// Increment CACHE_REVISION if the code below is modified (ISOFile.cpp & GameFile.cpp)
-IVolume::ECountry CountrySwitch(u8 country_code)
 {
   switch (country_code)
   {
   // Worldwide
   case 'A':
-    return IVolume::COUNTRY_WORLD;
+    return Country::COUNTRY_WORLD;
 
   // PAL
   case 'D':
-    return IVolume::COUNTRY_GERMANY;
+    return Country::COUNTRY_GERMANY;
 
   case 'X':  // Used by a couple PAL games
   case 'Y':  // German, French
   case 'L':  // Japanese import to PAL regions
   case 'M':  // Japanese import to PAL regions
   case 'P':
-    return IVolume::COUNTRY_EUROPE;
+    return Country::COUNTRY_EUROPE;
 
   case 'U':
-    return IVolume::COUNTRY_AUSTRALIA;
+    return Country::COUNTRY_AUSTRALIA;
 
   case 'F':
-    return IVolume::COUNTRY_FRANCE;
+    return Country::COUNTRY_FRANCE;
 
   case 'I':
-    return IVolume::COUNTRY_ITALY;
+    return Country::COUNTRY_ITALY;
 
   case 'H':
-    return IVolume::COUNTRY_NETHERLANDS;
+    return Country::COUNTRY_NETHERLANDS;
 
   case 'R':
-    return IVolume::COUNTRY_RUSSIA;
+    return Country::COUNTRY_RUSSIA;
 
   case 'S':
-    return IVolume::COUNTRY_SPAIN;
+    return Country::COUNTRY_SPAIN;
 
   // NTSC
   case 'E':
   case 'N':  // Japanese import to USA and other NTSC regions
   case 'Z':  // Prince of Persia - The Forgotten Sands (Wii)
   case 'B':  // Ufouria: The Saga (Virtual Console)
-    return IVolume::COUNTRY_USA;
+    return Country::COUNTRY_USA;
 
   case 'J':
-    return IVolume::COUNTRY_JAPAN;
+    return Country::COUNTRY_JAPAN;
 
   case 'K':
   case 'Q':  // Korea with Japanese language
   case 'T':  // Korea with English language
-    return IVolume::COUNTRY_KOREA;
+    return Country::COUNTRY_KOREA;
 
   case 'W':
-    return IVolume::COUNTRY_TAIWAN;
+    return Country::COUNTRY_TAIWAN;
 
   default:
     if (country_code > 'A')  // Silently ignore IOS wads
       WARN_LOG(DISCIO, "Unknown Country Code! %c", country_code);
-    return IVolume::COUNTRY_UNKNOWN;
+    return Country::COUNTRY_UNKNOWN;
   }
 }
 
-u8 GetSysMenuRegion(u16 _TitleVersion)
+u8 GetSysMenuRegion(u16 title_version)
 {
-  switch (_TitleVersion)
+  switch (title_version)
   {
   case 128:
   case 192:

Source/Core/DiscIO/Enums.h

@@ -0,0 +1,62 @@
+// Copyright 2016 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "Common/CommonTypes.h"
+
+namespace DiscIO
+{
+// Increment CACHE_REVISION (ISOFile.cpp & GameFile.cpp) if these enums are modified
+
+enum class Platform
+{
+  GAMECUBE_DISC = 0,
+  WII_DISC,
+  WII_WAD,
+  ELF_DOL,
+  NUMBER_OF_PLATFORMS
+};
+
+enum class Country
+{
+  COUNTRY_EUROPE = 0,
+  COUNTRY_JAPAN,
+  COUNTRY_USA,
+  COUNTRY_AUSTRALIA,
+  COUNTRY_FRANCE,
+  COUNTRY_GERMANY,
+  COUNTRY_ITALY,
+  COUNTRY_KOREA,
+  COUNTRY_NETHERLANDS,
+  COUNTRY_RUSSIA,
+  COUNTRY_SPAIN,
+  COUNTRY_TAIWAN,
+  COUNTRY_WORLD,
+  COUNTRY_UNKNOWN,
+  NUMBER_OF_COUNTRIES
+};
+
+// Languages 0 - 9 match Nintendo's Wii language numbering.
+// Languages 1 - 6 match Nintendo's PAL GameCube languages 0 - 5.
+// NTSC GameCubes only support one language and thus don't number languages.
+enum class Language
+{
+  LANGUAGE_JAPANESE = 0,
+  LANGUAGE_ENGLISH = 1,
+  LANGUAGE_GERMAN = 2,
+  LANGUAGE_FRENCH = 3,
+  LANGUAGE_SPANISH = 4,
+  LANGUAGE_ITALIAN = 5,
+  LANGUAGE_DUTCH = 6,
+  LANGUAGE_SIMPLIFIED_CHINESE = 7,
+  LANGUAGE_TRADITIONAL_CHINESE = 8,
+  LANGUAGE_KOREAN = 9,
+  LANGUAGE_UNKNOWN
+};
+
+Country CountrySwitch(u8 country_code);
+u8 GetSysMenuRegion(u16 title_version);
+std::string GetCompanyFromID(const std::string& company_id);
+}

Source/Core/DiscIO/FileMonitor.cpp

@@ -18,6 +18,7 @@
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/FileMonitor.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
@@ -67,7 +68,7 @@ void ReadFileSystem(const std::string& filename)
   if (!s_open_iso)
     return;
 
-  if (s_open_iso->GetVolumeType() != DiscIO::IVolume::WII_WAD)
+  if (s_open_iso->GetVolumeType() != DiscIO::Platform::WII_WAD)
   {
     s_filesystem = DiscIO::CreateFileSystem(s_open_iso.get());
 

Source/Core/DiscIO/NANDContentLoader.cpp

@@ -23,8 +23,8 @@
 #include "Common/NandPaths.h"
 #include "Common/StringUtil.h"
 
+#include "DiscIO/Enums.h"
 #include "DiscIO/NANDContentLoader.h"
-#include "DiscIO/Volume.h"
 #include "DiscIO/WiiWad.h"
 
 namespace DiscIO
@@ -303,10 +303,10 @@ std::vector<u8> CNANDContentLoader::GetKeyFromTicket(const std::vector<u8>& tick
   return AESDecode(common_key, iv, &ticket[0x01BF], 16);
 }
 
-DiscIO::IVolume::ECountry CNANDContentLoader::GetCountry() const
+DiscIO::Country CNANDContentLoader::GetCountry() const
 {
   if (!IsValid())
-    return DiscIO::IVolume::COUNTRY_UNKNOWN;
+    return DiscIO::Country::COUNTRY_UNKNOWN;
 
   return CountrySwitch(m_Country);
 }

Source/Core/DiscIO/NANDContentLoader.h

@@ -5,13 +5,18 @@
 #pragma once
 
 #include <cstddef>
+#include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "Common/CommonTypes.h"
 #include "Common/NandPaths.h"
-#include "DiscIO/Volume.h"
+
+namespace DiscIO
+{
+enum class Country;
+}
 
 namespace DiscIO
 {
@@ -86,7 +91,7 @@ public:
   const std::vector<SNANDContent>& GetContent() const { return m_Content; }
   u16 GetTitleVersion() const { return m_TitleVersion; }
   u16 GetNumEntries() const { return m_NumEntries; }
-  DiscIO::IVolume::ECountry GetCountry() const;
+  DiscIO::Country GetCountry() const;
   u8 GetCountryChar() const { return m_Country; }
   enum
   {

Source/Core/DiscIO/Volume.cpp

@@ -0,0 +1,77 @@
+// Copyright 2009 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "Common/ColorUtil.h"
+#include "Common/CommonFuncs.h"
+#include "Common/CommonTypes.h"
+#include "Common/FileUtil.h"
+#include "Common/StringUtil.h"
+#include "DiscIO/Enums.h"
+#include "DiscIO/Volume.h"
+
+namespace DiscIO
+{
+static const unsigned int WII_BANNER_WIDTH = 192;
+static const unsigned int WII_BANNER_HEIGHT = 64;
+static const unsigned int WII_BANNER_SIZE = WII_BANNER_WIDTH * WII_BANNER_HEIGHT * 2;
+static const unsigned int WII_BANNER_OFFSET = 0xA0;
+
+std::vector<u32> IVolume::GetWiiBanner(int* width, int* height, u64 title_id)
+{
+  *width = 0;
+  *height = 0;
+
+  std::string file_name = StringFromFormat("%s/title/%08x/%08x/data/banner.bin",
+                                           File::GetUserPath(D_WIIROOT_IDX).c_str(),
+                                           (u32)(title_id >> 32), (u32)title_id);
+  if (!File::Exists(file_name))
+    return std::vector<u32>();
+
+  if (File::GetSize(file_name) < WII_BANNER_OFFSET + WII_BANNER_SIZE)
+    return std::vector<u32>();
+
+  File::IOFile file(file_name, "rb");
+  if (!file.Seek(WII_BANNER_OFFSET, SEEK_SET))
+    return std::vector<u32>();
+
+  std::vector<u8> banner_file(WII_BANNER_SIZE);
+  if (!file.ReadBytes(banner_file.data(), banner_file.size()))
+    return std::vector<u32>();
+
+  std::vector<u32> image_buffer(WII_BANNER_WIDTH * WII_BANNER_HEIGHT);
+  ColorUtil::decode5A3image(image_buffer.data(), (u16*)banner_file.data(), WII_BANNER_WIDTH,
+                            WII_BANNER_HEIGHT);
+
+  *width = WII_BANNER_WIDTH;
+  *height = WII_BANNER_HEIGHT;
+  return image_buffer;
+}
+
+std::map<Language, std::string> IVolume::ReadWiiNames(const std::vector<u8>& data)
+{
+  std::map<Language, std::string> names;
+  for (size_t i = 0; i < NUMBER_OF_LANGUAGES; ++i)
+  {
+    size_t name_start = NAME_BYTES_LENGTH * i;
+    size_t name_end = name_start + NAME_BYTES_LENGTH;
+    if (data.size() >= name_end)
+    {
+      u16* temp = (u16*)(data.data() + name_start);
+      std::wstring out_temp(NAME_STRING_LENGTH, '\0');
+      std::transform(temp, temp + out_temp.size(), out_temp.begin(), (u16(&)(u16))Common::swap16);
+      out_temp.erase(std::find(out_temp.begin(), out_temp.end(), 0x00), out_temp.end());
+      std::string name = UTF16ToUTF8(out_temp);
+      if (!name.empty())
+        names[static_cast<Language>(i)] = name;
+    }
+  }
+  return names;
+}
+}

Source/Core/DiscIO/Volume.h

@@ -12,59 +12,15 @@
 #include "Common/CommonFuncs.h"
 #include "Common/CommonTypes.h"
 #include "Common/StringUtil.h"
-#include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 
 namespace DiscIO
 {
+enum class BlobType;
+
 class IVolume
 {
 public:
-  // Increment CACHE_REVISION if the enums below are modified (ISOFile.cpp & GameFile.cpp)
-  enum EPlatform
-  {
-    GAMECUBE_DISC = 0,
-    WII_DISC,
-    WII_WAD,
-    ELF_DOL,
-    NUMBER_OF_PLATFORMS
-  };
-
-  enum ECountry
-  {
-    COUNTRY_EUROPE = 0,
-    COUNTRY_JAPAN,
-    COUNTRY_USA,
-    COUNTRY_AUSTRALIA,
-    COUNTRY_FRANCE,
-    COUNTRY_GERMANY,
-    COUNTRY_ITALY,
-    COUNTRY_KOREA,
-    COUNTRY_NETHERLANDS,
-    COUNTRY_RUSSIA,
-    COUNTRY_SPAIN,
-    COUNTRY_TAIWAN,
-    COUNTRY_WORLD,
-    COUNTRY_UNKNOWN,
-    NUMBER_OF_COUNTRIES
-  };
-
-  // Languages 0 - 9 match the official Wii language numbering.
-  // Languages 1 - 6 match the official GC PAL languages 0 - 5.
-  enum ELanguage
-  {
-    LANGUAGE_JAPANESE = 0,
-    LANGUAGE_ENGLISH = 1,
-    LANGUAGE_GERMAN = 2,
-    LANGUAGE_FRENCH = 3,
-    LANGUAGE_SPANISH = 4,
-    LANGUAGE_ITALIAN = 5,
-    LANGUAGE_DUTCH = 6,
-    LANGUAGE_SIMPLIFIED_CHINESE = 7,
-    LANGUAGE_TRADITIONAL_CHINESE = 8,
-    LANGUAGE_KOREAN = 9,
-    LANGUAGE_UNKNOWN
-  };
-
   IVolume() {}
   virtual ~IVolume() {}
   // decrypt parameter must be false if not reading a Wii disc
@@ -85,36 +41,21 @@ public:
   virtual std::string GetMakerID() const = 0;
   virtual u16 GetRevision() const = 0;
   virtual std::string GetInternalName() const = 0;
-  virtual std::map<ELanguage, std::string> GetShortNames() const
+  virtual std::map<Language, std::string> GetShortNames() const { return {{}}; }
-  {
+  virtual std::map<Language, std::string> GetLongNames() const { return {{}}; }
-    return std::map<ELanguage, std::string>();
+  virtual std::map<Language, std::string> GetShortMakers() const { return {{}}; }
-  }
+  virtual std::map<Language, std::string> GetLongMakers() const { return {{}}; }
-  virtual std::map<ELanguage, std::string> GetLongNames() const
+  virtual std::map<Language, std::string> GetDescriptions() const { return {{}}; }
-  {
-    return std::map<ELanguage, std::string>();
-  }
-  virtual std::map<ELanguage, std::string> GetShortMakers() const
-  {
-    return std::map<ELanguage, std::string>();
-  }
-  virtual std::map<ELanguage, std::string> GetLongMakers() const
-  {
-    return std::map<ELanguage, std::string>();
-  }
-  virtual std::map<ELanguage, std::string> GetDescriptions() const
-  {
-    return std::map<ELanguage, std::string>();
-  }
   virtual std::vector<u32> GetBanner(int* width, int* height) const = 0;
   virtual u64 GetFSTSize() const = 0;
   virtual std::string GetApploaderDate() const = 0;
   // 0 is the first disc, 1 is the second disc
   virtual u8 GetDiscNumber() const { return 0; }
-  virtual EPlatform GetVolumeType() const = 0;
+  virtual Platform GetVolumeType() const = 0;
   virtual bool SupportsIntegrityCheck() const { return false; }
   virtual bool CheckIntegrity() const { return false; }
   virtual bool ChangePartition(u64 offset) { return false; }
-  virtual ECountry GetCountry() const = 0;
+  virtual Country GetCountry() const = 0;
   virtual BlobType GetBlobType() const = 0;
   // Size of virtual disc (not always accurate)
   virtual u64 GetSize() const = 0;
@@ -132,7 +73,8 @@ protected:
 
     // There doesn't seem to be any GC discs with the country set to Taiwan...
     // But maybe they would use Shift_JIS if they existed? Not sure
-    bool use_shift_jis = (COUNTRY_JAPAN == GetCountry() || COUNTRY_TAIWAN == GetCountry());
+    bool use_shift_jis =
+        (Country::COUNTRY_JAPAN == GetCountry() || Country::COUNTRY_TAIWAN == GetCountry());
 
     if (use_shift_jis)
       return SHIFTJISToUTF8(string);
@@ -140,7 +82,7 @@ protected:
       return CP1252ToUTF8(string);
   }
 
-  static std::map<IVolume::ELanguage, std::string> ReadWiiNames(const std::vector<u8>& data);
+  static std::map<Language, std::string> ReadWiiNames(const std::vector<u8>& data);
 
   static const size_t NUMBER_OF_LANGUAGES = 10;
   static const size_t NAME_STRING_LENGTH = 42;
@@ -148,9 +90,4 @@ protected:
   static const size_t NAMES_TOTAL_BYTES = NAME_BYTES_LENGTH * NUMBER_OF_LANGUAGES;
 };
 
-// Generic Switch function for all volumes
-IVolume::ECountry CountrySwitch(u8 country_code);
-u8 GetSysMenuRegion(u16 _TitleVersion);
-std::string GetCompanyFromID(const std::string& company_id);
-
 }  // namespace

Source/Core/DiscIO/VolumeDirectory.cpp

@@ -17,6 +17,7 @@
 #include "Common/Logging/Log.h"
 #include "Common/MathUtil.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/FileMonitor.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeDirectory.h"
@@ -163,7 +164,7 @@ void CVolumeDirectory::SetUniqueID(const std::string& id)
   memcpy(m_diskHeader.data(), id.c_str(), std::min(id.length(), MAX_ID_LENGTH));
 }
 
-IVolume::ECountry CVolumeDirectory::GetCountry() const
+Country CVolumeDirectory::GetCountry() const
 {
   return CountrySwitch(m_diskHeader[3]);
 }
@@ -183,12 +184,12 @@ std::string CVolumeDirectory::GetInternalName() const
     return "";
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeDirectory::GetLongNames() const
+std::map<Language, std::string> CVolumeDirectory::GetLongNames() const
 {
   std::string name = GetInternalName();
   if (name.empty())
     return {{}};
-  return {{IVolume::LANGUAGE_UNKNOWN, name}};
+  return {{Language::LANGUAGE_UNKNOWN, name}};
 }
 
 std::vector<u32> CVolumeDirectory::GetBanner(int* width, int* height) const
@@ -218,9 +219,9 @@ std::string CVolumeDirectory::GetApploaderDate() const
   return "VOID";
 }
 
-IVolume::EPlatform CVolumeDirectory::GetVolumeType() const
+Platform CVolumeDirectory::GetVolumeType() const
 {
-  return m_is_wii ? WII_DISC : GAMECUBE_DISC;
+  return m_is_wii ? Platform::WII_DISC : Platform::GAMECUBE_DISC;
 }
 
 BlobType CVolumeDirectory::GetBlobType() const

Source/Core/DiscIO/VolumeDirectory.h

@@ -10,7 +10,6 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
-#include "DiscIO/Blob.h"
 #include "DiscIO/Volume.h"
 
 namespace File
@@ -24,6 +23,11 @@ struct FSTEntry;
 
 namespace DiscIO
 {
+enum class BlobType;
+enum class Country;
+enum class Language;
+enum class Platform;
+
 class CVolumeDirectory : public IVolume
 {
 public:
@@ -43,16 +47,16 @@ public:
 
   u16 GetRevision() const override { return 0; }
   std::string GetInternalName() const override;
-  std::map<IVolume::ELanguage, std::string> GetLongNames() const override;
+  std::map<Language, std::string> GetLongNames() const override;
   std::vector<u32> GetBanner(int* width, int* height) const override;
   void SetName(const std::string&);
 
   u64 GetFSTSize() const override;
 
   std::string GetApploaderDate() const override;
-  EPlatform GetVolumeType() const override;
+  Platform GetVolumeType() const override;
 
-  ECountry GetCountry() const override;
+  Country GetCountry() const override;
 
   BlobType GetBlobType() const override;
   u64 GetSize() const override;

Source/Core/DiscIO/VolumeGC.cpp

@@ -15,6 +15,7 @@
 #include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/FileMonitor.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
@@ -60,10 +61,10 @@ std::string CVolumeGC::GetUniqueID() const
   return DecodeString(ID);
 }
 
-IVolume::ECountry CVolumeGC::GetCountry() const
+Country CVolumeGC::GetCountry() const
 {
   if (!m_pReader)
-    return COUNTRY_UNKNOWN;
+    return Country::COUNTRY_UNKNOWN;
 
   u8 country_code;
   m_pReader->Read(3, 1, &country_code);
@@ -104,31 +105,31 @@ std::string CVolumeGC::GetInternalName() const
   return "";
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeGC::GetShortNames() const
+std::map<Language, std::string> CVolumeGC::GetShortNames() const
 {
   LoadBannerFile();
   return m_short_names;
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeGC::GetLongNames() const
+std::map<Language, std::string> CVolumeGC::GetLongNames() const
 {
   LoadBannerFile();
   return m_long_names;
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeGC::GetShortMakers() const
+std::map<Language, std::string> CVolumeGC::GetShortMakers() const
 {
   LoadBannerFile();
   return m_short_makers;
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeGC::GetLongMakers() const
+std::map<Language, std::string> CVolumeGC::GetLongMakers() const
 {
   LoadBannerFile();
   return m_long_makers;
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeGC::GetDescriptions() const
+std::map<Language, std::string> CVolumeGC::GetDescriptions() const
 {
   LoadBannerFile();
   return m_descriptions;
@@ -194,9 +195,9 @@ u8 CVolumeGC::GetDiscNumber() const
   return disc_number;
 }
 
-IVolume::EPlatform CVolumeGC::GetVolumeType() const
+Platform CVolumeGC::GetVolumeType() const
 {
-  return GAMECUBE_DISC;
+  return Platform::GAMECUBE_DISC;
 }
 
 void CVolumeGC::LoadBannerFile() const
@@ -241,18 +242,18 @@ void CVolumeGC::LoadBannerFile() const
 void CVolumeGC::ExtractBannerInformation(const GCBanner& banner_file, bool is_bnr1) const
 {
   u32 number_of_languages = 0;
-  ELanguage start_language = LANGUAGE_UNKNOWN;
+  Language start_language = Language::LANGUAGE_UNKNOWN;
-  bool is_japanese = GetCountry() == ECountry::COUNTRY_JAPAN;
 
   if (is_bnr1)  // NTSC
   {
+    bool is_japanese = GetCountry() == Country::COUNTRY_JAPAN;
     number_of_languages = 1;
-    start_language = is_japanese ? ELanguage::LANGUAGE_JAPANESE : ELanguage::LANGUAGE_ENGLISH;
+    start_language = is_japanese ? Language::LANGUAGE_JAPANESE : Language::LANGUAGE_ENGLISH;
   }
   else  // PAL
   {
     number_of_languages = 6;
-    start_language = ELanguage::LANGUAGE_ENGLISH;
+    start_language = Language::LANGUAGE_ENGLISH;
   }
 
   m_image_width = GC_BANNER_WIDTH;
@@ -264,7 +265,7 @@ void CVolumeGC::ExtractBannerInformation(const GCBanner& banner_file, bool is_bn
   for (u32 i = 0; i < number_of_languages; ++i)
   {
     const GCBannerInformation& info = banner_file.information[i];
-    ELanguage language = static_cast<ELanguage>(start_language + i);
+    Language language = static_cast<Language>(static_cast<int>(start_language) + i);
 
     std::string description = DecodeString(info.description);
     if (!description.empty())

Source/Core/DiscIO/VolumeGC.h

@@ -10,13 +10,17 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
-#include "DiscIO/Blob.h"
 #include "DiscIO/Volume.h"
 
 // --- this volume type is used for GC disc images ---
 
 namespace DiscIO
 {
+enum class BlobType;
+enum class Country;
+enum class Language;
+enum class Platform;
+
 class CVolumeGC : public IVolume
 {
 public:
@@ -27,18 +31,18 @@ public:
   std::string GetMakerID() const override;
   u16 GetRevision() const override;
   std::string GetInternalName() const override;
-  std::map<ELanguage, std::string> GetShortNames() const override;
+  std::map<Language, std::string> GetShortNames() const override;
-  std::map<ELanguage, std::string> GetLongNames() const override;
+  std::map<Language, std::string> GetLongNames() const override;
-  std::map<ELanguage, std::string> GetShortMakers() const override;
+  std::map<Language, std::string> GetShortMakers() const override;
-  std::map<ELanguage, std::string> GetLongMakers() const override;
+  std::map<Language, std::string> GetLongMakers() const override;
-  std::map<ELanguage, std::string> GetDescriptions() const override;
+  std::map<Language, std::string> GetDescriptions() const override;
   std::vector<u32> GetBanner(int* width, int* height) const override;
   u64 GetFSTSize() const override;
   std::string GetApploaderDate() const override;
   u8 GetDiscNumber() const override;
 
-  EPlatform GetVolumeType() const override;
+  Platform GetVolumeType() const override;
-  ECountry GetCountry() const override;
+  Country GetCountry() const override;
   BlobType GetBlobType() const override;
   u64 GetSize() const override;
   u64 GetRawSize() const override;
@@ -73,12 +77,12 @@ private:
   static const size_t BNR1_SIZE = sizeof(GCBanner) - sizeof(GCBannerInformation) * 5;
   static const size_t BNR2_SIZE = sizeof(GCBanner);
 
-  mutable std::map<ELanguage, std::string> m_short_names;
+  mutable std::map<Language, std::string> m_short_names;
 
-  mutable std::map<ELanguage, std::string> m_long_names;
+  mutable std::map<Language, std::string> m_long_names;
-  mutable std::map<ELanguage, std::string> m_short_makers;
+  mutable std::map<Language, std::string> m_short_makers;
-  mutable std::map<ELanguage, std::string> m_long_makers;
+  mutable std::map<Language, std::string> m_long_makers;
-  mutable std::map<ELanguage, std::string> m_descriptions;
+  mutable std::map<Language, std::string> m_descriptions;
 
   mutable bool m_banner_loaded = false;
   mutable std::vector<u32> m_image_buffer;

Source/Core/DiscIO/VolumeWad.cpp

@@ -16,6 +16,7 @@
 #include "Common/MsgHandler.h"
 #include "Common/StringUtil.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeWad.h"
 
@@ -54,10 +55,10 @@ bool CVolumeWAD::Read(u64 _Offset, u64 _Length, u8* _pBuffer, bool decrypt) cons
   return m_pReader->Read(_Offset, _Length, _pBuffer);
 }
 
-IVolume::ECountry CVolumeWAD::GetCountry() const
+Country CVolumeWAD::GetCountry() const
 {
   if (!m_pReader)
-    return COUNTRY_UNKNOWN;
+    return Country::COUNTRY_UNKNOWN;
 
   // read the last digit of the titleID in the ticket
   u8 country_code;
@@ -114,16 +115,16 @@ u16 CVolumeWAD::GetRevision() const
   return Common::swap16(revision);
 }
 
-IVolume::EPlatform CVolumeWAD::GetVolumeType() const
+Platform CVolumeWAD::GetVolumeType() const
 {
-  return WII_WAD;
+  return Platform::WII_WAD;
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeWAD::GetLongNames() const
+std::map<Language, std::string> CVolumeWAD::GetLongNames() const
 {
   std::vector<u8> name_data(NAMES_TOTAL_BYTES);
   if (!Read(m_opening_bnr_offset + 0x9C, NAMES_TOTAL_BYTES, name_data.data()))
-    return std::map<IVolume::ELanguage, std::string>();
+    return std::map<Language, std::string>();
   return ReadWiiNames(name_data);
 }
 

Source/Core/DiscIO/VolumeWad.h

@@ -10,7 +10,6 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
-#include "DiscIO/Blob.h"
 #include "DiscIO/Volume.h"
 
 // --- this volume type is used for Wad files ---
@@ -19,6 +18,11 @@
 
 namespace DiscIO
 {
+enum class BlobType;
+enum class Country;
+enum class Language;
+enum class Platform;
+
 class CVolumeWAD : public IVolume
 {
 public:
@@ -30,12 +34,12 @@ public:
   std::string GetMakerID() const override;
   u16 GetRevision() const override;
   std::string GetInternalName() const override { return ""; }
-  std::map<IVolume::ELanguage, std::string> GetLongNames() const override;
+  std::map<Language, std::string> GetLongNames() const override;
   std::vector<u32> GetBanner(int* width, int* height) const override;
   u64 GetFSTSize() const override { return 0; }
   std::string GetApploaderDate() const override { return ""; }
-  EPlatform GetVolumeType() const override;
+  Platform GetVolumeType() const override;
-  ECountry GetCountry() const override;
+  Country GetCountry() const override;
 
   BlobType GetBlobType() const override;
   u64 GetSize() const override;

Source/Core/DiscIO/VolumeWiiCrypted.cpp

@@ -17,6 +17,7 @@
 #include "Common/Logging/Log.h"
 #include "Common/MsgHandler.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/FileMonitor.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
@@ -152,53 +153,49 @@ std::string CVolumeWiiCrypted::GetUniqueID() const
   return DecodeString(ID);
 }
 
-IVolume::ECountry CVolumeWiiCrypted::GetCountry() const
+Country CVolumeWiiCrypted::GetCountry() const
 {
   if (!m_pReader)
-    return COUNTRY_UNKNOWN;
+    return Country::COUNTRY_UNKNOWN;
 
   u8 country_byte;
   if (!m_pReader->Read(3, 1, &country_byte))
-  {
+    return Country::COUNTRY_UNKNOWN;
-    return COUNTRY_UNKNOWN;
-  }
 
-  IVolume::ECountry country_value = CountrySwitch(country_byte);
+  Country country_value = CountrySwitch(country_byte);
 
   u32 region_code;
   if (!ReadSwapped(0x4E000, &region_code, false))
-  {
     return country_value;
-  }
 
   switch (region_code)
   {
   case 0:
     switch (country_value)
     {
-    case IVolume::COUNTRY_TAIWAN:
+    case Country::COUNTRY_TAIWAN:
-      return IVolume::COUNTRY_TAIWAN;
+      return Country::COUNTRY_TAIWAN;
     default:
-      return IVolume::COUNTRY_JAPAN;
+      return Country::COUNTRY_JAPAN;
     }
   case 1:
-    return IVolume::COUNTRY_USA;
+    return Country::COUNTRY_USA;
   case 2:
     switch (country_value)
     {
-    case IVolume::COUNTRY_FRANCE:
+    case Country::COUNTRY_FRANCE:
-    case IVolume::COUNTRY_GERMANY:
+    case Country::COUNTRY_GERMANY:
-    case IVolume::COUNTRY_ITALY:
+    case Country::COUNTRY_ITALY:
-    case IVolume::COUNTRY_NETHERLANDS:
+    case Country::COUNTRY_NETHERLANDS:
-    case IVolume::COUNTRY_RUSSIA:
+    case Country::COUNTRY_RUSSIA:
-    case IVolume::COUNTRY_SPAIN:
+    case Country::COUNTRY_SPAIN:
-    case IVolume::COUNTRY_AUSTRALIA:
+    case Country::COUNTRY_AUSTRALIA:
       return country_value;
     default:
-      return IVolume::COUNTRY_EUROPE;
+      return Country::COUNTRY_EUROPE;
     }
   case 4:
-    return IVolume::COUNTRY_KOREA;
+    return Country::COUNTRY_KOREA;
   default:
     return country_value;
   }
@@ -238,12 +235,12 @@ std::string CVolumeWiiCrypted::GetInternalName() const
   return "";
 }
 
-std::map<IVolume::ELanguage, std::string> CVolumeWiiCrypted::GetLongNames() const
+std::map<Language, std::string> CVolumeWiiCrypted::GetLongNames() const
 {
   std::unique_ptr<IFileSystem> file_system(CreateFileSystem(this));
   std::vector<u8> opening_bnr(NAMES_TOTAL_BYTES);
-  opening_bnr.resize(
+  size_t size = file_system->ReadFile("opening.bnr", opening_bnr.data(), opening_bnr.size(), 0x5C);
-      file_system->ReadFile("opening.bnr", opening_bnr.data(), opening_bnr.size(), 0x5C));
+  opening_bnr.resize(size);
   return ReadWiiNames(opening_bnr);
 }
 
@@ -285,9 +282,9 @@ std::string CVolumeWiiCrypted::GetApploaderDate() const
   return DecodeString(date);
 }
 
-IVolume::EPlatform CVolumeWiiCrypted::GetVolumeType() const
+Platform CVolumeWiiCrypted::GetVolumeType() const
 {
-  return WII_DISC;
+  return Platform::WII_DISC;
 }
 
 u8 CVolumeWiiCrypted::GetDiscNumber() const

Source/Core/DiscIO/VolumeWiiCrypted.h

@@ -11,13 +11,17 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
-#include "DiscIO/Blob.h"
 #include "DiscIO/Volume.h"
 
 // --- this volume type is used for encrypted Wii images ---
 
 namespace DiscIO
 {
+enum class BlobType;
+enum class Country;
+enum class Language;
+enum class Platform;
+
 class CVolumeWiiCrypted : public IVolume
 {
 public:
@@ -31,18 +35,18 @@ public:
   std::string GetMakerID() const override;
   u16 GetRevision() const override;
   std::string GetInternalName() const override;
-  std::map<IVolume::ELanguage, std::string> GetLongNames() const override;
+  std::map<Language, std::string> GetLongNames() const override;
   std::vector<u32> GetBanner(int* width, int* height) const override;
   u64 GetFSTSize() const override;
   std::string GetApploaderDate() const override;
   u8 GetDiscNumber() const override;
 
-  EPlatform GetVolumeType() const override;
+  Platform GetVolumeType() const override;
   bool SupportsIntegrityCheck() const override { return true; }
   bool CheckIntegrity() const override;
   bool ChangePartition(u64 offset) override;
 
-  ECountry GetCountry() const override;
+  Country GetCountry() const override;
   BlobType GetBlobType() const override;
   u64 GetSize() const override;
   u64 GetRawSize() const override;

Source/Core/DolphinQt2/Config/InfoWidget.cpp

@@ -13,6 +13,8 @@
 #include <QPushButton>
 #include <QTextEdit>
 
+#include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DolphinQt2/Config/InfoWidget.h"
 
 InfoWidget::InfoWidget(const GameFile& game) : m_game(game)
@@ -71,7 +73,7 @@ QGroupBox* InfoWidget::CreateBannerDetails()
   CreateLanguageSelector();
 
   layout->addRow(tr("Show Language:"), m_language_selector);
-  if (m_game.GetPlatformID() == DiscIO::IVolume::GAMECUBE_DISC)
+  if (m_game.GetPlatformID() == DiscIO::Platform::GAMECUBE_DISC)
   {
     layout->addRow(tr("Short Name:"), m_short_name);
     layout->addRow(tr("Short Maker:"), m_short_maker);
@@ -79,7 +81,7 @@ QGroupBox* InfoWidget::CreateBannerDetails()
     layout->addRow(tr("Long Maker:"), m_long_maker);
     layout->addRow(tr("Description:"), m_description);
   }
-  else if (m_game.GetPlatformID() == DiscIO::IVolume::WII_DISC)
+  else if (m_game.GetPlatformID() == DiscIO::Platform::WII_DISC)
   {
     layout->addRow(tr("Name:"), m_long_name);
   }
@@ -123,11 +125,11 @@ QLineEdit* InfoWidget::CreateValueDisplay(const QString& value)
 void InfoWidget::CreateLanguageSelector()
 {
   m_language_selector = new QComboBox();
-  QList<DiscIO::IVolume::ELanguage> languages = m_game.GetAvailableLanguages();
+  QList<DiscIO::Language> languages = m_game.GetAvailableLanguages();
   for (int i = 0; i < languages.count(); i++)
   {
-    DiscIO::IVolume::ELanguage language = languages.at(i);
+    DiscIO::Language language = languages.at(i);
-    m_language_selector->addItem(m_game.GetLanguage(language), language);
+    m_language_selector->addItem(m_game.GetLanguage(language), static_cast<int>(language));
   }
   if (m_language_selector->count() == 1)
     m_language_selector->setDisabled(true);
@@ -137,8 +139,8 @@ void InfoWidget::CreateLanguageSelector()
 
 void InfoWidget::ChangeLanguage()
 {
-  DiscIO::IVolume::ELanguage language =
+  DiscIO::Language language =
-      static_cast<DiscIO::IVolume::ELanguage>(m_language_selector->currentData().toInt());
+      static_cast<DiscIO::Language>(m_language_selector->currentData().toInt());
   m_short_name->setText(m_game.GetShortName(language));
   m_short_maker->setText(m_game.GetShortMaker(language));
   m_long_name->setText(m_game.GetLongName(language));

Source/Core/DolphinQt2/GameList/GameFile.cpp

@@ -10,6 +10,9 @@
 
 #include "Common/FileUtil.h"
 #include "Core/ConfigManager.h"
+#include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
+#include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 #include "DolphinQt2/GameList/GameFile.h"
 #include "DolphinQt2/Resources.h"
@@ -18,15 +21,15 @@
 static const int CACHE_VERSION = 13;  // Last changed in PR #3261
 static const int DATASTREAM_VERSION = QDataStream::Qt_5_5;
 
-QList<DiscIO::IVolume::ELanguage> GameFile::GetAvailableLanguages() const
+QList<DiscIO::Language> GameFile::GetAvailableLanguages() const
 {
   return m_long_names.keys();
 }
 
-static QMap<DiscIO::IVolume::ELanguage, QString>
+static QMap<DiscIO::Language, QString>
-ConvertLanguageMap(const std::map<DiscIO::IVolume::ELanguage, std::string>& map)
+ConvertLanguageMap(const std::map<DiscIO::Language, std::string>& map)
 {
-  QMap<DiscIO::IVolume::ELanguage, QString> result;
+  QMap<DiscIO::Language, QString> result;
   for (auto entry : map)
     result.insert(entry.first, QString::fromStdString(entry.second).trimmed());
   return result;
@@ -169,9 +172,9 @@ bool GameFile::TryLoadElfDol()
     return false;
 
   m_revision = 0;
-  m_long_names[DiscIO::IVolume::LANGUAGE_ENGLISH] = m_file_name;
+  m_long_names[DiscIO::Language::LANGUAGE_ENGLISH] = m_file_name;
-  m_platform = DiscIO::IVolume::ELF_DOL;
+  m_platform = DiscIO::Platform::ELF_DOL;
-  m_country = DiscIO::IVolume::COUNTRY_UNKNOWN;
+  m_country = DiscIO::Country::COUNTRY_UNKNOWN;
   m_blob_type = DiscIO::BlobType::DIRECTORY;
   m_raw_size = m_size;
   m_banner = Resources::GetMisc(Resources::BANNER_MISSING);
@@ -185,14 +188,14 @@ void GameFile::SaveCache()
   // TODO
 }
 
-QString GameFile::GetBannerString(const QMap<DiscIO::IVolume::ELanguage, QString>& m) const
+QString GameFile::GetBannerString(const QMap<DiscIO::Language, QString>& m) const
 {
   // Try the settings language, then English, then just pick one.
   if (m.isEmpty())
     return QString();
 
-  bool wii = m_platform != DiscIO::IVolume::GAMECUBE_DISC;
+  bool wii = m_platform != DiscIO::Platform::GAMECUBE_DISC;
-  DiscIO::IVolume::ELanguage current_lang;
+  DiscIO::Language current_lang;
   if (wii)
     current_lang = Settings().GetWiiSystemLanguage();
   else
@@ -200,8 +203,8 @@ QString GameFile::GetBannerString(const QMap<DiscIO::IVolume::ELanguage, QString
 
   if (m.contains(current_lang))
     return m[current_lang];
-  if (m.contains(DiscIO::IVolume::LANGUAGE_ENGLISH))
+  if (m.contains(DiscIO::Language::LANGUAGE_ENGLISH))
-    return m[DiscIO::IVolume::LANGUAGE_ENGLISH];
+    return m[DiscIO::Language::LANGUAGE_ENGLISH];
   return m.first();
 }
 
@@ -209,13 +212,13 @@ QString GameFile::GetPlatform() const
 {
   switch (m_platform)
   {
-  case DiscIO::IVolume::GAMECUBE_DISC:
+  case DiscIO::Platform::GAMECUBE_DISC:
     return QObject::tr("GameCube");
-  case DiscIO::IVolume::WII_DISC:
+  case DiscIO::Platform::WII_DISC:
     return QObject::tr("Wii");
-  case DiscIO::IVolume::WII_WAD:
+  case DiscIO::Platform::WII_WAD:
     return QObject::tr("Wii Channel");
-  case DiscIO::IVolume::ELF_DOL:
+  case DiscIO::Platform::ELF_DOL:
     return QObject::tr("ELF/DOL");
   default:
     return QObject::tr("Unknown");
@@ -226,60 +229,60 @@ QString GameFile::GetCountry() const
 {
   switch (m_country)
   {
-  case DiscIO::IVolume::COUNTRY_EUROPE:
+  case DiscIO::Country::COUNTRY_EUROPE:
     return QObject::tr("Europe");
-  case DiscIO::IVolume::COUNTRY_JAPAN:
+  case DiscIO::Country::COUNTRY_JAPAN:
     return QObject::tr("Japan");
-  case DiscIO::IVolume::COUNTRY_USA:
+  case DiscIO::Country::COUNTRY_USA:
     return QObject::tr("USA");
-  case DiscIO::IVolume::COUNTRY_AUSTRALIA:
+  case DiscIO::Country::COUNTRY_AUSTRALIA:
     return QObject::tr("Australia");
-  case DiscIO::IVolume::COUNTRY_FRANCE:
+  case DiscIO::Country::COUNTRY_FRANCE:
     return QObject::tr("France");
-  case DiscIO::IVolume::COUNTRY_GERMANY:
+  case DiscIO::Country::COUNTRY_GERMANY:
     return QObject::tr("Germany");
-  case DiscIO::IVolume::COUNTRY_ITALY:
+  case DiscIO::Country::COUNTRY_ITALY:
     return QObject::tr("Italy");
-  case DiscIO::IVolume::COUNTRY_KOREA:
+  case DiscIO::Country::COUNTRY_KOREA:
     return QObject::tr("Korea");
-  case DiscIO::IVolume::COUNTRY_NETHERLANDS:
+  case DiscIO::Country::COUNTRY_NETHERLANDS:
     return QObject::tr("Netherlands");
-  case DiscIO::IVolume::COUNTRY_RUSSIA:
+  case DiscIO::Country::COUNTRY_RUSSIA:
     return QObject::tr("Russia");
-  case DiscIO::IVolume::COUNTRY_SPAIN:
+  case DiscIO::Country::COUNTRY_SPAIN:
     return QObject::tr("Spain");
-  case DiscIO::IVolume::COUNTRY_TAIWAN:
+  case DiscIO::Country::COUNTRY_TAIWAN:
     return QObject::tr("Taiwan");
-  case DiscIO::IVolume::COUNTRY_WORLD:
+  case DiscIO::Country::COUNTRY_WORLD:
     return QObject::tr("World");
   default:
     return QObject::tr("Unknown");
   }
 }
 
-QString GameFile::GetLanguage(DiscIO::IVolume::ELanguage lang) const
+QString GameFile::GetLanguage(DiscIO::Language lang) const
 {
   switch (lang)
   {
-  case DiscIO::IVolume::LANGUAGE_JAPANESE:
+  case DiscIO::Language::LANGUAGE_JAPANESE:
     return QObject::tr("Japanese");
-  case DiscIO::IVolume::LANGUAGE_ENGLISH:
+  case DiscIO::Language::LANGUAGE_ENGLISH:
     return QObject::tr("English");
-  case DiscIO::IVolume::LANGUAGE_GERMAN:
+  case DiscIO::Language::LANGUAGE_GERMAN:
     return QObject::tr("German");
-  case DiscIO::IVolume::LANGUAGE_FRENCH:
+  case DiscIO::Language::LANGUAGE_FRENCH:
     return QObject::tr("French");
-  case DiscIO::IVolume::LANGUAGE_SPANISH:
+  case DiscIO::Language::LANGUAGE_SPANISH:
     return QObject::tr("Spanish");
-  case DiscIO::IVolume::LANGUAGE_ITALIAN:
+  case DiscIO::Language::LANGUAGE_ITALIAN:
     return QObject::tr("Italian");
-  case DiscIO::IVolume::LANGUAGE_DUTCH:
+  case DiscIO::Language::LANGUAGE_DUTCH:
     return QObject::tr("Dutch");
-  case DiscIO::IVolume::LANGUAGE_SIMPLIFIED_CHINESE:
+  case DiscIO::Language::LANGUAGE_SIMPLIFIED_CHINESE:
     return QObject::tr("Simplified Chinese");
-  case DiscIO::IVolume::LANGUAGE_TRADITIONAL_CHINESE:
+  case DiscIO::Language::LANGUAGE_TRADITIONAL_CHINESE:
     return QObject::tr("Traditional Chinese");
-  case DiscIO::IVolume::LANGUAGE_KOREAN:
+  case DiscIO::Language::LANGUAGE_KOREAN:
     return QObject::tr("Korean");
   default:
     return QObject::tr("Unknown");

Source/Core/DolphinQt2/GameList/GameFile.h

@@ -9,7 +9,16 @@
 #include <QPixmap>
 #include <QString>
 
-#include "DiscIO/Volume.h"
+#include "Common/CommonTypes.h"
+
+namespace DiscIO
+{
+enum class BlobType;
+enum class Country;
+enum class Language;
+enum class Platform;
+class IVolume;
+}
 
 // TODO cache
 class GameFile final
@@ -36,26 +45,26 @@ public:
   QString GetIssues() const { return m_issues; }
   int GetRating() const { return m_rating; }
   QString GetApploaderDate() const { return m_apploader_date; }
-  DiscIO::IVolume::EPlatform GetPlatformID() const { return m_platform; }
+  DiscIO::Platform GetPlatformID() const { return m_platform; }
   QString GetPlatform() const;
-  DiscIO::IVolume::ECountry GetCountryID() const { return m_country; }
+  DiscIO::Country GetCountryID() const { return m_country; }
   QString GetCountry() const;
   DiscIO::BlobType GetBlobType() const { return m_blob_type; }
   // Banner details
-  QString GetLanguage(DiscIO::IVolume::ELanguage lang) const;
+  QString GetLanguage(DiscIO::Language lang) const;
-  QList<DiscIO::IVolume::ELanguage> GetAvailableLanguages() const;
+  QList<DiscIO::Language> GetAvailableLanguages() const;
   QString GetShortName() const { return GetBannerString(m_short_names); }
   QString GetShortMaker() const { return GetBannerString(m_short_makers); }
   QString GetLongName() const { return GetBannerString(m_long_names); }
   QString GetLongMaker() const { return GetBannerString(m_long_makers); }
   QString GetDescription() const { return GetBannerString(m_descriptions); }
-  QString GetShortName(DiscIO::IVolume::ELanguage lang) const { return m_short_names[lang]; }
+  QString GetShortName(DiscIO::Language lang) const { return m_short_names[lang]; }
-  QString GetShortMaker(DiscIO::IVolume::ELanguage lang) const { return m_short_makers[lang]; }
+  QString GetShortMaker(DiscIO::Language lang) const { return m_short_makers[lang]; }
-  QString GetLongName(DiscIO::IVolume::ELanguage lang) const { return m_long_names[lang]; }
+  QString GetLongName(DiscIO::Language lang) const { return m_long_names[lang]; }
-  QString GetLongMaker(DiscIO::IVolume::ELanguage lang) const { return m_long_makers[lang]; }
+  QString GetLongMaker(DiscIO::Language lang) const { return m_long_makers[lang]; }
-  QString GetDescription(DiscIO::IVolume::ELanguage lang) const { return m_descriptions[lang]; }
+  QString GetDescription(DiscIO::Language lang) const { return m_descriptions[lang]; }
 private:
-  QString GetBannerString(const QMap<DiscIO::IVolume::ELanguage, QString>& m) const;
+  QString GetBannerString(const QMap<DiscIO::Language, QString>& m) const;
 
   QString GetCacheFileName() const;
   void ReadBanner(const DiscIO::IVolume& volume);
@@ -80,15 +89,15 @@ private:
   QString m_maker_id;
   u16 m_revision = 0;
   QString m_internal_name;
-  QMap<DiscIO::IVolume::ELanguage, QString> m_short_names;
+  QMap<DiscIO::Language, QString> m_short_names;
-  QMap<DiscIO::IVolume::ELanguage, QString> m_long_names;
+  QMap<DiscIO::Language, QString> m_long_names;
-  QMap<DiscIO::IVolume::ELanguage, QString> m_short_makers;
+  QMap<DiscIO::Language, QString> m_short_makers;
-  QMap<DiscIO::IVolume::ELanguage, QString> m_long_makers;
+  QMap<DiscIO::Language, QString> m_long_makers;
-  QMap<DiscIO::IVolume::ELanguage, QString> m_descriptions;
+  QMap<DiscIO::Language, QString> m_descriptions;
   QString m_company;
   u8 m_disc_number = 0;
-  DiscIO::IVolume::EPlatform m_platform;
+  DiscIO::Platform m_platform;
-  DiscIO::IVolume::ECountry m_country;
+  DiscIO::Country m_country;
   DiscIO::BlobType m_blob_type;
   u64 m_raw_size = 0;
   QPixmap m_banner;

Source/Core/DolphinQt2/GameList/GameList.cpp

@@ -8,6 +8,8 @@
 #include <QMenu>
 #include <QUrl>
 
+#include "DiscIO/Enums.h"
+
 #include "DolphinQt2/Config/PropertiesDialog.h"
 #include "DolphinQt2/GameList/GameList.h"
 #include "DolphinQt2/GameList/ListProxyModel.h"
@@ -104,8 +106,8 @@ void GameList::MakeListView()
 void GameList::ShowContextMenu(const QPoint&)
 {
   QMenu* menu = new QMenu(this);
-  DiscIO::IVolume::EPlatform platform = GameFile(GetSelectedGame()).GetPlatformID();
+  DiscIO::Platform platform = GameFile(GetSelectedGame()).GetPlatformID();
-  if (platform == DiscIO::IVolume::GAMECUBE_DISC || platform == DiscIO::IVolume::WII_DISC)
+  if (platform == DiscIO::Platform::GAMECUBE_DISC || platform == DiscIO::Platform::WII_DISC)
   {
     menu->addAction(tr("Properties"), this, SLOT(OpenProperties()));
     menu->addAction(tr("Open Wiki Page"), this, SLOT(OpenWiki()));

Source/Core/DolphinQt2/GameList/GameListModel.cpp

@@ -38,7 +38,7 @@ QVariant GameListModel::data(const QModelIndex& index, int role) const
     case COL_SIZE:
       return game->GetFileSize();
     case COL_COUNTRY:
-      return game->GetCountryID();
+      return static_cast<int>(game->GetCountryID());
     case COL_RATING:
       return game->GetRating();
     }

Source/Core/DolphinQt2/Settings.cpp

@@ -101,12 +101,12 @@ void Settings::SetWiiNAND(const QString& path)
   SConfig::GetInstance().SaveSettings();
 }
 
-DiscIO::IVolume::ELanguage Settings::GetWiiSystemLanguage() const
+DiscIO::Language Settings::GetWiiSystemLanguage() const
 {
   return SConfig::GetInstance().GetCurrentLanguage(true);
 }
 
-DiscIO::IVolume::ELanguage Settings::GetGCSystemLanguage() const
+DiscIO::Language Settings::GetGCSystemLanguage() const
 {
   return SConfig::GetInstance().GetCurrentLanguage(false);
 }

Source/Core/DolphinQt2/Settings.h

@@ -6,7 +6,10 @@
 
 #include <QSettings>
 
-#include "DiscIO/Volume.h"
+namespace DiscIO
+{
+enum class Language;
+}
 
 // UI settings to be stored in the config directory.
 class Settings final : public QSettings
@@ -34,8 +37,8 @@ public:
   void SetApploader(const QString& path);
   QString GetWiiNAND() const;
   void SetWiiNAND(const QString& path);
-  DiscIO::IVolume::ELanguage GetWiiSystemLanguage() const;
+  DiscIO::Language GetWiiSystemLanguage() const;
-  DiscIO::IVolume::ELanguage GetGCSystemLanguage() const;
+  DiscIO::Language GetGCSystemLanguage() const;
   bool GetPreferredView() const;
   void SetPreferredView(bool table);
 

Source/Core/DolphinWX/Config/WiiConfigPane.cpp

@@ -11,7 +11,7 @@
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
 #include "Core/IPC_HLE/WII_IPC_HLE.h"
-#include "DiscIO/Volume.h"
+#include "DiscIO/Enums.h"
 #include "DolphinWX/Config/WiiConfigPane.h"
 #include "DolphinWX/WxUtils.h"
 
@@ -139,8 +139,8 @@ void WiiConfigPane::OnConnectKeyboardCheckBoxChanged(wxCommandEvent& event)
 
 void WiiConfigPane::OnSystemLanguageChoiceChanged(wxCommandEvent& event)
 {
-  DiscIO::IVolume::ELanguage wii_system_lang =
+  DiscIO::Language wii_system_lang =
-      (DiscIO::IVolume::ELanguage)m_system_language_choice->GetSelection();
+      static_cast<DiscIO::Language>(m_system_language_choice->GetSelection());
   SConfig::GetInstance().m_SYSCONF->SetData("IPL.LNG", wii_system_lang);
   u8 country_code = GetSADRCountryCode(wii_system_lang);
 
@@ -155,30 +155,30 @@ void WiiConfigPane::OnAspectRatioChoiceChanged(wxCommandEvent& event)
 
 // Change from IPL.LNG value to IPL.SADR country code.
 // http://wiibrew.org/wiki/Country_Codes
-u8 WiiConfigPane::GetSADRCountryCode(DiscIO::IVolume::ELanguage language)
+u8 WiiConfigPane::GetSADRCountryCode(DiscIO::Language language)
 {
   switch (language)
   {
-  case DiscIO::IVolume::LANGUAGE_JAPANESE:
+  case DiscIO::Language::LANGUAGE_JAPANESE:
     return 1;  // Japan
-  case DiscIO::IVolume::LANGUAGE_ENGLISH:
+  case DiscIO::Language::LANGUAGE_ENGLISH:
     return 49;  // USA
-  case DiscIO::IVolume::LANGUAGE_GERMAN:
+  case DiscIO::Language::LANGUAGE_GERMAN:
     return 78;  // Germany
-  case DiscIO::IVolume::LANGUAGE_FRENCH:
+  case DiscIO::Language::LANGUAGE_FRENCH:
     return 77;  // France
-  case DiscIO::IVolume::LANGUAGE_SPANISH:
+  case DiscIO::Language::LANGUAGE_SPANISH:
     return 105;  // Spain
-  case DiscIO::IVolume::LANGUAGE_ITALIAN:
+  case DiscIO::Language::LANGUAGE_ITALIAN:
     return 83;  // Italy
-  case DiscIO::IVolume::LANGUAGE_DUTCH:
+  case DiscIO::Language::LANGUAGE_DUTCH:
     return 94;  // Netherlands
-  case DiscIO::IVolume::LANGUAGE_SIMPLIFIED_CHINESE:
+  case DiscIO::Language::LANGUAGE_SIMPLIFIED_CHINESE:
-  case DiscIO::IVolume::LANGUAGE_TRADITIONAL_CHINESE:
+  case DiscIO::Language::LANGUAGE_TRADITIONAL_CHINESE:
     return 157;  // China
-  case DiscIO::IVolume::LANGUAGE_KOREAN:
+  case DiscIO::Language::LANGUAGE_KOREAN:
     return 136;  // Korea
-  case DiscIO::IVolume::LANGUAGE_UNKNOWN:
+  case DiscIO::Language::LANGUAGE_UNKNOWN:
     break;
   }
 

Source/Core/DolphinWX/Config/WiiConfigPane.h

@@ -7,7 +7,11 @@
 #include <wx/arrstr.h>
 #include <wx/panel.h>
 #include "Common/CommonTypes.h"
-#include "DiscIO/Volume.h"
+
+namespace DiscIO
+{
+enum class Language;
+}
 
 class wxCheckBox;
 class wxChoice;
@@ -29,7 +33,7 @@ private:
   void OnSystemLanguageChoiceChanged(wxCommandEvent&);
   void OnAspectRatioChoiceChanged(wxCommandEvent&);
 
-  static u8 GetSADRCountryCode(DiscIO::IVolume::ELanguage language);
+  static u8 GetSADRCountryCode(DiscIO::Language language);
 
   wxArrayString m_system_language_strings;
   wxArrayString m_aspect_ratio_strings;

Source/Core/DolphinWX/GameListCtrl.cpp

@@ -45,6 +45,7 @@
 #include "Core/HW/WiiSaveCrypted.h"
 #include "Core/Movie.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 #include "DolphinWX/Frame.h"
@@ -179,59 +180,48 @@ CGameListCtrl::~CGameListCtrl()
   ClearIsoFiles();
 }
 
-void CGameListCtrl::InitBitmaps()
+template <typename T>
+static void InitBitmap(wxImageList* img_list, std::vector<int>* vector, T index,
+                       const std::string& name)
 {
   wxSize size(96, 32);
+  (*vector)[static_cast<size_t>(index)] = img_list->Add(WxUtils::LoadResourceBitmap(name, size));
+}
+
+void CGameListCtrl::InitBitmaps()
+{
   wxImageList* img_list = new wxImageList(96, 32);
   AssignImageList(img_list, wxIMAGE_LIST_SMALL);
 
-  m_FlagImageIndex.resize(DiscIO::IVolume::NUMBER_OF_COUNTRIES);
+  m_FlagImageIndex.resize(static_cast<size_t>(DiscIO::Country::NUMBER_OF_COUNTRIES));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_JAPAN] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_JAPAN, "Flag_Japan");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Japan", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_EUROPE, "Flag_Europe");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_EUROPE] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_USA, "Flag_USA");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Europe", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_AUSTRALIA, "Flag_Australia");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_USA] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_FRANCE, "Flag_France");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_USA", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_GERMANY, "Flag_Germany");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_AUSTRALIA] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_ITALY, "Flag_Italy");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Australia", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_KOREA, "Flag_Korea");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_FRANCE] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_NETHERLANDS, "Flag_Netherlands");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_France", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_RUSSIA, "Flag_Russia");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_GERMANY] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_SPAIN, "Flag_Spain");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Germany", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_TAIWAN, "Flag_Taiwan");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_ITALY] =
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_WORLD, "Flag_International");
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Italy", size));
+  InitBitmap(img_list, &m_FlagImageIndex, DiscIO::Country::COUNTRY_UNKNOWN, "Flag_Unknown");
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_KOREA] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Korea", size));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_NETHERLANDS] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Netherlands", size));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_RUSSIA] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Russia", size));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_SPAIN] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Spain", size));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_TAIWAN] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Taiwan", size));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_WORLD] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_International", size));
-  m_FlagImageIndex[DiscIO::IVolume::COUNTRY_UNKNOWN] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Flag_Unknown", size));
 
-  m_PlatformImageIndex.resize(4);
+  m_PlatformImageIndex.resize(static_cast<size_t>(DiscIO::Platform::NUMBER_OF_PLATFORMS));
-  m_PlatformImageIndex[DiscIO::IVolume::GAMECUBE_DISC] =
+  InitBitmap(img_list, &m_PlatformImageIndex, DiscIO::Platform::GAMECUBE_DISC, "Platform_Gamecube");
-      img_list->Add(WxUtils::LoadResourceBitmap("Platform_Gamecube", size));
+  InitBitmap(img_list, &m_PlatformImageIndex, DiscIO::Platform::WII_DISC, "Platform_Wii");
-  m_PlatformImageIndex[DiscIO::IVolume::WII_DISC] =
+  InitBitmap(img_list, &m_PlatformImageIndex, DiscIO::Platform::WII_WAD, "Platform_Wad");
-      img_list->Add(WxUtils::LoadResourceBitmap("Platform_Wii", size));
+  InitBitmap(img_list, &m_PlatformImageIndex, DiscIO::Platform::ELF_DOL, "Platform_File");
-  m_PlatformImageIndex[DiscIO::IVolume::WII_WAD] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Platform_Wad", size));
-  m_PlatformImageIndex[DiscIO::IVolume::ELF_DOL] =
-      img_list->Add(WxUtils::LoadResourceBitmap("Platform_File", size));
 
   m_EmuStateImageIndex.resize(6);
-  m_EmuStateImageIndex[0] = img_list->Add(WxUtils::LoadResourceBitmap("rating0", size));
+  InitBitmap(img_list, &m_EmuStateImageIndex, 0, "rating0");
-  m_EmuStateImageIndex[1] = img_list->Add(WxUtils::LoadResourceBitmap("rating1", size));
+  InitBitmap(img_list, &m_EmuStateImageIndex, 1, "rating1");
-  m_EmuStateImageIndex[2] = img_list->Add(WxUtils::LoadResourceBitmap("rating2", size));
+  InitBitmap(img_list, &m_EmuStateImageIndex, 2, "rating2");
-  m_EmuStateImageIndex[3] = img_list->Add(WxUtils::LoadResourceBitmap("rating3", size));
+  InitBitmap(img_list, &m_EmuStateImageIndex, 3, "rating3");
-  m_EmuStateImageIndex[4] = img_list->Add(WxUtils::LoadResourceBitmap("rating4", size));
+  InitBitmap(img_list, &m_EmuStateImageIndex, 4, "rating4");
-  m_EmuStateImageIndex[5] = img_list->Add(WxUtils::LoadResourceBitmap("rating5", size));
+  InitBitmap(img_list, &m_EmuStateImageIndex, 5, "rating5");
 }
 
 void CGameListCtrl::BrowseForDirectory()
@@ -403,7 +393,8 @@ void CGameListCtrl::UpdateItemAtColumn(long _Index, int column)
   {
   case COLUMN_PLATFORM:
   {
-    SetItemColumnImage(_Index, COLUMN_PLATFORM, m_PlatformImageIndex[rISOFile.GetPlatform()]);
+    SetItemColumnImage(_Index, COLUMN_PLATFORM,
+                       m_PlatformImageIndex[static_cast<size_t>(rISOFile.GetPlatform())]);
     break;
   }
   case COLUMN_BANNER:
@@ -442,7 +433,8 @@ void CGameListCtrl::UpdateItemAtColumn(long _Index, int column)
                        m_EmuStateImageIndex[rISOFile.GetEmuState()]);
     break;
   case COLUMN_COUNTRY:
-    SetItemColumnImage(_Index, COLUMN_COUNTRY, m_FlagImageIndex[rISOFile.GetCountry()]);
+    SetItemColumnImage(_Index, COLUMN_COUNTRY,
+                       m_FlagImageIndex[static_cast<size_t>(rISOFile.GetCountry())]);
     break;
   case COLUMN_SIZE:
     SetItem(_Index, COLUMN_SIZE, NiceSizeFormat(rISOFile.GetFileSize()), -1);
@@ -576,15 +568,15 @@ void CGameListCtrl::ScanForISOs()
 
         switch (iso_file->GetPlatform())
         {
-        case DiscIO::IVolume::WII_DISC:
+        case DiscIO::Platform::WII_DISC:
           if (!SConfig::GetInstance().m_ListWii)
             list = false;
           break;
-        case DiscIO::IVolume::WII_WAD:
+        case DiscIO::Platform::WII_WAD:
           if (!SConfig::GetInstance().m_ListWad)
             list = false;
           break;
-        case DiscIO::IVolume::ELF_DOL:
+        case DiscIO::Platform::ELF_DOL:
           if (!SConfig::GetInstance().m_ListElfDol)
             list = false;
           break;
@@ -596,59 +588,59 @@ void CGameListCtrl::ScanForISOs()
 
         switch (iso_file->GetCountry())
         {
-        case DiscIO::IVolume::COUNTRY_AUSTRALIA:
+        case DiscIO::Country::COUNTRY_AUSTRALIA:
           if (!SConfig::GetInstance().m_ListAustralia)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_EUROPE:
+        case DiscIO::Country::COUNTRY_EUROPE:
           if (!SConfig::GetInstance().m_ListPal)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_FRANCE:
+        case DiscIO::Country::COUNTRY_FRANCE:
           if (!SConfig::GetInstance().m_ListFrance)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_GERMANY:
+        case DiscIO::Country::COUNTRY_GERMANY:
           if (!SConfig::GetInstance().m_ListGermany)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_ITALY:
+        case DiscIO::Country::COUNTRY_ITALY:
           if (!SConfig::GetInstance().m_ListItaly)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_JAPAN:
+        case DiscIO::Country::COUNTRY_JAPAN:
           if (!SConfig::GetInstance().m_ListJap)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_KOREA:
+        case DiscIO::Country::COUNTRY_KOREA:
           if (!SConfig::GetInstance().m_ListKorea)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_NETHERLANDS:
+        case DiscIO::Country::COUNTRY_NETHERLANDS:
           if (!SConfig::GetInstance().m_ListNetherlands)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_RUSSIA:
+        case DiscIO::Country::COUNTRY_RUSSIA:
           if (!SConfig::GetInstance().m_ListRussia)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_SPAIN:
+        case DiscIO::Country::COUNTRY_SPAIN:
           if (!SConfig::GetInstance().m_ListSpain)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_TAIWAN:
+        case DiscIO::Country::COUNTRY_TAIWAN:
           if (!SConfig::GetInstance().m_ListTaiwan)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_USA:
+        case DiscIO::Country::COUNTRY_USA:
           if (!SConfig::GetInstance().m_ListUsa)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_WORLD:
+        case DiscIO::Country::COUNTRY_WORLD:
           if (!SConfig::GetInstance().m_ListWorld)
             list = false;
           break;
-        case DiscIO::IVolume::COUNTRY_UNKNOWN:
+        case DiscIO::Country::COUNTRY_UNKNOWN:
         default:
           if (!SConfig::GetInstance().m_ListUnknown)
             list = false;
@@ -937,22 +929,22 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
     if (selected_iso)
     {
       wxMenu popupMenu;
-      DiscIO::IVolume::EPlatform platform = selected_iso->GetPlatform();
+      DiscIO::Platform platform = selected_iso->GetPlatform();
 
-      if (platform != DiscIO::IVolume::ELF_DOL)
+      if (platform != DiscIO::Platform::ELF_DOL)
       {
         popupMenu.Append(IDM_PROPERTIES, _("&Properties"));
         popupMenu.Append(IDM_GAME_WIKI, _("&Wiki"));
         popupMenu.AppendSeparator();
       }
-      if (platform == DiscIO::IVolume::WII_DISC || platform == DiscIO::IVolume::WII_WAD)
+      if (platform == DiscIO::Platform::WII_DISC || platform == DiscIO::Platform::WII_WAD)
       {
         popupMenu.Append(IDM_OPEN_SAVE_FOLDER, _("Open Wii &save folder"));
         popupMenu.Append(IDM_EXPORT_SAVE, _("Export Wii save (Experimental)"));
       }
       popupMenu.Append(IDM_OPEN_CONTAINING_FOLDER, _("Open &containing folder"));
 
-      if (platform != DiscIO::IVolume::ELF_DOL)
+      if (platform != DiscIO::Platform::ELF_DOL)
         popupMenu.AppendCheckItem(IDM_SET_DEFAULT_ISO, _("Set as &default ISO"));
 
       // First we have to decide a starting value when we append it
@@ -962,7 +954,7 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
       popupMenu.AppendSeparator();
       popupMenu.Append(IDM_DELETE_ISO, _("&Delete File..."));
 
-      if (platform == DiscIO::IVolume::GAMECUBE_DISC || platform == DiscIO::IVolume::WII_DISC)
+      if (platform == DiscIO::Platform::GAMECUBE_DISC || platform == DiscIO::Platform::WII_DISC)
       {
         if (selected_iso->GetBlobType() == DiscIO::BlobType::GCZ)
           popupMenu.Append(IDM_COMPRESS_ISO, _("Decompress ISO..."));
@@ -973,7 +965,7 @@ void CGameListCtrl::OnRightClick(wxMouseEvent& event)
         changeDiscItem->Enable(Core::IsRunning());
       }
 
-      if (platform == DiscIO::IVolume::WII_WAD)
+      if (platform == DiscIO::Platform::WII_WAD)
         popupMenu.Append(IDM_LIST_INSTALL_WAD, _("Install to Wii Menu"));
 
       PopupMenu(&popupMenu);
@@ -1156,8 +1148,8 @@ void CGameListCtrl::CompressSelection(bool _compress)
   for (const GameListItem* iso : GetAllSelectedISOs())
   {
     // Don't include items that we can't do anything with
-    if (iso->GetPlatform() != DiscIO::IVolume::GAMECUBE_DISC &&
+    if (iso->GetPlatform() != DiscIO::Platform::GAMECUBE_DISC &&
-        iso->GetPlatform() != DiscIO::IVolume::WII_DISC)
+        iso->GetPlatform() != DiscIO::Platform::WII_DISC)
       continue;
     if (iso->GetBlobType() != DiscIO::BlobType::PLAIN &&
         iso->GetBlobType() != DiscIO::BlobType::GCZ)
@@ -1167,7 +1159,7 @@ void CGameListCtrl::CompressSelection(bool _compress)
 
     // Show the Wii compression warning if it's relevant and it hasn't been shown already
     if (!wii_compression_warning_accepted && _compress && !iso->IsCompressed() &&
-        iso->GetPlatform() == DiscIO::IVolume::WII_DISC)
+        iso->GetPlatform() == DiscIO::Platform::WII_DISC)
     {
       if (WiiCompressWarning())
         wii_compression_warning_accepted = true;
@@ -1216,7 +1208,7 @@ void CGameListCtrl::CompressSelection(bool _compress)
 
         all_good &=
             DiscIO::CompressFileToBlob(iso->GetFileName(), OutputFileName,
-                                       (iso->GetPlatform() == DiscIO::IVolume::WII_DISC) ? 1 : 0,
+                                       (iso->GetPlatform() == DiscIO::Platform::WII_DISC) ? 1 : 0,
                                        16384, &MultiCompressCB, &progress);
       }
       else if (iso->IsCompressed() && !_compress)
@@ -1224,7 +1216,7 @@ void CGameListCtrl::CompressSelection(bool _compress)
         std::string FileName;
         SplitPath(iso->GetFileName(), nullptr, &FileName, nullptr);
         progress.current_filename = FileName;
-        if (iso->GetPlatform() == DiscIO::IVolume::WII_DISC)
+        if (iso->GetPlatform() == DiscIO::Platform::WII_DISC)
           FileName.append(".iso");
         else
           FileName.append(".gcm");
@@ -1275,7 +1267,7 @@ void CGameListCtrl::OnCompressISO(wxCommandEvent& WXUNUSED(event))
     if (is_compressed)
     {
       wxString FileType;
-      if (iso->GetPlatform() == DiscIO::IVolume::WII_DISC)
+      if (iso->GetPlatform() == DiscIO::Platform::WII_DISC)
         FileType = _("All Wii ISO files (iso)") + "|*.iso";
       else
         FileType = _("All GameCube GCM files (gcm)") + "|*.gcm";
@@ -1286,7 +1278,7 @@ void CGameListCtrl::OnCompressISO(wxCommandEvent& WXUNUSED(event))
     }
     else
     {
-      if (iso->GetPlatform() == DiscIO::IVolume::WII_DISC && !WiiCompressWarning())
+      if (iso->GetPlatform() == DiscIO::Platform::WII_DISC && !WiiCompressWarning())
         return;
 
       path = wxFileSelector(_("Save compressed GCM/ISO"), StrToWxStr(FilePath),
@@ -1317,7 +1309,7 @@ void CGameListCtrl::OnCompressISO(wxCommandEvent& WXUNUSED(event))
     else
       all_good = DiscIO::CompressFileToBlob(
           iso->GetFileName(), WxStrToStr(path),
-          (iso->GetPlatform() == DiscIO::IVolume::WII_DISC) ? 1 : 0, 16384, &CompressCB, &dialog);
+          (iso->GetPlatform() == DiscIO::Platform::WII_DISC) ? 1 : 0, 16384, &CompressCB, &dialog);
   }
 
   if (!all_good)

Source/Core/DolphinWX/ISOFile.cpp

@@ -28,6 +28,8 @@
 #include "Core/Boot/Boot.h"
 #include "Core/ConfigManager.h"
 
+#include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
 
@@ -39,8 +41,8 @@ static const u32 CACHE_REVISION = 0x127;  // Last changed in PR 3309
 #define DVD_BANNER_WIDTH 96
 #define DVD_BANNER_HEIGHT 32
 
-static std::string GetLanguageString(DiscIO::IVolume::ELanguage language,
+static std::string GetLanguageString(DiscIO::Language language,
-                                     std::map<DiscIO::IVolume::ELanguage, std::string> strings)
+                                     std::map<DiscIO::Language, std::string> strings)
 {
   auto end = strings.end();
   auto it = strings.find(language);
@@ -48,9 +50,9 @@ static std::string GetLanguageString(DiscIO::IVolume::ELanguage language,
     return it->second;
 
   // English tends to be a good fallback when the requested language isn't available
-  if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH)
+  if (language != DiscIO::Language::LANGUAGE_ENGLISH)
   {
-    it = strings.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
+    it = strings.find(DiscIO::Language::LANGUAGE_ENGLISH);
     if (it != end)
       return it->second;
   }
@@ -65,7 +67,7 @@ static std::string GetLanguageString(DiscIO::IVolume::ELanguage language,
 GameListItem::GameListItem(const std::string& _rFileName,
                            const std::unordered_map<std::string, std::string>& custom_titles)
     : m_FileName(_rFileName), m_title_id(0), m_emu_state(0), m_FileSize(0),
-      m_Country(DiscIO::IVolume::COUNTRY_UNKNOWN), m_Revision(0), m_Valid(false), m_ImageWidth(0),
+      m_Country(DiscIO::Country::COUNTRY_UNKNOWN), m_Revision(0), m_Valid(false), m_ImageWidth(0),
       m_ImageHeight(0), m_disc_number(0), m_has_custom_name(false)
 {
   if (LoadFromCache())
@@ -96,9 +98,9 @@ GameListItem::GameListItem(const std::string& _rFileName,
       m_names = volume->GetLongNames();
       if (m_names.empty())
         m_names = volume->GetShortNames();
-      m_company = GetLanguageString(DiscIO::IVolume::LANGUAGE_ENGLISH, volume->GetLongMakers());
+      m_company = GetLanguageString(DiscIO::Language::LANGUAGE_ENGLISH, volume->GetLongMakers());
       if (m_company.empty())
-        m_company = GetLanguageString(DiscIO::IVolume::LANGUAGE_ENGLISH, volume->GetShortMakers());
+        m_company = GetLanguageString(DiscIO::Language::LANGUAGE_ENGLISH, volume->GetShortMakers());
 
       m_Country = volume->GetCountry();
       m_blob_type = volume->GetBlobType();
@@ -126,7 +128,7 @@ GameListItem::GameListItem(const std::string& _rFileName,
     std::string game_id = m_UniqueID;
 
     // Ignore publisher ID for WAD files
-    if (m_Platform == DiscIO::IVolume::WII_WAD && game_id.size() > 4)
+    if (m_Platform == DiscIO::Platform::WII_WAD && game_id.size() > 4)
       game_id.erase(4);
 
     auto it = custom_titles.find(game_id);
@@ -142,7 +144,7 @@ GameListItem::GameListItem(const std::string& _rFileName,
   {
     m_Valid = true;
     m_FileSize = File::GetSize(_rFileName);
-    m_Platform = DiscIO::IVolume::ELF_DOL;
+    m_Platform = DiscIO::Platform::ELF_DOL;
     m_blob_type = DiscIO::BlobType::DIRECTORY;
   }
 
@@ -296,18 +298,18 @@ wxBitmap GameListItem::ScaleBanner(wxImage* image)
 #endif
 }
 
-std::string GameListItem::GetDescription(DiscIO::IVolume::ELanguage language) const
+std::string GameListItem::GetDescription(DiscIO::Language language) const
 {
   return GetLanguageString(language, m_descriptions);
 }
 
 std::string GameListItem::GetDescription() const
 {
-  bool wii = m_Platform != DiscIO::IVolume::GAMECUBE_DISC;
+  bool wii = m_Platform != DiscIO::Platform::GAMECUBE_DISC;
   return GetDescription(SConfig::GetInstance().GetCurrentLanguage(wii));
 }
 
-std::string GameListItem::GetName(DiscIO::IVolume::ELanguage language) const
+std::string GameListItem::GetName(DiscIO::Language language) const
 {
   return GetLanguageString(language, m_names);
 }
@@ -317,7 +319,7 @@ std::string GameListItem::GetName() const
   if (m_has_custom_name)
     return m_custom_name;
 
-  bool wii = m_Platform != DiscIO::IVolume::GAMECUBE_DISC;
+  bool wii = m_Platform != DiscIO::Platform::GAMECUBE_DISC;
   std::string name = GetName(SConfig::GetInstance().GetCurrentLanguage(wii));
   if (!name.empty())
     return name;
@@ -328,10 +330,10 @@ std::string GameListItem::GetName() const
   return name + ext;
 }
 
-std::vector<DiscIO::IVolume::ELanguage> GameListItem::GetLanguages() const
+std::vector<DiscIO::Language> GameListItem::GetLanguages() const
 {
-  std::vector<DiscIO::IVolume::ELanguage> languages;
+  std::vector<DiscIO::Language> languages;
-  for (std::pair<DiscIO::IVolume::ELanguage, std::string> name : m_names)
+  for (std::pair<DiscIO::Language, std::string> name : m_names)
     languages.push_back(name.first);
   return languages;
 }
@@ -344,7 +346,7 @@ const std::string GameListItem::GetWiiFSPath() const
   if (iso == nullptr)
     return ret;
 
-  if (iso->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC)
+  if (iso->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC)
   {
     u64 title_id = 0;
     iso->GetTitleID(&title_id);
@@ -364,3 +366,9 @@ const std::string GameListItem::GetWiiFSPath() const
 
   return ret;
 }
+
+bool GameListItem::IsCompressed() const
+{
+  return m_blob_type == DiscIO::BlobType::GCZ || m_blob_type == DiscIO::BlobType::CISO ||
+         m_blob_type == DiscIO::BlobType::WBFS;
+}

Source/Core/DolphinWX/ISOFile.h

@@ -10,15 +10,22 @@
 #include <vector>
 
 #include "Common/Common.h"
-#include "DiscIO/Blob.h"
-#include "DiscIO/Volume.h"
 
 #if defined(HAVE_WX) && HAVE_WX
 #include <wx/bitmap.h>
 #include <wx/image.h>
 #endif
 
+namespace DiscIO
+{
+enum class BlobType;
+enum class Country;
+enum class Language;
+enum class Platform;
+}
+
 class PointerWrap;
+
 class GameListItem
 {
 public:
@@ -31,25 +38,21 @@ public:
 
   bool IsValid() const { return m_Valid; }
   const std::string& GetFileName() const { return m_FileName; }
-  std::string GetName(DiscIO::IVolume::ELanguage language) const;
+  std::string GetName(DiscIO::Language language) const;
   std::string GetName() const;
-  std::string GetDescription(DiscIO::IVolume::ELanguage language) const;
+  std::string GetDescription(DiscIO::Language language) const;
   std::string GetDescription() const;
-  std::vector<DiscIO::IVolume::ELanguage> GetLanguages() const;
+  std::vector<DiscIO::Language> GetLanguages() const;
   std::string GetCompany() const { return m_company; }
   u16 GetRevision() const { return m_Revision; }
   const std::string& GetUniqueID() const { return m_UniqueID; }
   const std::string GetWiiFSPath() const;
-  DiscIO::IVolume::ECountry GetCountry() const { return m_Country; }
+  DiscIO::Country GetCountry() const { return m_Country; }
-  DiscIO::IVolume::EPlatform GetPlatform() const { return m_Platform; }
+  DiscIO::Platform GetPlatform() const { return m_Platform; }
   DiscIO::BlobType GetBlobType() const { return m_blob_type; }
   const std::string& GetIssues() const { return m_issues; }
   int GetEmuState() const { return m_emu_state; }
-  bool IsCompressed() const
+  bool IsCompressed() const;
-  {
-    return m_blob_type == DiscIO::BlobType::GCZ || m_blob_type == DiscIO::BlobType::CISO ||
-           m_blob_type == DiscIO::BlobType::WBFS;
-  }
   u64 GetFileSize() const { return m_FileSize; }
   u64 GetVolumeSize() const { return m_VolumeSize; }
   // 0 is the first disc, 1 is the second disc
@@ -63,8 +66,8 @@ public:
 private:
   std::string m_FileName;
 
-  std::map<DiscIO::IVolume::ELanguage, std::string> m_names;
+  std::map<DiscIO::Language, std::string> m_names;
-  std::map<DiscIO::IVolume::ELanguage, std::string> m_descriptions;
+  std::map<DiscIO::Language, std::string> m_descriptions;
   std::string m_company;
 
   std::string m_UniqueID;
@@ -76,8 +79,8 @@ private:
   u64 m_FileSize;
   u64 m_VolumeSize;
 
-  DiscIO::IVolume::ECountry m_Country;
+  DiscIO::Country m_Country;
-  DiscIO::IVolume::EPlatform m_Platform;
+  DiscIO::Platform m_Platform;
   DiscIO::BlobType m_blob_type;
   u16 m_Revision;
 

Source/Core/DolphinWX/ISOProperties.cpp

@@ -59,6 +59,7 @@
 #include "Core/GeckoCodeConfig.h"
 #include "Core/PatchEngine.h"
 #include "DiscIO/Blob.h"
+#include "DiscIO/Enums.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
@@ -123,46 +124,46 @@ CISOProperties::CISOProperties(const GameListItem& game_list_item, wxWindow* par
   m_GameID->SetValue(StrToWxStr(m_open_iso->GetUniqueID()));
   switch (m_open_iso->GetCountry())
   {
-  case DiscIO::IVolume::COUNTRY_AUSTRALIA:
+  case DiscIO::Country::COUNTRY_AUSTRALIA:
     m_Country->SetValue(_("Australia"));
     break;
-  case DiscIO::IVolume::COUNTRY_EUROPE:
+  case DiscIO::Country::COUNTRY_EUROPE:
     m_Country->SetValue(_("Europe"));
     break;
-  case DiscIO::IVolume::COUNTRY_FRANCE:
+  case DiscIO::Country::COUNTRY_FRANCE:
     m_Country->SetValue(_("France"));
     break;
-  case DiscIO::IVolume::COUNTRY_ITALY:
+  case DiscIO::Country::COUNTRY_ITALY:
     m_Country->SetValue(_("Italy"));
     break;
-  case DiscIO::IVolume::COUNTRY_GERMANY:
+  case DiscIO::Country::COUNTRY_GERMANY:
     m_Country->SetValue(_("Germany"));
     break;
-  case DiscIO::IVolume::COUNTRY_NETHERLANDS:
+  case DiscIO::Country::COUNTRY_NETHERLANDS:
     m_Country->SetValue(_("Netherlands"));
     break;
-  case DiscIO::IVolume::COUNTRY_RUSSIA:
+  case DiscIO::Country::COUNTRY_RUSSIA:
     m_Country->SetValue(_("Russia"));
     break;
-  case DiscIO::IVolume::COUNTRY_SPAIN:
+  case DiscIO::Country::COUNTRY_SPAIN:
     m_Country->SetValue(_("Spain"));
     break;
-  case DiscIO::IVolume::COUNTRY_USA:
+  case DiscIO::Country::COUNTRY_USA:
     m_Country->SetValue(_("USA"));
     break;
-  case DiscIO::IVolume::COUNTRY_JAPAN:
+  case DiscIO::Country::COUNTRY_JAPAN:
     m_Country->SetValue(_("Japan"));
     break;
-  case DiscIO::IVolume::COUNTRY_KOREA:
+  case DiscIO::Country::COUNTRY_KOREA:
     m_Country->SetValue(_("Korea"));
     break;
-  case DiscIO::IVolume::COUNTRY_TAIWAN:
+  case DiscIO::Country::COUNTRY_TAIWAN:
     m_Country->SetValue(_("Taiwan"));
     break;
-  case DiscIO::IVolume::COUNTRY_WORLD:
+  case DiscIO::Country::COUNTRY_WORLD:
     m_Country->SetValue(_("World"));
     break;
-  case DiscIO::IVolume::COUNTRY_UNKNOWN:
+  case DiscIO::Country::COUNTRY_UNKNOWN:
   default:
     m_Country->SetValue(_("Unknown"));
     break;
@@ -175,7 +176,7 @@ CISOProperties::CISOProperties(const GameListItem& game_list_item, wxWindow* par
   m_FST->SetValue(StrToWxStr(std::to_string(m_open_iso->GetFSTSize())));
 
   // Here we set all the info to be shown + we set the window title
-  bool wii = m_open_iso->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
+  bool wii = m_open_iso->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC;
   ChangeBannerDetails(SConfig::GetInstance().GetCurrentLanguage(wii));
 
   m_Banner->SetBitmap(OpenGameListItem.GetBitmap());
@@ -183,9 +184,9 @@ CISOProperties::CISOProperties(const GameListItem& game_list_item, wxWindow* par
 
   // Filesystem browser/dumper
   // TODO : Should we add a way to browse the wad file ?
-  if (m_open_iso->GetVolumeType() != DiscIO::IVolume::WII_WAD)
+  if (m_open_iso->GetVolumeType() != DiscIO::Platform::WII_WAD)
   {
-    if (m_open_iso->GetVolumeType() == DiscIO::IVolume::WII_DISC)
+    if (m_open_iso->GetVolumeType() == DiscIO::Platform::WII_DISC)
     {
       int partition_count = 0;
       for (int group = 0; group < 4; group++)
@@ -426,7 +427,7 @@ void CISOProperties::CreateGUIControls()
 
   wxStaticBoxSizer* const sbWiiOverrides =
       new wxStaticBoxSizer(wxVERTICAL, m_GameConfig, _("Wii Console"));
-  if (m_open_iso->GetVolumeType() == DiscIO::IVolume::GAMECUBE_DISC)
+  if (m_open_iso->GetVolumeType() == DiscIO::Platform::GAMECUBE_DISC)
   {
     sbWiiOverrides->ShowItems(false);
     EnableWideScreen->Hide();
@@ -523,10 +524,10 @@ void CISOProperties::CreateGUIControls()
 
   wxStaticText* const m_LangText = new wxStaticText(m_Information, wxID_ANY, _("Show Language:"));
 
-  bool wii = m_open_iso->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
+  bool wii = m_open_iso->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC;
-  DiscIO::IVolume::ELanguage preferred_language = SConfig::GetInstance().GetCurrentLanguage(wii);
+  DiscIO::Language preferred_language = SConfig::GetInstance().GetCurrentLanguage(wii);
 
-  std::vector<DiscIO::IVolume::ELanguage> languages = OpenGameListItem.GetLanguages();
+  std::vector<DiscIO::Language> languages = OpenGameListItem.GetLanguages();
   int preferred_language_index = 0;
   for (size_t i = 0; i < languages.size(); ++i)
   {
@@ -535,37 +536,37 @@ void CISOProperties::CreateGUIControls()
 
     switch (languages[i])
     {
-    case DiscIO::IVolume::LANGUAGE_JAPANESE:
+    case DiscIO::Language::LANGUAGE_JAPANESE:
       arrayStringFor_Lang.Add(_("Japanese"));
       break;
-    case DiscIO::IVolume::LANGUAGE_ENGLISH:
+    case DiscIO::Language::LANGUAGE_ENGLISH:
       arrayStringFor_Lang.Add(_("English"));
       break;
-    case DiscIO::IVolume::LANGUAGE_GERMAN:
+    case DiscIO::Language::LANGUAGE_GERMAN:
       arrayStringFor_Lang.Add(_("German"));
       break;
-    case DiscIO::IVolume::LANGUAGE_FRENCH:
+    case DiscIO::Language::LANGUAGE_FRENCH:
       arrayStringFor_Lang.Add(_("French"));
       break;
-    case DiscIO::IVolume::LANGUAGE_SPANISH:
+    case DiscIO::Language::LANGUAGE_SPANISH:
       arrayStringFor_Lang.Add(_("Spanish"));
       break;
-    case DiscIO::IVolume::LANGUAGE_ITALIAN:
+    case DiscIO::Language::LANGUAGE_ITALIAN:
       arrayStringFor_Lang.Add(_("Italian"));
       break;
-    case DiscIO::IVolume::LANGUAGE_DUTCH:
+    case DiscIO::Language::LANGUAGE_DUTCH:
       arrayStringFor_Lang.Add(_("Dutch"));
       break;
-    case DiscIO::IVolume::LANGUAGE_SIMPLIFIED_CHINESE:
+    case DiscIO::Language::LANGUAGE_SIMPLIFIED_CHINESE:
       arrayStringFor_Lang.Add(_("Simplified Chinese"));
       break;
-    case DiscIO::IVolume::LANGUAGE_TRADITIONAL_CHINESE:
+    case DiscIO::Language::LANGUAGE_TRADITIONAL_CHINESE:
       arrayStringFor_Lang.Add(_("Traditional Chinese"));
       break;
-    case DiscIO::IVolume::LANGUAGE_KOREAN:
+    case DiscIO::Language::LANGUAGE_KOREAN:
       arrayStringFor_Lang.Add(_("Korean"));
       break;
-    case DiscIO::IVolume::LANGUAGE_UNKNOWN:
+    case DiscIO::Language::LANGUAGE_UNKNOWN:
     default:
       arrayStringFor_Lang.Add(_("Unknown"));
       break;
@@ -650,7 +651,7 @@ void CISOProperties::CreateGUIControls()
   sInfoPage->Add(sbBannerDetails, 0, wxEXPAND | wxALL, 5);
   m_Information->SetSizer(sInfoPage);
 
-  if (m_open_iso->GetVolumeType() != DiscIO::IVolume::WII_WAD)
+  if (m_open_iso->GetVolumeType() != DiscIO::Platform::WII_WAD)
   {
     wxPanel* const filesystem_panel = new wxPanel(m_Notebook, ID_FILESYSTEM);
     m_Notebook->AddPage(filesystem_panel, _("Filesystem"));
@@ -758,7 +759,7 @@ void CISOProperties::OnRightClickOnTree(wxTreeEvent& event)
 
   popupMenu.Append(IDM_EXTRACTALL, _("Extract All Files..."));
 
-  if (m_open_iso->GetVolumeType() != DiscIO::IVolume::WII_DISC ||
+  if (m_open_iso->GetVolumeType() != DiscIO::Platform::WII_DISC ||
       (m_Treectrl->GetItemImage(m_Treectrl->GetSelection()) == 0 &&
        m_Treectrl->GetFirstVisibleItem() != m_Treectrl->GetSelection()))
   {
@@ -797,7 +798,7 @@ void CISOProperties::OnExtractFile(wxCommandEvent& WXUNUSED(event))
     m_Treectrl->SelectItem(m_Treectrl->GetItemParent(m_Treectrl->GetSelection()));
   }
 
-  if (m_open_iso->GetVolumeType() == DiscIO::IVolume::WII_DISC)
+  if (m_open_iso->GetVolumeType() == DiscIO::Platform::WII_DISC)
   {
     const wxTreeItemId tree_selection = m_Treectrl->GetSelection();
     WiiPartition* partition =
@@ -815,9 +816,8 @@ void CISOProperties::OnExtractFile(wxCommandEvent& WXUNUSED(event))
 void CISOProperties::ExportDir(const std::string& _rFullPath, const std::string& _rExportFolder,
                                const WiiPartition* partition)
 {
-  DiscIO::IFileSystem* const fs = m_open_iso->GetVolumeType() == DiscIO::IVolume::WII_DISC ?
+  bool is_wii = m_open_iso->GetVolumeType() == DiscIO::Platform::WII_DISC;
-                                      partition->FileSystem.get() :
+  DiscIO::IFileSystem* const fs = is_wii ? partition->FileSystem.get() : m_filesystem.get();
-                                      m_filesystem.get();
 
   const std::vector<DiscIO::SFileInfo>& fst = fs->GetFileList();
 
@@ -831,7 +831,7 @@ void CISOProperties::ExportDir(const std::string& _rFullPath, const std::string&
     size = (u32)fst.size();
 
     fs->ExportApploader(_rExportFolder);
-    if (m_open_iso->GetVolumeType() != DiscIO::IVolume::WII_DISC)
+    if (m_open_iso->GetVolumeType() != DiscIO::Platform::WII_DISC)
       fs->ExportDOL(_rExportFolder);
   }
   else
@@ -913,7 +913,7 @@ void CISOProperties::OnExtractDir(wxCommandEvent& event)
 
   if (event.GetId() == IDM_EXTRACTALL)
   {
-    if (m_open_iso->GetVolumeType() == DiscIO::IVolume::WII_DISC)
+    if (m_open_iso->GetVolumeType() == DiscIO::Platform::WII_DISC)
     {
       wxTreeItemIdValue cookie;
       wxTreeItemId root = m_Treectrl->GetRootItem();
@@ -943,7 +943,7 @@ void CISOProperties::OnExtractDir(wxCommandEvent& event)
 
   Directory += DIR_SEP_CHR;
 
-  if (m_open_iso->GetVolumeType() == DiscIO::IVolume::WII_DISC)
+  if (m_open_iso->GetVolumeType() == DiscIO::Platform::WII_DISC)
   {
     const wxTreeItemId tree_selection = m_Treectrl->GetSelection();
     WiiPartition* partition =
@@ -967,7 +967,7 @@ void CISOProperties::OnExtractDataFromHeader(wxCommandEvent& event)
   if (Path.empty())
     return;
 
-  if (m_open_iso->GetVolumeType() == DiscIO::IVolume::WII_DISC)
+  if (m_open_iso->GetVolumeType() == DiscIO::Platform::WII_DISC)
   {
     WiiPartition* partition =
         reinterpret_cast<WiiPartition*>(m_Treectrl->GetItemData(m_Treectrl->GetSelection()));
@@ -1011,7 +1011,7 @@ void CISOProperties::CheckPartitionIntegrity(wxCommandEvent& event)
 {
   // Normally we can't enter this function if we aren't analyzing a Wii disc
   // anyway, but let's still check to be sure.
-  if (m_open_iso->GetVolumeType() != DiscIO::IVolume::WII_DISC)
+  if (m_open_iso->GetVolumeType() != DiscIO::Platform::WII_DISC)
     return;
 
   wxProgressDialog dialog(_("Checking integrity..."), _("Working..."), 1000, this,
@@ -1546,7 +1546,7 @@ void CISOProperties::OnChangeBannerLang(wxCommandEvent& event)
   ChangeBannerDetails(OpenGameListItem.GetLanguages()[event.GetSelection()]);
 }
 
-void CISOProperties::ChangeBannerDetails(DiscIO::IVolume::ELanguage language)
+void CISOProperties::ChangeBannerDetails(DiscIO::Language language)
 {
   wxString const name = StrToWxStr(OpenGameListItem.GetName(language));
   wxString const comment = StrToWxStr(OpenGameListItem.GetDescription(language));

Source/Core/DolphinWX/ISOProperties.h

@@ -17,7 +17,6 @@
 #include "Core/ActionReplay.h"
 #include "DiscIO/Filesystem.h"
 #include "DiscIO/Volume.h"
-#include "DiscIO/VolumeCreator.h"
 #include "DolphinWX/ARCodeAddEdit.h"
 #include "DolphinWX/ISOFile.h"
 #include "DolphinWX/PatchAddEdit.h"
@@ -35,7 +34,7 @@ class wxTreeCtrl;
 
 namespace DiscIO
 {
-struct SFileInfo;
+enum class Language;
 }
 namespace Gecko
 {
@@ -242,7 +241,7 @@ private:
   void PatchList_Save();
   void ActionReplayList_Load();
   void ActionReplayList_Save();
-  void ChangeBannerDetails(DiscIO::IVolume::ELanguage language);
+  void ChangeBannerDetails(DiscIO::Language language);
 
   long GetElementStyle(const char* section, const char* key);
   void SetCheckboxValueFromGameini(const char* section, const char* key, wxCheckBox* checkbox);

Source/Core/DolphinWX/NetPlay/NetWindow.cpp

@@ -34,6 +34,8 @@
 #include "Core/NetPlayProto.h"
 #include "Core/NetPlayServer.h"
 
+#include "DiscIO/Enums.h"
+
 #include "DolphinWX/Frame.h"
 #include "DolphinWX/GameListCtrl.h"
 #include "DolphinWX/ISOFile.h"
@@ -69,7 +71,7 @@ static wxString FailureReasonStringForHostLabel(int reason)
 static std::string BuildGameName(const GameListItem& game)
 {
   // Lang needs to be consistent
-  DiscIO::IVolume::ELanguage const lang = DiscIO::IVolume::LANGUAGE_ENGLISH;
+  const DiscIO::Language lang = DiscIO::Language::LANGUAGE_ENGLISH;
   std::vector<std::string> info;
   if (!game.GetUniqueID().empty())
     info.push_back(game.GetUniqueID());