ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #8243 from JosJuice/merge-wad-classes 

DiscIO: Merge WiiWAD into VolumeWAD
This commit is contained in:
Léo Lam 2019-07-21 15:32:52 +08:00 committed by GitHub
parent cd7a374ab9 34f32898e6
commit da1fbbc5d5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 142 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Source/Core/Core/Boot/Boot.cpp
View File

@ -59,6 +59,7 @@ namespace fs = std::filesystem;
#include "DiscIO/Enums.h"
#include "DiscIO/Volume.h"
#include "DiscIO/VolumeWad.h"
static std::vector<std::string> ReadM3UFile(const std::string& m3u_path,
const std::string& folder_path)
@ -161,10 +162,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);
}
@ -201,7 +202,11 @@ BootParameters::GenerateFromFile(std::vector<std::string> paths,
return std::make_unique<BootParameters>(DFF{std::move(path)}, savestate_path);
if (extension == ".wad")
return std::make_unique<BootParameters>(DiscIO::WiiWAD{std::move(path)}, savestate_path);
{
std::unique_ptr<DiscIO::VolumeWAD> wad = DiscIO::CreateWAD(std::move(path));
if (wad)
return std::make_unique<BootParameters>(std::move(*wad), savestate_path);
}
PanicAlertT("Could not recognize file %s", path.c_str());
return {};
@ -221,19 +226,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 +370,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 +406,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;
@ -465,7 +471,7 @@ bool CBoot::BootUp(std::unique_ptr<BootParameters> boot)
return true;
}
bool operator()(const DiscIO::WiiWAD& wad) const
bool operator()(const DiscIO::VolumeWAD& wad) const
{
SetDefaultDisc();
return Boot_WiiWAD(wad);
@ -495,7 +501,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())

20
Source/Core/Core/Boot/Boot.h
View File

@ -17,7 +17,7 @@
#include "DiscIO/Blob.h"
#include "DiscIO/Enums.h"
#include "DiscIO/Volume.h"
#include "DiscIO/WiiWad.h"
#include "DiscIO/VolumeWad.h"
namespace File
{
@ -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;
};
@ -75,7 +75,7 @@ struct BootParameters
GenerateFromFile(std::vector<std::string> paths,
const std::optional<std::string>& savestate_path = {});
using Parameters = std::variant<Disc, Executable, DiscIO::WiiWAD, NANDTitle, IPL, DFF>;
using Parameters = std::variant<Disc, Executable, DiscIO::VolumeWAD, NANDTitle, IPL, DFF>;
BootParameters(Parameters&& parameters_, const std::optional<std::string>& savestate_path_ = {});
Parameters parameters;
@ -102,21 +102,21 @@ public:
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();
static bool Boot_WiiWAD(const DiscIO::WiiWAD& wad);
static bool Boot_WiiWAD(const DiscIO::VolumeWAD& wad);
static bool BootNANDTitle(u64 title_id);
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();

8
Source/Core/Core/Boot/Boot_BS2Emu.cpp
View File

@ -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);
}

4
Source/Core/Core/Boot/Boot_WiiWAD.cpp
View File

