diff --git a/src/common/cd_image.cpp b/src/common/cd_image.cpp index 1d384e81..558a9ce4 100644 --- a/src/common/cd_image.cpp +++ b/src/common/cd_image.cpp @@ -6,7 +6,7 @@ #include Log_SetChannel(CDImage); -CDImage::CDImage() = default; +CDImage::CDImage(OpenFlags open_flags) : m_open_flags(open_flags) {} CDImage::~CDImage() = default; @@ -16,7 +16,7 @@ u32 CDImage::GetBytesPerSector(TrackMode mode) return sizes[static_cast(mode)]; } -std::unique_ptr CDImage::Open(const char* filename, Common::Error* error) +std::unique_ptr CDImage::Open(const char* filename, OpenFlags open_flags, Common::Error* error) { const char* extension; @@ -38,36 +38,36 @@ std::unique_ptr CDImage::Open(const char* filename, Common::Error* erro if (StringUtil::Strcasecmp(extension, ".cue") == 0) { - return OpenCueSheetImage(filename, error); + return OpenCueSheetImage(filename, open_flags, error); } else if (StringUtil::Strcasecmp(extension, ".bin") == 0 || StringUtil::Strcasecmp(extension, ".img") == 0 || StringUtil::Strcasecmp(extension, ".iso") == 0) { - return OpenBinImage(filename, error); + return OpenBinImage(filename, open_flags, error); } else if (StringUtil::Strcasecmp(extension, ".chd") == 0) { - return OpenCHDImage(filename, error); + return OpenCHDImage(filename, open_flags, error); } else if (StringUtil::Strcasecmp(extension, ".ecm") == 0) { - return OpenEcmImage(filename, error); + return OpenEcmImage(filename, open_flags, error); } else if (StringUtil::Strcasecmp(extension, ".mds") == 0) { - return OpenMdsImage(filename, error); + return OpenMdsImage(filename, open_flags, error); } else if (StringUtil::Strcasecmp(extension, ".pbp") == 0) { - return OpenPBPImage(filename, error); + return OpenPBPImage(filename, open_flags, error); } else if (StringUtil::Strcasecmp(extension, ".m3u") == 0) { - return OpenM3uImage(filename, error); + return OpenM3uImage(filename, open_flags, error); } if (IsDeviceName(filename)) - return OpenDeviceImage(filename, error); + return OpenDeviceImage(filename, open_flags, error); #undef CASE_COMPARE diff --git a/src/common/cd_image.h b/src/common/cd_image.h index 03d88b27..076c3606 100644 --- a/src/common/cd_image.h +++ b/src/common/cd_image.h @@ -15,7 +15,13 @@ class Error; class CDImage { public: - CDImage(); + enum class OpenFlags : u8 + { + None = 0, + PreCache = (1 << 0), // Pre-cache image to RAM, if supported. + }; + + CDImage(OpenFlags open_flags); virtual ~CDImage(); using LBA = u32; @@ -210,18 +216,19 @@ public: static bool IsDeviceName(const char* filename); // Opening disc image. - static std::unique_ptr Open(const char* filename, Common::Error* error); - static std::unique_ptr OpenBinImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenCueSheetImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenCHDImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenEcmImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenMdsImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenPBPImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenM3uImage(const char* filename, Common::Error* error); - static std::unique_ptr OpenDeviceImage(const char* filename, Common::Error* error); + static std::unique_ptr Open(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenBinImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenCueSheetImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenCHDImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenEcmImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenMdsImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenPBPImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenM3uImage(const char* filename, OpenFlags open_flags, Common::Error* error); + static std::unique_ptr OpenDeviceImage(const char* filename, OpenFlags open_flags, Common::Error* error); static std::unique_ptr CreateMemoryImage(CDImage* image, ProgressCallback* progress = ProgressCallback::NullProgressCallback); - static std::unique_ptr OverlayPPFPatch(const char* filename, std::unique_ptr parent_image, + static std::unique_ptr OverlayPPFPatch(const char* filename, OpenFlags open_flags, + std::unique_ptr parent_image, ProgressCallback* progress = ProgressCallback::NullProgressCallback); // Accessors. @@ -248,6 +255,7 @@ public: const std::vector& GetIndices() const { return m_indices; } const Track& GetTrack(u32 track) const; const Index& GetIndex(u32 i) const; + OpenFlags GetOpenFlags() const { return m_open_flags; } // Seek to data LBA. bool Seek(LBA lba); @@ -324,4 +332,8 @@ private: const Index* m_current_index = nullptr; LBA m_position_in_index = 0; LBA m_position_in_track = 0; + + OpenFlags m_open_flags; }; + +IMPLEMENT_ENUM_CLASS_BITWISE_OPERATORS(CDImage::OpenFlags); diff --git a/src/common/cd_image_bin.cpp b/src/common/cd_image_bin.cpp index b364348c..d71c7af6 100644 --- a/src/common/cd_image_bin.cpp +++ b/src/common/cd_image_bin.cpp @@ -9,7 +9,7 @@ Log_SetChannel(CDImageBin); class CDImageBin : public CDImage { public: - CDImageBin(); + CDImageBin(OpenFlags open_flags); ~CDImageBin() override; bool Open(const char* filename, Common::Error* error); @@ -27,7 +27,7 @@ private: CDSubChannelReplacement m_sbi; }; -CDImageBin::CDImageBin() = default; +CDImageBin::CDImageBin(OpenFlags open_flags) : CDImage(open_flags) {} CDImageBin::~CDImageBin() { @@ -133,9 +133,9 @@ bool CDImageBin::ReadSectorFromIndex(void* buffer, const Index& index, LBA lba_i return true; } -std::unique_ptr CDImage::OpenBinImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenBinImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->Open(filename, error)) return {}; diff --git a/src/common/cd_image_chd.cpp b/src/common/cd_image_chd.cpp index 682c25a5..49c601d0 100644 --- a/src/common/cd_image_chd.cpp +++ b/src/common/cd_image_chd.cpp @@ -44,7 +44,7 @@ static std::optional ParseTrackModeString(const char* str) class CDImageCHD : public CDImage { public: - CDImageCHD(); + CDImageCHD(OpenFlags open_flags); ~CDImageCHD() override; bool Open(const char* filename, Common::Error* error); @@ -75,7 +75,7 @@ private: CDSubChannelReplacement m_sbi; }; -CDImageCHD::CDImageCHD() = default; +CDImageCHD::CDImageCHD(OpenFlags open_flags) : CDImage(open_flags) {} CDImageCHD::~CDImageCHD() { @@ -108,6 +108,17 @@ bool CDImageCHD::Open(const char* filename, Common::Error* error) return false; } + if ((GetOpenFlags() & OpenFlags::PreCache) != OpenFlags::None) + { + const chd_error err = chd_precache(m_chd); + if (err != CHDERR_NONE) + { + Log_WarningPrintf("Failed to pre-cache CHD '%s': %s", filename, chd_error_string(err)); + if (error) + error->SetMessage(chd_error_string(err)); + } + } + const chd_header* header = chd_get_header(m_chd); m_hunk_size = header->hunkbytes; if ((m_hunk_size % CHD_CD_SECTOR_DATA_SIZE) != 0) @@ -374,9 +385,9 @@ bool CDImageCHD::ReadHunk(u32 hunk_index) return true; } -std::unique_ptr CDImage::OpenCHDImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenCHDImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->Open(filename, error)) return {}; diff --git a/src/common/cd_image_cue.cpp b/src/common/cd_image_cue.cpp index 8c7865b7..28bf45dd 100644 --- a/src/common/cd_image_cue.cpp +++ b/src/common/cd_image_cue.cpp @@ -14,7 +14,7 @@ Log_SetChannel(CDImageCueSheet); class CDImageCueSheet : public CDImage { public: - CDImageCueSheet(); + CDImageCueSheet(OpenFlags open_flags); ~CDImageCueSheet() override; bool OpenAndParse(const char* filename, Common::Error* error); @@ -37,7 +37,7 @@ private: CDSubChannelReplacement m_sbi; }; -CDImageCueSheet::CDImageCueSheet() = default; +CDImageCueSheet::CDImageCueSheet(OpenFlags open_flags) : CDImage(open_flags) {} CDImageCueSheet::~CDImageCueSheet() { @@ -330,9 +330,9 @@ bool CDImageCueSheet::ReadSectorFromIndex(void* buffer, const Index& index, LBA return true; } -std::unique_ptr CDImage::OpenCueSheetImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenCueSheetImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->OpenAndParse(filename, error)) return {}; diff --git a/src/common/cd_image_device.cpp b/src/common/cd_image_device.cpp index f41f57d9..68c1f3c0 100644 --- a/src/common/cd_image_device.cpp +++ b/src/common/cd_image_device.cpp @@ -66,7 +66,7 @@ static void DeinterleaveSubcode(const u8* subcode_in, u8* subcode_out) class CDImageDeviceWin32 : public CDImage { public: - CDImageDeviceWin32(); + CDImageDeviceWin32(OpenFlags open_flags); ~CDImageDeviceWin32() override; bool Open(const char* filename, Common::Error* error); @@ -101,7 +101,7 @@ private: std::array m_subq; }; -CDImageDeviceWin32::CDImageDeviceWin32() = default; +CDImageDeviceWin32::CDImageDeviceWin32(OpenFlags open_flags) : CDImage(open_flags) {} CDImageDeviceWin32::~CDImageDeviceWin32() { @@ -473,9 +473,9 @@ bool CDImageDeviceWin32::DetermineReadMode() return false; } -std::unique_ptr CDImage::OpenDeviceImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenDeviceImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->Open(filename, error)) return {}; @@ -525,7 +525,7 @@ bool CDImage::IsDeviceName(const char* filename) #else -std::unique_ptr CDImage::OpenDeviceImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenDeviceImage(const char* filename, OpenFlags open_flags, Common::Error* error) { return {}; } diff --git a/src/common/cd_image_ecm.cpp b/src/common/cd_image_ecm.cpp index 378f0fdf..176b5bb1 100644 --- a/src/common/cd_image_ecm.cpp +++ b/src/common/cd_image_ecm.cpp @@ -158,7 +158,7 @@ static void eccedc_generate(u8* sector, int type) class CDImageEcm : public CDImage { public: - CDImageEcm(); + CDImageEcm(OpenFlags open_flags); ~CDImageEcm() override; bool Open(const char* filename, Common::Error* error); @@ -213,7 +213,7 @@ private: CDSubChannelReplacement m_sbi; }; -CDImageEcm::CDImageEcm() = default; +CDImageEcm::CDImageEcm(OpenFlags open_flags) : CDImage(open_flags) {} CDImageEcm::~CDImageEcm() { @@ -546,9 +546,9 @@ bool CDImageEcm::ReadSectorFromIndex(void* buffer, const Index& index, LBA lba_i return true; } -std::unique_ptr CDImage::OpenEcmImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenEcmImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->Open(filename, error)) return {}; diff --git a/src/common/cd_image_m3u.cpp b/src/common/cd_image_m3u.cpp index 7c49b31a..74c5b2d7 100644 --- a/src/common/cd_image_m3u.cpp +++ b/src/common/cd_image_m3u.cpp @@ -13,7 +13,7 @@ Log_SetChannel(CDImageMemory); class CDImageM3u : public CDImage { public: - CDImageM3u(); + CDImageM3u(OpenFlags open_flags); ~CDImageM3u() override; bool Open(const char* path, Common::Error* Error); @@ -43,7 +43,7 @@ private: u32 m_current_image_index = UINT32_C(0xFFFFFFFF); }; -CDImageM3u::CDImageM3u() = default; +CDImageM3u::CDImageM3u(OpenFlags open_flags) : CDImage(open_flags) {} CDImageM3u::~CDImageM3u() = default; @@ -130,7 +130,7 @@ bool CDImageM3u::SwitchSubImage(u32 index, Common::Error* error) return true; const Entry& entry = m_entries[index]; - std::unique_ptr new_image = CDImage::Open(entry.filename.c_str(), error); + std::unique_ptr new_image = CDImage::Open(entry.filename.c_str(), GetOpenFlags(), error); if (!new_image) { Log_ErrorPrintf("Failed to load subimage %u (%s)", index, entry.filename.c_str()); @@ -173,9 +173,9 @@ bool CDImageM3u::ReadSubChannelQ(SubChannelQ* subq, const Index& index, LBA lba_ return m_current_image->ReadSubChannelQ(subq, index, lba_in_index); } -std::unique_ptr CDImage::OpenM3uImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenM3uImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->Open(filename, error)) return {}; diff --git a/src/common/cd_image_mds.cpp b/src/common/cd_image_mds.cpp index 21a63376..9a85e3cf 100644 --- a/src/common/cd_image_mds.cpp +++ b/src/common/cd_image_mds.cpp @@ -32,7 +32,7 @@ static_assert(sizeof(TrackEntry) == 0x50, "TrackEntry is 0x50 bytes"); class CDImageMds : public CDImage { public: - CDImageMds(); + CDImageMds(OpenFlags open_flags); ~CDImageMds() override; bool OpenAndParse(const char* filename, Common::Error* error); @@ -49,7 +49,7 @@ private: CDSubChannelReplacement m_sbi; }; -CDImageMds::CDImageMds() = default; +CDImageMds::CDImageMds(OpenFlags open_flags) : CDImage(open_flags) {} CDImageMds::~CDImageMds() { @@ -293,9 +293,9 @@ bool CDImageMds::ReadSectorFromIndex(void* buffer, const Index& index, LBA lba_i return true; } -std::unique_ptr CDImage::OpenMdsImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenMdsImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->OpenAndParse(filename, error)) return {}; diff --git a/src/common/cd_image_memory.cpp b/src/common/cd_image_memory.cpp index 1ce5eba8..afb32ead 100644 --- a/src/common/cd_image_memory.cpp +++ b/src/common/cd_image_memory.cpp @@ -10,7 +10,7 @@ Log_SetChannel(CDImageMemory); class CDImageMemory : public CDImage { public: - CDImageMemory(); + CDImageMemory(OpenFlags open_flags); ~CDImageMemory() override; bool CopyImage(CDImage* image, ProgressCallback* progress); @@ -27,7 +27,7 @@ private: CDSubChannelReplacement m_sbi; }; -CDImageMemory::CDImageMemory() = default; +CDImageMemory::CDImageMemory(OpenFlags open_flags) : CDImage(open_flags) {} CDImageMemory::~CDImageMemory() { @@ -143,7 +143,7 @@ bool CDImageMemory::ReadSectorFromIndex(void* buffer, const Index& index, LBA lb std::unique_ptr CDImage::CreateMemoryImage(CDImage* image, ProgressCallback* progress /* = ProgressCallback::NullProgressCallback */) { - std::unique_ptr memory_image = std::make_unique(); + std::unique_ptr memory_image = std::make_unique(image->GetOpenFlags()); if (!memory_image->CopyImage(image, progress)) return {}; diff --git a/src/common/cd_image_pbp.cpp b/src/common/cd_image_pbp.cpp index 0708192d..1e8cb67e 100644 --- a/src/common/cd_image_pbp.cpp +++ b/src/common/cd_image_pbp.cpp @@ -20,7 +20,7 @@ using FileSystem::FTell64; class CDImagePBP final : public CDImage { public: - CDImagePBP() = default; + CDImagePBP(OpenFlags open_flags) : CDImage(open_flags) {} ~CDImagePBP() override; bool Open(const char* filename, Common::Error* error); @@ -898,9 +898,9 @@ std::string CDImagePBP::GetSubImageMetadata(u32 index, const std::string_view& t return CDImage::GetSubImageMetadata(index, type); } -std::unique_ptr CDImage::OpenPBPImage(const char* filename, Common::Error* error) +std::unique_ptr CDImage::OpenPBPImage(const char* filename, OpenFlags open_flags, Common::Error* error) { - std::unique_ptr image = std::make_unique(); + std::unique_ptr image = std::make_unique(open_flags); if (!image->Open(filename, error)) return {}; diff --git a/src/common/cd_image_ppf.cpp b/src/common/cd_image_ppf.cpp index 50936c0f..7bccd58a 100644 --- a/src/common/cd_image_ppf.cpp +++ b/src/common/cd_image_ppf.cpp @@ -18,7 +18,7 @@ enum : u32 class CDImagePPF : public CDImage { public: - CDImagePPF(); + CDImagePPF(OpenFlags open_flags); ~CDImagePPF() override; bool Open(const char* filename, std::unique_ptr parent_image); @@ -46,7 +46,7 @@ private: u32 m_replacement_offset = 0; }; -CDImagePPF::CDImagePPF() = default; +CDImagePPF::CDImagePPF(OpenFlags open_flags) : CDImage(open_flags) {} CDImagePPF::~CDImagePPF() = default; @@ -429,10 +429,10 @@ bool CDImagePPF::ReadSectorFromIndex(void* buffer, const Index& index, LBA lba_i } std::unique_ptr -CDImage::OverlayPPFPatch(const char* filename, std::unique_ptr parent_image, +CDImage::OverlayPPFPatch(const char* filename, OpenFlags open_flags, std::unique_ptr parent_image, ProgressCallback* progress /* = ProgressCallback::NullProgressCallback */) { - std::unique_ptr ppf_image = std::make_unique(); + std::unique_ptr ppf_image = std::make_unique(open_flags); if (!ppf_image->Open(filename, std::move(parent_image))) return {}; diff --git a/src/core/host_interface.cpp b/src/core/host_interface.cpp index 520ae1a6..9995d08a 100644 --- a/src/core/host_interface.cpp +++ b/src/core/host_interface.cpp @@ -556,6 +556,7 @@ void HostInterface::SetDefaultSettings(SettingsInterface& si) si.SetIntValue("CDROM", "ReadaheadSectors", Settings::DEFAULT_CDROM_READAHEAD_SECTORS); si.SetBoolValue("CDROM", "RegionCheck", false); si.SetBoolValue("CDROM", "LoadImageToRAM", false); + si.SetBoolValue("CDROM", "PreCacheCHD", false); si.SetBoolValue("CDROM", "MuteCDAudio", false); si.SetIntValue("CDROM", "ReadSpeedup", 1); si.SetIntValue("CDROM", "SeekSpeedup", 1); diff --git a/src/core/settings.cpp b/src/core/settings.cpp index fabc20ec..17932207 100644 --- a/src/core/settings.cpp +++ b/src/core/settings.cpp @@ -250,6 +250,7 @@ void Settings::Load(SettingsInterface& si) cdrom_readahead_sectors = static_cast(si.GetIntValue("CDROM", "ReadaheadSectors", DEFAULT_CDROM_READAHEAD_SECTORS)); cdrom_region_check = si.GetBoolValue("CDROM", "RegionCheck", false); cdrom_load_image_to_ram = si.GetBoolValue("CDROM", "LoadImageToRAM", false); + cdrom_precache_chd = si.GetBoolValue("CDROM", "PreCacheCHD", false); cdrom_mute_cd_audio = si.GetBoolValue("CDROM", "MuteCDAudio", false); cdrom_read_speedup = si.GetIntValue("CDROM", "ReadSpeedup", 1); cdrom_seek_speedup = si.GetIntValue("CDROM", "SeekSpeedup", 1); @@ -434,6 +435,7 @@ void Settings::Save(SettingsInterface& si) const si.SetIntValue("CDROM", "ReadaheadSectors", cdrom_readahead_sectors); si.SetBoolValue("CDROM", "RegionCheck", cdrom_region_check); si.SetBoolValue("CDROM", "LoadImageToRAM", cdrom_load_image_to_ram); + si.SetBoolValue("CDROM", "PreCacheCHD", cdrom_precache_chd); si.SetBoolValue("CDROM", "MuteCDAudio", cdrom_mute_cd_audio); si.SetIntValue("CDROM", "ReadSpeedup", cdrom_read_speedup); si.SetIntValue("CDROM", "SeekSpeedup", cdrom_seek_speedup); diff --git a/src/core/settings.h b/src/core/settings.h index c7b2596a..3209a50e 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -160,6 +160,7 @@ struct Settings u8 cdrom_readahead_sectors = DEFAULT_CDROM_READAHEAD_SECTORS; bool cdrom_region_check = false; bool cdrom_load_image_to_ram = false; + bool cdrom_precache_chd = false; bool cdrom_mute_cd_audio = false; u32 cdrom_read_speedup = 1; u32 cdrom_seek_speedup = 1; diff --git a/src/core/system.cpp b/src/core/system.cpp index 2731f73d..9f638431 100644 --- a/src/core/system.cpp +++ b/src/core/system.cpp @@ -329,7 +329,7 @@ ConsoleRegion GetConsoleRegionForDiscRegion(DiscRegion region) std::string GetGameCodeForPath(const char* image_path, bool fallback_to_hash) { - std::unique_ptr cdi = CDImage::Open(image_path, nullptr); + std::unique_ptr cdi = CDImage::Open(image_path, CDImage::OpenFlags::None, nullptr); if (!cdi) return {}; @@ -615,7 +615,7 @@ std::optional GetRegionForPath(const char* image_path) else if (IsPsfFileName(image_path)) return GetRegionForPsf(image_path); - std::unique_ptr cdi = CDImage::Open(image_path, nullptr); + std::unique_ptr cdi = CDImage::Open(image_path, CDImage::OpenFlags::None, nullptr); if (!cdi) return {}; @@ -662,7 +662,11 @@ bool RecreateGPU(GPURenderer renderer, bool update_display /* = true*/) std::unique_ptr OpenCDImage(const char* path, Common::Error* error, bool force_preload, bool check_for_patches) { - std::unique_ptr media = CDImage::Open(path, error); + CDImage::OpenFlags open_flags = CDImage::OpenFlags::None; + if (g_settings.cdrom_precache_chd && !g_settings.cdrom_load_image_to_ram) + open_flags |= CDImage::OpenFlags::PreCache; + + std::unique_ptr media = CDImage::Open(path, open_flags, error); if (!media) return {}; @@ -692,7 +696,7 @@ std::unique_ptr OpenCDImage(const char* path, Common::Error* error, boo path, FileSystem::ReplaceExtension(FileSystem::GetDisplayNameFromPath(path), "ppf"))); if (FileSystem::FileExists(ppf_filename.c_str())) { - media = CDImage::OverlayPPFPatch(ppf_filename.c_str(), std::move(media)); + media = CDImage::OverlayPPFPatch(ppf_filename.c_str(), CDImage::OpenFlags::None, std::move(media)); if (!media) { g_host_interface->AddFormattedOSDMessage( diff --git a/src/duckstation-libretro/libretro_core_options.h b/src/duckstation-libretro/libretro_core_options.h index 8869018a..b82dbd53 100644 --- a/src/duckstation-libretro/libretro_core_options.h +++ b/src/duckstation-libretro/libretro_core_options.h @@ -213,6 +213,21 @@ struct retro_core_option_v2_definition option_defs_us[] = { }, "false" }, + { + "duckstation_CDROM.PreCacheCHD", + "Pre-cache CHD Images To RAM", + NULL, + "Pre-caches CHD CD-ROM images to RAM without decompressing them. Unlike the preload option, this option supports " + "M3U files. It is also faster and requires less RAM compared to preloading as it doesn't decompress the CHD.", + NULL, + "console", + { + { "true", "Enabled" }, + { "false", "Disabled" }, + { NULL, NULL }, + }, + "false" + }, { "duckstation_CDROM.MuteCDAudio", "Mute CD Audio", diff --git a/src/duckstation-libretro/libretro_host_interface.cpp b/src/duckstation-libretro/libretro_host_interface.cpp index 68336d68..fb63b228 100644 --- a/src/duckstation-libretro/libretro_host_interface.cpp +++ b/src/duckstation-libretro/libretro_host_interface.cpp @@ -782,6 +782,7 @@ bool LibretroHostInterface::UpdateCoreOptionsDisplay() static bool pgxp_enable_prev; static MultitapMode multitap_mode_prev; static bool vram_rewrite_replacements_prev; + static bool cdrom_preload_enable_prev; const CPUExecutionMode cpu_execution_mode = Settings::ParseCPUExecutionMode( @@ -806,15 +807,18 @@ bool LibretroHostInterface::UpdateCoreOptionsDisplay() const bool dual_multitap = (multitap_mode == MultitapMode::BothPorts); const bool vram_rewrite_replacements = (hardware_renderer && si.GetBoolValue("TextureReplacements", "EnableVRAMWriteReplacements", false)); + const bool cdrom_preload_enable = si.GetBoolValue("CDROM", "LoadImageToRAM", false); if (cpu_execution_mode == cpu_execution_mode_prev && pgxp_enable == pgxp_enable_prev && - multitap_mode == multitap_mode_prev && vram_rewrite_replacements == vram_rewrite_replacements_prev) + multitap_mode == multitap_mode_prev && vram_rewrite_replacements == vram_rewrite_replacements_prev && + cdrom_preload_enable == cdrom_preload_enable_prev) return false; cpu_execution_mode_prev = cpu_execution_mode; pgxp_enable_prev = pgxp_enable; multitap_mode_prev = multitap_mode; vram_rewrite_replacements_prev = vram_rewrite_replacements; + cdrom_preload_enable_prev = cdrom_preload_enable; struct retro_core_option_display option_display; @@ -912,6 +916,10 @@ bool LibretroHostInterface::UpdateCoreOptionsDisplay() option_display.key = "duckstation_TextureReplacements.PreloadTextures"; g_retro_environment_callback(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display); + option_display.visible = !cdrom_preload_enable; + option_display.key = "duckstation_CDROM.PreCacheCHD"; + g_retro_environment_callback(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display); + return true; } bool LibretroHostInterface::HasCoreVariablesChanged() diff --git a/src/duckstation-qt/consolesettingswidget.cpp b/src/duckstation-qt/consolesettingswidget.cpp index 212b995b..52bd9209 100644 --- a/src/duckstation-qt/consolesettingswidget.cpp +++ b/src/duckstation-qt/consolesettingswidget.cpp @@ -54,6 +54,7 @@ ConsoleSettingsWidget::ConsoleSettingsWidget(QtHostInterface* host_interface, QW SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromRegionCheck, "CDROM", "RegionCheck", false); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromLoadImageToRAM, "CDROM", "LoadImageToRAM", false); + SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromPreCacheCHD, "CDROM", "PreCacheCHD", false); SettingWidgetBinder::BindWidgetToBoolSetting(m_host_interface, m_ui.cdromLoadImagePatches, "CDROM", "LoadImagePatches", false); SettingWidgetBinder::BindWidgetToIntSetting(m_host_interface, m_ui.cdromSeekSpeedup, "CDROM", "SeekSpeedup", 1); @@ -97,6 +98,10 @@ ConsoleSettingsWidget::ConsoleSettingsWidget(QtHostInterface* host_interface, QW m_ui.cdromLoadImageToRAM, tr("Preload Image to RAM"), tr("Unchecked"), tr("Loads the game image into RAM. Useful for network paths that may become unreliable during gameplay. In some " "cases also eliminates stutter when games initiate audio track playback.")); + dialog->registerWidgetHelp( + m_ui.cdromPreCacheCHD, tr("Pre-cache CHD Images"), tr("Unchecked"), + tr("Pre-caches CHD CD-ROM images to RAM without decompressing them. Unlike the preload option, this option supports " + "M3U files. It is also faster and requires less RAM compared to preloading as it doesn't decompress the CHD.")); dialog->registerWidgetHelp(m_ui.cdromLoadImagePatches, tr("Apply Image Patches"), tr("Unchecked"), tr("Automatically applies patches to disc images when they are present in the same " "directory. Currently only PPF patches are supported with this option.")); @@ -113,10 +118,13 @@ ConsoleSettingsWidget::ConsoleSettingsWidget(QtHostInterface* host_interface, QW connect(m_ui.cpuClockSpeed, &QSlider::valueChanged, this, &ConsoleSettingsWidget::onCPUClockSpeedValueChanged); connect(m_ui.cdromReadSpeedup, QOverload::of(&QComboBox::currentIndexChanged), this, &ConsoleSettingsWidget::onCDROMReadSpeedupValueChanged); + connect(m_ui.cdromLoadImageToRAM, &QCheckBox::stateChanged, this, + &ConsoleSettingsWidget::updateCdromPreCacheCHDEnabled); connect(m_ui.multitapMode, QOverload::of(&QComboBox::currentIndexChanged), [this](int index) { emit multitapModeChanged(); }); calculateCPUClockValue(); + updateCdromPreCacheCHDEnabled(); } ConsoleSettingsWidget::~ConsoleSettingsWidget() = default; @@ -172,6 +180,11 @@ void ConsoleSettingsWidget::onCDROMReadSpeedupValueChanged(int value) m_host_interface->applySettings(); } +void ConsoleSettingsWidget::updateCdromPreCacheCHDEnabled() +{ + m_ui.cdromPreCacheCHD->setEnabled(!m_ui.cdromLoadImageToRAM->isChecked()); +} + void ConsoleSettingsWidget::calculateCPUClockValue() { const u32 numerator = static_cast(m_host_interface->GetIntSettingValue("CPU", "OverclockNumerator", 1)); diff --git a/src/duckstation-qt/consolesettingswidget.h b/src/duckstation-qt/consolesettingswidget.h index 90b4f124..e0afc53d 100644 --- a/src/duckstation-qt/consolesettingswidget.h +++ b/src/duckstation-qt/consolesettingswidget.h @@ -23,6 +23,7 @@ private Q_SLOTS: void onCPUClockSpeedValueChanged(int value); void updateCPUClockSpeedLabel(); void onCDROMReadSpeedupValueChanged(int value); + void updateCdromPreCacheCHDEnabled(); private: void calculateCPUClockValue(); diff --git a/src/duckstation-qt/consolesettingswidget.ui b/src/duckstation-qt/consolesettingswidget.ui index c1f1424f..fd4ef12f 100644 --- a/src/duckstation-qt/consolesettingswidget.ui +++ b/src/duckstation-qt/consolesettingswidget.ui @@ -272,13 +272,6 @@ - - - - Enable Region Check - - - @@ -286,13 +279,27 @@ - + + + + Enable Region Check + + + + Apply Image Patches + + + + Pre-cache CHD Images + + + diff --git a/src/duckstation-qt/gamepropertiesdialog.cpp b/src/duckstation-qt/gamepropertiesdialog.cpp index bdb6df41..f63c9ee0 100644 --- a/src/duckstation-qt/gamepropertiesdialog.cpp +++ b/src/duckstation-qt/gamepropertiesdialog.cpp @@ -62,7 +62,7 @@ void GamePropertiesDialog::populate(const GameListEntry* ge) const QString title_qstring(QString::fromStdString(ge->title)); std::string hash_code; - std::unique_ptr cdi(CDImage::Open(ge->path.c_str(), nullptr)); + std::unique_ptr cdi(CDImage::Open(ge->path.c_str(), CDImage::OpenFlags::None, nullptr)); if (cdi) { hash_code = System::GetGameHashCodeForImage(cdi.get()); @@ -253,7 +253,7 @@ void GamePropertiesDialog::populateTracksInfo(const std::string& image_path) m_ui.tracks->clearContents(); m_path = image_path; - std::unique_ptr image = CDImage::Open(image_path.c_str(), nullptr); + std::unique_ptr image = CDImage::Open(image_path.c_str(), CDImage::OpenFlags::None, nullptr); if (!image) return; @@ -972,7 +972,7 @@ void GamePropertiesDialog::computeTrackHashes(std::string& redump_keyword) if (m_path.empty()) return; - std::unique_ptr image = CDImage::Open(m_path.c_str(), nullptr); + std::unique_ptr image = CDImage::Open(m_path.c_str(), CDImage::OpenFlags::None, nullptr); if (!image) return; diff --git a/src/frontend-common/cheevos.cpp b/src/frontend-common/cheevos.cpp index 8c4e4892..3b1beb3a 100644 --- a/src/frontend-common/cheevos.cpp +++ b/src/frontend-common/cheevos.cpp @@ -969,7 +969,7 @@ void GameChanged() if (path.empty() || s_game_path == path) return; - std::unique_ptr cdi = CDImage::Open(path.c_str(), nullptr); + std::unique_ptr cdi = CDImage::Open(path.c_str(), CDImage::OpenFlags::None, nullptr); if (!cdi) { Log_ErrorPrintf("Failed to open temporary CD image '%s'", path.c_str()); @@ -1002,7 +1002,7 @@ void GameChanged(const std::string& path, CDImage* image) if (image && image->HasSubImages() && image->GetCurrentSubImage() != 0) { - std::unique_ptr image_copy(CDImage::Open(image->GetFileName().c_str(), nullptr)); + std::unique_ptr image_copy(CDImage::Open(image->GetFileName().c_str(), CDImage::OpenFlags::None, nullptr)); if (!image_copy) { Log_ErrorPrintf("Failed to reopen image '%s'", image->GetFileName().c_str()); diff --git a/src/frontend-common/fullscreen_ui.cpp b/src/frontend-common/fullscreen_ui.cpp index b79de8cb..a087cea3 100644 --- a/src/frontend-common/fullscreen_ui.cpp +++ b/src/frontend-common/fullscreen_ui.cpp @@ -1585,6 +1585,10 @@ void DrawSettingsWindow() "Preload Images to RAM", "Loads the game image into RAM. Useful for network paths that may become unreliable during gameplay.", &s_settings_copy.cdrom_load_image_to_ram); + settings_changed |= ToggleButton( + "Pre-cache CHD Images", + "Pre-caches CHD images to RAM without decompressing them.", + &s_settings_copy.cdrom_precache_chd); settings_changed |= ToggleButtonForNonSetting( "Apply Image Patches", "Automatically applies patches to disc images when they are present, currently only PPF is supported.", diff --git a/src/frontend-common/game_list.cpp b/src/frontend-common/game_list.cpp index 01d8372f..58d3fe07 100644 --- a/src/frontend-common/game_list.cpp +++ b/src/frontend-common/game_list.cpp @@ -146,7 +146,7 @@ bool GameList::GetGameListEntry(const std::string& path, GameListEntry* entry) if (System::IsPsfFileName(path.c_str())) return GetPsfListEntry(path.c_str(), entry); - std::unique_ptr cdi = CDImage::Open(path.c_str(), nullptr); + std::unique_ptr cdi = CDImage::Open(path.c_str(), CDImage::OpenFlags::None, nullptr); if (!cdi) return false;