Skip to content
Permalink
Browse files

DiscIO: Add functions CreateDisc and CreateWAD

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

Lets code easily add constraints such as not letting the user
select a WAD file when using the disc changing functionality.
  • Loading branch information...
JosJuice committed Jul 14, 2019
1 parent a77b571 commit 0f5a4b37ee8e00210b211953969f10bfb48c5aaa
@@ -161,10 +161,10 @@ BootParameters::GenerateFromFile(std::vector<std::string> paths,
{".gcm", ".iso", ".tgc", ".wbfs", ".ciso", ".gcz", ".dol", ".elf"}};
if (disc_image_extensions.find(extension) != disc_image_extensions.end() || is_drive)
{
std::unique_ptr<DiscIO::Volume> volume = DiscIO::CreateVolumeFromFilename(path);
if (volume)
std::unique_ptr<DiscIO::VolumeDisc> disc = DiscIO::CreateDisc(path);
if (disc)
{
return std::make_unique<BootParameters>(Disc{std::move(path), std::move(volume), paths},
return std::make_unique<BootParameters>(Disc{std::move(path), std::move(disc), paths},
savestate_path);
}

@@ -221,19 +221,19 @@ BootParameters::IPL::IPL(DiscIO::Region region_, Disc&& disc_) : IPL(region_)
// Inserts a disc into the emulated disc drive and returns a pointer to it.
// The returned pointer must only be used while we are still booting,
// because DVDThread can do whatever it wants to the disc after that.
static const DiscIO::Volume* SetDisc(std::unique_ptr<DiscIO::Volume> volume,
std::vector<std::string> auto_disc_change_paths = {})
static const DiscIO::VolumeDisc* SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
std::vector<std::string> auto_disc_change_paths = {})
{
const DiscIO::Volume* pointer = volume.get();
DVDInterface::SetDisc(std::move(volume), auto_disc_change_paths);
const DiscIO::VolumeDisc* pointer = disc.get();
DVDInterface::SetDisc(std::move(disc), auto_disc_change_paths);
return pointer;
}

bool CBoot::DVDRead(const DiscIO::Volume& volume, u64 dvd_offset, u32 output_address, u32 length,
bool CBoot::DVDRead(const DiscIO::VolumeDisc& disc, u64 dvd_offset, u32 output_address, u32 length,
const DiscIO::Partition& partition)
{
std::vector<u8> buffer(length);
if (!volume.Read(dvd_offset, length, buffer.data(), partition))
if (!disc.Read(dvd_offset, length, buffer.data(), partition))
return false;
Memory::CopyToEmu(output_address, buffer.data(), length);
return true;
@@ -365,7 +365,7 @@ static void SetDefaultDisc()
{
const std::string default_iso = Config::Get(Config::MAIN_DEFAULT_ISO);
if (!default_iso.empty())
SetDisc(DiscIO::CreateVolumeFromFilename(default_iso));
SetDisc(DiscIO::CreateDisc(default_iso));
}

static void CopyDefaultExceptionHandlers()
@@ -401,7 +401,8 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
bool operator()(BootParameters::Disc& disc) const
{
NOTICE_LOG(BOOT, "Booting from disc: %s", disc.path.c_str());
const DiscIO::Volume* volume = SetDisc(std::move(disc.volume), disc.auto_disc_change_paths);
const DiscIO::VolumeDisc* volume =
SetDisc(std::move(disc.volume), disc.auto_disc_change_paths);

if (!volume)
return false;
@@ -495,7 +496,7 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
if (ipl.disc)
{
NOTICE_LOG(BOOT, "Inserting disc: %s", ipl.disc->path.c_str());
SetDisc(DiscIO::CreateVolumeFromFilename(ipl.disc->path), ipl.disc->auto_disc_change_paths);
SetDisc(DiscIO::CreateDisc(ipl.disc->path), ipl.disc->auto_disc_change_paths);
}

if (LoadMapFromFilename())
@@ -39,7 +39,7 @@ struct BootParameters
struct Disc
{
std::string path;
std::unique_ptr<DiscIO::Volume> volume;
std::unique_ptr<DiscIO::VolumeDisc> volume;
std::vector<std::string> auto_disc_change_paths;
};

@@ -102,8 +102,8 @@ class CBoot
static bool LoadMapFromFilename();

private:
static bool DVDRead(const DiscIO::Volume& volume, u64 dvd_offset, u32 output_address, u32 length,
const DiscIO::Partition& partition);
static bool DVDRead(const DiscIO::VolumeDisc& disc, u64 dvd_offset, u32 output_address,
u32 length, const DiscIO::Partition& partition);
static void RunFunction(u32 address);

static void UpdateDebugger_MapLoaded();
@@ -113,10 +113,10 @@ class CBoot

static void SetupMSR();
static void SetupBAT(bool is_wii);
static bool RunApploader(bool is_wii, const DiscIO::Volume& volume);
static bool EmulatedBS2_GC(const DiscIO::Volume& volume);
static bool EmulatedBS2_Wii(const DiscIO::Volume& volume);
static bool EmulatedBS2(bool is_wii, const DiscIO::Volume& volume);
static bool RunApploader(bool is_wii, const DiscIO::VolumeDisc& volume);
static bool EmulatedBS2_GC(const DiscIO::VolumeDisc& volume);
static bool EmulatedBS2_Wii(const DiscIO::VolumeDisc& volume);
static bool EmulatedBS2(bool is_wii, const DiscIO::VolumeDisc& volume);
static bool Load_BS2(const std::string& boot_rom_filename);

static void SetupGCMemory();
@@ -85,7 +85,7 @@ void CBoot::SetupBAT(bool is_wii)
PowerPC::IBATUpdated();
}

bool CBoot::RunApploader(bool is_wii, const DiscIO::Volume& volume)
bool CBoot::RunApploader(bool is_wii, const DiscIO::VolumeDisc& volume)
{
const DiscIO::Partition partition = volume.GetGamePartition();

@@ -200,7 +200,7 @@ void CBoot::SetupGCMemory()
// GameCube Bootstrap 2 HLE:
// copy the apploader to 0x81200000
// execute the apploader, function by function, using the above utility.
bool CBoot::EmulatedBS2_GC(const DiscIO::Volume& volume)
bool CBoot::EmulatedBS2_GC(const DiscIO::VolumeDisc& volume)
{
INFO_LOG(BOOT, "Faking GC BS2...");

@@ -366,7 +366,7 @@ static void WriteEmptyPlayRecord()
// Wii Bootstrap 2 HLE:
// copy the apploader to 0x81200000
// execute the apploader
bool CBoot::EmulatedBS2_Wii(const DiscIO::Volume& volume)
bool CBoot::EmulatedBS2_Wii(const DiscIO::VolumeDisc& volume)
{
INFO_LOG(BOOT, "Faking Wii BS2...");
if (volume.GetVolumeType() != DiscIO::Platform::WiiDisc)
@@ -426,7 +426,7 @@ bool CBoot::EmulatedBS2_Wii(const DiscIO::Volume& volume)

// Returns true if apploader has run successfully. If is_wii is true, the disc
// that volume refers to must currently be inserted into the emulated disc drive.
bool CBoot::EmulatedBS2(bool is_wii, const DiscIO::Volume& volume)
bool CBoot::EmulatedBS2(bool is_wii, const DiscIO::VolumeDisc& volume)
{
return is_wii ? EmulatedBS2_Wii(volume) : EmulatedBS2_GC(volume);
}
@@ -470,7 +470,7 @@ void Shutdown()
DVDThread::Stop();
}

void SetDisc(std::unique_ptr<DiscIO::Volume> disc,
void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
std::optional<std::vector<std::string>> auto_disc_change_paths = {})
{
if (disc)
@@ -506,11 +506,10 @@ static void EjectDiscCallback(u64 userdata, s64 cyclesLate)

static void InsertDiscCallback(u64 userdata, s64 cyclesLate)
{
std::unique_ptr<DiscIO::Volume> new_volume =
DiscIO::CreateVolumeFromFilename(s_disc_path_to_insert);
std::unique_ptr<DiscIO::VolumeDisc> new_disc = DiscIO::CreateDisc(s_disc_path_to_insert);

if (new_volume)
SetDisc(std::move(new_volume), {});
if (new_disc)
SetDisc(std::move(new_disc), {});
else
PanicAlertT("The disc that was about to be inserted couldn't be found.");

@@ -14,7 +14,7 @@
class PointerWrap;
namespace DiscIO
{
class Volume;
class VolumeDisc;
struct Partition;
} // namespace DiscIO
namespace MMIO
@@ -81,7 +81,7 @@ void DoState(PointerWrap& p);

void RegisterMMIO(MMIO::Mapping* mmio, u32 base);

void SetDisc(std::unique_ptr<DiscIO::Volume> disc,
void SetDisc(std::unique_ptr<DiscIO::VolumeDisc> disc,
std::optional<std::vector<std::string>> auto_disc_change_paths);
bool IsDiscInside();
void EjectDisc(); // Must only be called on the CPU thread
@@ -581,8 +581,7 @@ class DiscSystemUpdater final : public SystemUpdater
{
public:
DiscSystemUpdater(UpdateCallback update_callback, const std::string& image_path)
: m_update_callback{std::move(update_callback)}, m_volume{DiscIO::CreateVolumeFromFilename(
image_path)}
: m_update_callback{std::move(update_callback)}, m_volume{DiscIO::CreateDisc(image_path)}
{
}
UpdateResult DoDiscUpdate();
@@ -621,7 +620,7 @@ class DiscSystemUpdater final : public SystemUpdater
std::string_view path);

UpdateCallback m_update_callback;
std::unique_ptr<DiscIO::Volume> m_volume;
std::unique_ptr<DiscIO::VolumeDisc> m_volume;
DiscIO::Partition m_partition;
};

@@ -182,10 +182,10 @@ bool CompressFileToBlob(const std::string& infile_path, const std::string& outfi
}

DiscScrubber disc_scrubber;
std::unique_ptr<Volume> volume;
std::unique_ptr<VolumeDisc> volume;
if (sub_type == 1)
{
volume = CreateVolumeFromFilename(infile_path);
volume = CreateDisc(infile_path);
if (!volume || !disc_scrubber.SetupScrub(volume.get(), block_size))
{
PanicAlertT("\"%s\" failed to be scrubbed. Probably the image is corrupt.",
@@ -223,7 +223,7 @@ bool FileInfoGCWii::IsValid(u64 fst_size, const FileInfoGCWii& parent_directory)
return true;
}

FileSystemGCWii::FileSystemGCWii(const Volume* volume, const Partition& partition)
FileSystemGCWii::FileSystemGCWii(const VolumeDisc* volume, const Partition& partition)
: m_valid(false), m_root(nullptr, 0, 0, 0)
{
u8 offset_shift;
@@ -17,7 +17,7 @@

namespace DiscIO
{
class Volume;
class VolumeDisc;
struct Partition;

class FileInfoGCWii : public FileInfo
@@ -87,7 +87,7 @@ class FileInfoGCWii : public FileInfo
class FileSystemGCWii : public FileSystem
{
public:
FileSystemGCWii(const Volume* volume, const Partition& partition);
FileSystemGCWii(const VolumeDisc* volume, const Partition& partition);
~FileSystemGCWii() override;

bool IsValid() const override { return m_valid; }
@@ -43,30 +43,61 @@ std::map<Language, std::string> Volume::ReadWiiNames(const std::vector<char16_t>
return names;
}

std::unique_ptr<Volume> CreateVolumeFromFilename(const std::string& filename)
static std::unique_ptr<VolumeDisc> CreateDisc(std::unique_ptr<BlobReader>& reader)
{
std::unique_ptr<BlobReader> reader(CreateBlobReader(filename));
if (reader == nullptr)
return nullptr;

// Check for Wii
const std::optional<u32> wii_magic = reader->ReadSwapped<u32>(0x18);
if (wii_magic == u32(0x5D1C9EA3))
return std::make_unique<VolumeWii>(std::move(reader));

// Check for GC
const std::optional<u32> gc_magic = reader->ReadSwapped<u32>(0x1C);
if (gc_magic == u32(0xC2339F3D))
return std::make_unique<VolumeGC>(std::move(reader));

// No known magic words found
return nullptr;
}

std::unique_ptr<VolumeDisc> CreateDisc(const std::string& path)
{
std::unique_ptr<BlobReader> reader(CreateBlobReader(path));
return reader ? CreateDisc(reader) : nullptr;
}

static std::unique_ptr<VolumeWAD> CreateWAD(std::unique_ptr<BlobReader>& reader)
{
// Check for WAD
// 0x206962 for boot2 wads
const std::optional<u32> wad_magic = reader->ReadSwapped<u32>(0x02);
if (wad_magic == u32(0x00204973) || wad_magic == u32(0x00206962))
return std::make_unique<VolumeWAD>(std::move(reader));

// Check for GC
const std::optional<u32> gc_magic = reader->ReadSwapped<u32>(0x1C);
if (gc_magic == u32(0xC2339F3D))
return std::make_unique<VolumeGC>(std::move(reader));

// No known magic words found
return nullptr;
}

std::unique_ptr<VolumeWAD> CreateWAD(const std::string& path)
{
std::unique_ptr<BlobReader> reader(CreateBlobReader(path));
return reader ? CreateWAD(reader) : nullptr;
}

std::unique_ptr<Volume> CreateVolume(const std::string& path)
{
std::unique_ptr<BlobReader> reader(CreateBlobReader(path));
if (reader == nullptr)
return nullptr;

std::unique_ptr<VolumeDisc> disc = CreateDisc(reader);
if (disc)
return disc;

std::unique_ptr<VolumeWAD> wad = CreateWAD(reader);
if (wad)
return wad;

return nullptr;
}

} // namespace DiscIO
@@ -22,6 +22,7 @@ namespace DiscIO
{
enum class BlobType;
class FileSystem;
class VolumeWAD;

struct Partition final
{
@@ -141,6 +142,12 @@ class Volume
static const std::vector<u8> INVALID_CERT_CHAIN;
};

std::unique_ptr<Volume> CreateVolumeFromFilename(const std::string& filename);
class VolumeDisc : public Volume
{
};

std::unique_ptr<VolumeDisc> CreateDisc(const std::string& path);
std::unique_ptr<VolumeWAD> CreateWAD(const std::string& path);
std::unique_ptr<Volume> CreateVolume(const std::string& path);

} // namespace DiscIO
@@ -25,7 +25,7 @@ enum class Language;
enum class Region;
enum class Platform;

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

class VolumeWii : public Volume
class VolumeWii : public VolumeDisc
{
public:
VolumeWii(std::unique_ptr<BlobReader> reader);
@@ -60,7 +60,7 @@ PropertiesDialog::PropertiesDialog(QWidget* parent, const UICommon::GameFile& ga

if (game.GetPlatform() != DiscIO::Platform::ELFOrDOL)
{
std::shared_ptr<DiscIO::Volume> volume = DiscIO::CreateVolumeFromFilename(game.GetFilePath());
std::shared_ptr<DiscIO::Volume> volume = DiscIO::CreateVolume(game.GetFilePath());
if (volume)
{
VerifyWidget* verify = new VerifyWidget(volume);
@@ -121,7 +121,7 @@ GameFile::GameFile(std::string path) : m_file_path(std::move(path))
SplitPath(m_file_path, nullptr, &name, &extension);
m_file_name = name + extension;

std::unique_ptr<DiscIO::Volume> volume(DiscIO::CreateVolumeFromFilename(m_file_path));
std::unique_ptr<DiscIO::Volume> volume(DiscIO::CreateVolume(m_file_path));
if (volume != nullptr)
{
m_platform = volume->GetVolumeType();

0 comments on commit 0f5a4b3

Please sign in to comment.
You can’t perform that action at this time.