@ -15,7 +15,7 @@
#include "Core/IOS/IOS.h"
#include "Core/IOS/IOSC.h"
#include "Core/WiiUtils.h"
#include "DiscIO/WiiWad.h"
#include "DiscIO/VolumeWad.h"
bool CBoot::BootNANDTitle(const u64 title_id)
{
@ -34,7 +34,7 @@ bool CBoot::BootNANDTitle(const u64 title_id)
return es->LaunchTitle(title_id);
}
bool CBoot::Boot_WiiWAD(const DiscIO::WiiWAD& wad)
bool CBoot::Boot_WiiWAD(const DiscIO::VolumeWAD& wad)
{
if (!WiiUtils::InstallWAD(*IOS::HLE::GetIOS(), wad, WiiUtils::InstallType::Temporary))
{

6
Source/Core/Core/ConfigManager.cpp
View File

@ -49,7 +49,7 @@
#include "DiscIO/Enums.h"
#include "DiscIO/Volume.h"
#include "DiscIO/WiiWad.h"
#include "DiscIO/VolumeWad.h"
SConfig* SConfig::m_Instance;
@ -888,9 +888,9 @@ struct SetGameMetadata
return true;
}
bool operator()(const DiscIO::WiiWAD& wad) const
bool operator()(const DiscIO::VolumeWAD& wad) const
{
if (!wad.IsValid() || !wad.GetTMD().IsValid())
if (!wad.GetTMD().IsValid())
{
PanicAlertT("This WAD is not valid.");
return false;

9
Source/Core/Core/HW/DVD/DVDInterface.cpp
View File

@ -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.");

4
Source/Core/Core/HW/DVD/DVDInterface.h
View File

@ -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

21
Source/Core/Core/WiiUtils.cpp
View File

@ -42,13 +42,13 @@
#include "DiscIO/Filesystem.h"
#include "DiscIO/Volume.h"
#include "DiscIO/VolumeFileBlobReader.h"
#include "DiscIO/WiiWad.h"
#include "DiscIO/VolumeWad.h"
namespace WiiUtils
{
static bool ImportWAD(IOS::HLE::Kernel& ios, const DiscIO::WiiWAD& wad)
static bool ImportWAD(IOS::HLE::Kernel& ios, const DiscIO::VolumeWAD& wad)
{
if (!wad.IsValid())
if (!wad.GetTicket().IsValid() || !wad.GetTMD().IsValid())
{
PanicAlertT("WAD installation failed: The selected file is not a valid WAD.");
return false;
@ -110,7 +110,7 @@ static bool ImportWAD(IOS::HLE::Kernel& ios, const DiscIO::WiiWAD& wad)
return true;
}
bool InstallWAD(IOS::HLE::Kernel& ios, const DiscIO::WiiWAD& wad, InstallType install_type)
bool InstallWAD(IOS::HLE::Kernel& ios, const DiscIO::VolumeWAD& wad, InstallType install_type)
{
if (!wad.GetTMD().IsValid())
return false;
@ -164,8 +164,12 @@ bool InstallWAD(IOS::HLE::Kernel& ios, const DiscIO::WiiWAD& wad, InstallType in
bool InstallWAD(const std::string& wad_path)
{
std::unique_ptr<DiscIO::VolumeWAD> wad = DiscIO::CreateWAD(wad_path);
if (!wad)
return false;
IOS::HLE::Kernel ios;
return InstallWAD(ios, DiscIO::WiiWAD{wad_path}, InstallType::Permanent);
return InstallWAD(ios, *wad, InstallType::Permanent);
}
bool UninstallTitle(u64 title_id)
@ -581,8 +585,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 +624,7 @@ private:
std::string_view path);
UpdateCallback m_update_callback;
std::unique_ptr<DiscIO::Volume> m_volume;
std::unique_ptr<DiscIO::VolumeDisc> m_volume;
DiscIO::Partition m_partition;
};
@ -735,7 +738,7 @@ UpdateResult DiscSystemUpdater::ProcessEntry(u32 type, std::bitset<32> attrs,
ERROR_LOG(CORE, "Could not find %s", std::string(path).c_str());
return UpdateResult::DiscReadFailed;
}
const DiscIO::WiiWAD wad{std::move(blob)};
const DiscIO::VolumeWAD wad{std::move(blob)};
return ImportWAD(m_ios, wad) ? UpdateResult::Succeeded : UpdateResult::ImportFailed;
}

6
Source/Core/Core/WiiUtils.h
View File

@ -15,7 +15,7 @@
namespace DiscIO
{
class WiiWAD;
class VolumeWAD;
}
namespace IOS::HLE
@ -31,8 +31,8 @@ enum class InstallType
Temporary,
};
bool InstallWAD(IOS::HLE::Kernel& ios, const DiscIO::WiiWAD& wad, InstallType type);
// Same as the above, but constructs a temporary IOS and WiiWAD instance for importing
bool InstallWAD(IOS::HLE::Kernel& ios, const DiscIO::VolumeWAD& wad, InstallType type);
// Same as the above, but constructs a temporary IOS and VolumeWAD instance for importing
// and does a permanent install.
bool InstallWAD(const std::string& wad_path);

2
Source/Core/DiscIO/CMakeLists.txt
View File

@ -41,8 +41,6 @@ add_library(discio
WbfsBlob.h
WiiSaveBanner.cpp
WiiSaveBanner.h
WiiWad.cpp
WiiWad.h
)
target_link_libraries(discio

4
Source/Core/DiscIO/CompressedBlob.cpp
View File

@ -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.",

2
Source/Core/DiscIO/DiscIO.vcxproj
View File

@ -57,7 +57,6 @@
<ClCompile Include="VolumeWii.cpp" />
<ClCompile Include="WbfsBlob.cpp" />
<ClCompile Include="WiiSaveBanner.cpp" />
<ClCompile Include="WiiWad.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Blob.h" />
@ -81,7 +80,6 @@
<ClInclude Include="VolumeWii.h" />
<ClInclude Include="WbfsBlob.h" />
<ClInclude Include="WiiSaveBanner.h" />
<ClInclude Include="WiiWad.h" />
</ItemGroup>
<ItemGroup>
<Text Include="CMakeLists.txt" />

6
Source/Core/DiscIO/DiscIO.vcxproj.filters
View File

@ -30,9 +30,6 @@
<ClCompile Include="FileSystemGCWii.cpp">
<Filter>FileSystem</Filter>
</ClCompile>
<ClCompile Include="WiiWad.cpp">
<Filter>NAND</Filter>
</ClCompile>
<ClCompile Include="NANDImporter.cpp">
<Filter>NAND</Filter>
</ClCompile>
@ -98,9 +95,6 @@
<ClInclude Include="FileSystemGCWii.h">
<Filter>FileSystem</Filter>
</ClInclude>
<ClInclude Include="WiiWad.h">
<Filter>NAND</Filter>
</ClInclude>
<ClInclude Include="NANDImporter.h">
<Filter>NAND</Filter>
</ClInclude>

2
Source/Core/DiscIO/FileSystemGCWii.cpp
View File

@ -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;

4
Source/Core/DiscIO/FileSystemGCWii.h
View File

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

53
Source/Core/DiscIO/Volume.cpp
View File

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

10
Source/Core/DiscIO/Volume.h
View File

@ -22,6 +22,7 @@ namespace DiscIO
{
enum class BlobType;
class FileSystem;
class VolumeWAD;
struct Partition final
{
@ -73,6 +74,7 @@ public:
{
return INVALID_CERT_CHAIN;
}
virtual std::vector<u8> GetContent(u16 index) const { return {}; }
virtual std::vector<u64> GetContentOffsets() const { return {}; }
// Returns a non-owning pointer. Returns nullptr if the file system couldn't be read.
virtual const FileSystem* GetFileSystem(const Partition& partition) const = 0;
@ -141,6 +143,12 @@ protected:
static const std::vector<u8> INVALID_CERT_CHAIN;
};
std::unique_ptr<Volume> CreateVolumeFromFilename(const std::string& filename);
class VolumeDisc : public Volume
{
};
std::unique_ptr<VolumeDisc> CreateDisc(const std::string& path);
std::unique_ptr<VolumeWAD> CreateWAD(const std::string& path);
std::unique_ptr<Volume> CreateVolume(const std::string& path);
} // namespace DiscIO

2
Source/Core/DiscIO/VolumeGC.h
View File

@ -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);

9
Source/Core/DiscIO/VolumeVerifier.cpp
View File

@ -770,10 +770,7 @@ void VolumeVerifier::Process()
bool VolumeVerifier::CheckContentIntegrity(const IOS::ES::Content& content)
{
const u64 padded_size = Common::AlignUp(content.size, 0x40);
std::vector<u8> encrypted_data(padded_size);
m_volume.Read(m_content_offsets[m_content_index], padded_size, encrypted_data.data(),
PARTITION_NONE);
std::vector<u8> encrypted_data = m_volume.GetContent(content.index);
mbedtls_aes_context context;
const std::array<u8, 16> key = m_volume.GetTicket(PARTITION_NONE).GetTitleKey();
@ -783,8 +780,8 @@ bool VolumeVerifier::CheckContentIntegrity(const IOS::ES::Content& content)
iv[0] = static_cast<u8>(content.index >> 8);
iv[1] = static_cast<u8>(content.index & 0xFF);
std::vector<u8> decrypted_data(padded_size);
mbedtls_aes_crypt_cbc(&context, MBEDTLS_AES_DECRYPT, padded_size, iv.data(),
std::vector<u8> decrypted_data(Common::AlignUp(content.size, 0x40));
mbedtls_aes_crypt_cbc(&context, MBEDTLS_AES_DECRYPT, decrypted_data.size(), iv.data(),
encrypted_data.data(), decrypted_data.data());
std::array<u8, 20> sha1;

22
Source/Core/DiscIO/VolumeWad.cpp
View File

@ -61,10 +61,6 @@ VolumeWAD::VolumeWAD(std::unique_ptr<BlobReader> reader) : m_reader(std::move(re
Read(m_cert_chain_offset, m_cert_chain_size, m_cert_chain.data());
}
VolumeWAD::~VolumeWAD()
{
}
bool VolumeWAD::Read(u64 offset, u64 length, u8* buffer, const Partition& partition) const
{
if (partition != PARTITION_NONE)
@ -118,6 +114,24 @@ const std::vector<u8>& VolumeWAD::GetCertificateChain(const Partition& partition
return m_cert_chain;
}
std::vector<u8> VolumeWAD::GetContent(u16 index) const
{
u64 offset = m_data_offset;
for (const IOS::ES::Content& content : m_tmd.GetContents())
{
const u64 aligned_size = Common::AlignUp(content.size, 0x40);
if (content.index == index)
{
std::vector<u8> data(aligned_size);
if (!m_reader->Read(offset, aligned_size, data.data()))
return {};
return data;
}
offset += aligned_size;
}
return {};
}
std::vector<u64> VolumeWAD::GetContentOffsets() const
{
const std::vector<IOS::ES::Content> contents = m_tmd.GetContents();

2
Source/Core/DiscIO/VolumeWad.h
View File

@ -28,7 +28,6 @@ class VolumeWAD : public Volume
{
public:
VolumeWAD(std::unique_ptr<BlobReader> reader);
~VolumeWAD();
bool Read(u64 offset, u64 length, u8* buffer,
const Partition& partition = PARTITION_NONE) const override;
const FileSystem* GetFileSystem(const Partition& partition = PARTITION_NONE) const override;
@ -38,6 +37,7 @@ public:
const IOS::ES::TMDReader& GetTMD(const Partition& partition = PARTITION_NONE) const override;
const std::vector<u8>&
GetCertificateChain(const Partition& partition = PARTITION_NONE) const override;
std::vector<u8> GetContent(u16 index) const override;
std::vector<u64> GetContentOffsets() const override;
std::string GetGameID(const Partition& partition = PARTITION_NONE) const override;
std::string GetGameTDBID(const Partition& partition = PARTITION_NONE) const override;

2
Source/Core/DiscIO/VolumeWii.h
View File

@ -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);

112
Source/Core/DiscIO/WiiWad.cpp
View File

@ -1,112 +0,0 @@
// Copyright 2009 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include "Common/Align.h"
#include "Common/Assert.h"
#include "Common/CommonTypes.h"
#include "Common/FileUtil.h"
#include "Common/Logging/Log.h"
#include "DiscIO/Blob.h"
#include "DiscIO/WiiWad.h"
namespace DiscIO
{
namespace
{
std::vector<u8> CreateWADEntry(BlobReader& reader, u32 size, u64 offset)
{
if (size == 0)
return {};
std::vector<u8> buffer(size);
if (!reader.Read(offset, size, buffer.data()))
{
ERROR_LOG(DISCIO, "WiiWAD: Could not read from file");
PanicAlertT("WiiWAD: Could not read from file");
}
return buffer;
}
bool IsWiiWAD(BlobReader& reader)
{
const std::optional<u32> header_size = reader.ReadSwapped<u32>(0x0);
const std::optional<u32> header_type = reader.ReadSwapped<u32>(0x4);
return header_size == u32(0x20) &&
(header_type == u32(0x49730000) || header_type == u32(0x69620000));
}
} // Anonymous namespace
WiiWAD::WiiWAD(const std::string& name) : WiiWAD(CreateBlobReader(name))
{
}
WiiWAD::WiiWAD(std::unique_ptr<BlobReader> blob_reader) : m_reader(std::move(blob_reader))
{
if (m_reader)
m_valid = ParseWAD();
}
WiiWAD::~WiiWAD() = default;
bool WiiWAD::ParseWAD()
{
if (!IsWiiWAD(*m_reader))
return false;
std::optional<u32> certificate_chain_size = m_reader->ReadSwapped<u32>(0x08);
std::optional<u32> reserved = m_reader->ReadSwapped<u32>(0x0C);
std::optional<u32> ticket_size = m_reader->ReadSwapped<u32>(0x10);
std::optional<u32> tmd_size = m_reader->ReadSwapped<u32>(0x14);
std::optional<u32> data_app_size = m_reader->ReadSwapped<u32>(0x18);
std::optional<u32> footer_size = m_reader->ReadSwapped<u32>(0x1C);
if (!certificate_chain_size || !reserved || !ticket_size || !tmd_size || !data_app_size ||
!footer_size)
{
return false;
}
if (MAX_LOGLEVEL >= LogTypes::LOG_LEVELS::LDEBUG)
DEBUG_ASSERT_MSG(BOOT, *reserved == 0x00, "WiiWAD: Reserved must be 0x00");
u32 offset = 0x40;
m_certificate_chain = CreateWADEntry(*m_reader, *certificate_chain_size, offset);
offset += Common::AlignUp(*certificate_chain_size, 0x40);
m_ticket.SetBytes(CreateWADEntry(*m_reader, *ticket_size, offset));
offset += Common::AlignUp(*ticket_size, 0x40);
m_tmd.SetBytes(CreateWADEntry(*m_reader, *tmd_size, offset));
offset += Common::AlignUp(*tmd_size, 0x40);
m_data_app_offset = offset;
m_data_app = CreateWADEntry(*m_reader, *data_app_size, offset);
offset += Common::AlignUp(*data_app_size, 0x40);
m_footer = CreateWADEntry(*m_reader, *footer_size, offset);
offset += Common::AlignUp(*footer_size, 0x40);
return true;
}
std::vector<u8> WiiWAD::GetContent(u16 index) const
{
u64 offset = m_data_app_offset;
for (const IOS::ES::Content& content : m_tmd.GetContents())
{
const u64 aligned_size = Common::AlignUp(content.size, 0x40);
if (content.index == index)
{
std::vector<u8> data(aligned_size);
if (!m_reader->Read(offset, aligned_size, data.data()))
return {};
return data;
}
offset += aligned_size;
}
return {};
}
} // namespace DiscIO

49
Source/Core/DiscIO/WiiWad.h
View File

@ -1,49 +0,0 @@
// Copyright 2009 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#pragma once
#include <memory>
#include <string>
#include <vector>
#include "Common/CommonTypes.h"
#include "Core/IOS/ES/Formats.h"
namespace DiscIO
{
class BlobReader;
class WiiWAD
{
public:
explicit WiiWAD(const std::string& name);
explicit WiiWAD(std::unique_ptr<BlobReader> blob_reader);
WiiWAD(WiiWAD&&) = default;
WiiWAD& operator=(WiiWAD&&) = default;
~WiiWAD();
bool IsValid() const { return m_valid; }
const std::vector<u8>& GetCertificateChain() const { return m_certificate_chain; }
const IOS::ES::TicketReader& GetTicket() const { return m_ticket; }
const IOS::ES::TMDReader& GetTMD() const { return m_tmd; }
const std::vector<u8>& GetDataApp() const { return m_data_app; }
const std::vector<u8>& GetFooter() const { return m_footer; }
std::vector<u8> GetContent(u16 index) const;
private:
bool ParseWAD();
bool m_valid = false;
std::unique_ptr<BlobReader> m_reader;
u64 m_data_app_offset = 0;
std::vector<u8> m_certificate_chain;
IOS::ES::TicketReader m_ticket;
IOS::ES::TMDReader m_tmd;
std::vector<u8> m_data_app;
std::vector<u8> m_footer;
};
} // namespace DiscIO

2
Source/Core/DolphinQt/Config/PropertiesDialog.cpp
View File

@ -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);

2
Source/Core/UICommon/GameFile.cpp
View File

@ -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();