Xargon/Duckstation
1
0
Fork 0
mirror of https://github.com/RetroDECK/Duckstation.git synced 2025-02-02 04:25:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

GameDatabase: Purge use of ByteStream

Browse source
This commit is contained in:
Stenzek 2024-07-28 22:00:30 +10:00
parent c83b5fdd05
commit 7aaaf7c575
No known key found for this signature in database
1 changed files with 71 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

175
src/core/game_database.cpp
View file

@ -10,7 +10,10 @@
#include "util/imgui_manager.h" #include "util/imgui_manager.h"
#include "common/assert.h" #include "common/assert.h"
#include "common/binary_reader_writer.h"
#include "common/byte_stream.h" #include "common/byte_stream.h"
#include "common/error.h"
#include "common/file_system.h"
#include "common/heterogeneous_containers.h" #include "common/heterogeneous_containers.h"
#include "common/log.h" #include "common/log.h"
#include "common/path.h" #include "common/path.h"
@ -862,37 +865,6 @@ std::string GameDatabase::Entry::GenerateCompatibilityReport() const
return std::string(ret.view()); return std::string(ret.view());
} }
template<typename T>
bool ReadOptionalFromStream(ByteStream* stream, std::optional<T>* dest)
{
bool has_value;
if (!stream->Read2(&has_value, sizeof(has_value)))
return false;
if (!has_value)
return true;
T value;
if (!stream->Read2(&value, sizeof(T)))
return false;
*dest = value;
return true;
}
template<typename T>
bool WriteOptionalToStream(ByteStream* stream, const std::optional<T>& src)
{
const bool has_value = src.has_value();
if (!stream->Write2(&has_value, sizeof(has_value)))
return false;
if (!has_value)
return true;
return stream->Write2(&src.value(), sizeof(T));
}
static std::string GetCacheFile() static std::string GetCacheFile()
{ {
return Path::Combine(EmuFolders::Cache, "gamedb.cache"); return Path::Combine(EmuFolders::Cache, "gamedb.cache");
@ -900,20 +872,20 @@ static std::string GetCacheFile()
bool GameDatabase::LoadFromCache() bool GameDatabase::LoadFromCache()
{ {
std::unique_ptr<ByteStream> stream( auto fp = FileSystem::OpenManagedCFile(GetCacheFile().c_str(), "rb");
ByteStream::OpenFile(GetCacheFile().c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED)); if (!fp)
if (!stream)
{ {
DEV_LOG("Cache does not exist, loading full database."); DEV_LOG("Cache does not exist, loading full database.");
return false; return false;
} }
BinaryFileReader reader(fp.get());
const u64 gamedb_ts = Host::GetResourceFileTimestamp("gamedb.yaml", false).value_or(0); const u64 gamedb_ts = Host::GetResourceFileTimestamp("gamedb.yaml", false).value_or(0);
u32 signature, version, num_entries, num_codes; u32 signature, version, num_entries, num_codes;
u64 file_gamedb_ts; u64 file_gamedb_ts;
if (!stream->ReadU32(&signature) || !stream->ReadU32(&version) || !stream->ReadU64(&file_gamedb_ts) || if (!reader.ReadU32(&signature) || !reader.ReadU32(&version) || !reader.ReadU64(&file_gamedb_ts) ||
!stream->ReadU32(&num_entries) || !stream->ReadU32(&num_codes) || signature != GAME_DATABASE_CACHE_SIGNATURE || !reader.ReadU32(&num_entries) || !reader.ReadU32(&num_codes) || signature != GAME_DATABASE_CACHE_SIGNATURE ||
version != GAME_DATABASE_CACHE_VERSION) version != GAME_DATABASE_CACHE_VERSION)
{ {
DEV_LOG("Cache header is corrupted or version mismatch."); DEV_LOG("Cache header is corrupted or version mismatch.");
@ -937,29 +909,23 @@ bool GameDatabase::LoadFromCache()
u8 compatibility; u8 compatibility;
u32 num_disc_set_serials; u32 num_disc_set_serials;
if (!stream->ReadSizePrefixedString(&entry.serial) || !stream->ReadSizePrefixedString(&entry.title) || if (!reader.ReadSizePrefixedString(&entry.serial) || !reader.ReadSizePrefixedString(&entry.title) ||
!stream->ReadSizePrefixedString(&entry.genre) || !stream->ReadSizePrefixedString(&entry.developer) || !reader.ReadSizePrefixedString(&entry.genre) || !reader.ReadSizePrefixedString(&entry.developer) ||
!stream->ReadSizePrefixedString(&entry.publisher) || !reader.ReadSizePrefixedString(&entry.publisher) ||
!stream->ReadSizePrefixedString(&entry.compatibility_version_tested) || !reader.ReadSizePrefixedString(&entry.compatibility_version_tested) ||
!stream->ReadSizePrefixedString(&entry.compatibility_comments) || !stream->ReadU64(&entry.release_date) || !reader.ReadSizePrefixedString(&entry.compatibility_comments) || !reader.ReadU64(&entry.release_date) ||
!stream->ReadU8(&entry.min_players) || !stream->ReadU8(&entry.max_players) || !reader.ReadU8(&entry.min_players) || !reader.ReadU8(&entry.max_players) || !reader.ReadU8(&entry.min_blocks) ||
!stream->ReadU8(&entry.min_blocks) || !stream->ReadU8(&entry.max_blocks) || !reader.ReadU8(&entry.max_blocks) || !reader.ReadU16(&entry.supported_controllers) ||
!stream->ReadU16(&entry.supported_controllers) || !stream->ReadU8(&compatibility) || !reader.ReadU8(&compatibility) || compatibility >= static_cast<u8>(GameDatabase::CompatibilityRating::Count) ||
compatibility >= static_cast<u8>(GameDatabase::CompatibilityRating::Count) || !reader.Read(bits.data(), num_bytes) || !reader.ReadOptionalT(&entry.display_active_start_offset) ||
!stream->Read2(bits.data(), num_bytes) || !reader.ReadOptionalT(&entry.display_active_end_offset) ||
!ReadOptionalFromStream(stream.get(), &entry.display_active_start_offset) || !reader.ReadOptionalT(&entry.display_line_start_offset) ||
!ReadOptionalFromStream(stream.get(), &entry.display_active_end_offset) || !reader.ReadOptionalT(&entry.display_line_end_offset) ||
!ReadOptionalFromStream(stream.get(), &entry.display_line_start_offset) || !reader.ReadOptionalT(&entry.display_deinterlacing_mode) || !reader.ReadOptionalT(&entry.dma_max_slice_ticks) ||
!ReadOptionalFromStream(stream.get(), &entry.display_line_end_offset) || !reader.ReadOptionalT(&entry.dma_halt_ticks) || !reader.ReadOptionalT(&entry.gpu_fifo_size) ||
!ReadOptionalFromStream(stream.get(), &entry.display_deinterlacing_mode) || !reader.ReadOptionalT(&entry.gpu_max_run_ahead) || !reader.ReadOptionalT(&entry.gpu_pgxp_tolerance) ||
!ReadOptionalFromStream(stream.get(), &entry.dma_max_slice_ticks) || !reader.ReadOptionalT(&entry.gpu_pgxp_depth_threshold) || !reader.ReadOptionalT(&entry.gpu_line_detect_mode) ||
!ReadOptionalFromStream(stream.get(), &entry.dma_halt_ticks) || !reader.ReadSizePrefixedString(&entry.disc_set_name) || !reader.ReadU32(&num_disc_set_serials))
!ReadOptionalFromStream(stream.get(), &entry.gpu_fifo_size) ||
!ReadOptionalFromStream(stream.get(), &entry.gpu_max_run_ahead) ||
!ReadOptionalFromStream(stream.get(), &entry.gpu_pgxp_tolerance) ||
!ReadOptionalFromStream(stream.get(), &entry.gpu_pgxp_depth_threshold) ||
!ReadOptionalFromStream(stream.get(), &entry.gpu_line_detect_mode) ||
!stream->ReadSizePrefixedString(&entry.disc_set_name) || !stream->ReadU32(&num_disc_set_serials))
{ {
DEV_LOG("Cache entry is corrupted."); DEV_LOG("Cache entry is corrupted.");
return false; return false;
@ -970,7 +936,7 @@ bool GameDatabase::LoadFromCache()
entry.disc_set_serials.reserve(num_disc_set_serials); entry.disc_set_serials.reserve(num_disc_set_serials);
for (u32 j = 0; j < num_disc_set_serials; j++) for (u32 j = 0; j < num_disc_set_serials; j++)
{ {
if (!stream->ReadSizePrefixedString(&entry.disc_set_serials.emplace_back())) if (!reader.ReadSizePrefixedString(&entry.disc_set_serials.emplace_back()))
{ {
DEV_LOG("Cache entry is corrupted."); DEV_LOG("Cache entry is corrupted.");
return false; return false;
@ -991,8 +957,7 @@ bool GameDatabase::LoadFromCache()
{ {
std::string code; std::string code;
u32 index; u32 index;
if (!stream->ReadSizePrefixedString(&code) || !stream->ReadU32(&index) || if (!reader.ReadSizePrefixedString(&code) || !reader.ReadU32(&index) || index >= static_cast<u32>(s_entries.size()))
index >= static_cast<u32>(s_entries.size()))
{ {
DEV_LOG("Cache code entry is corrupted."); DEV_LOG("Cache code entry is corrupted.");
return false; return false;
@ -1008,35 +973,38 @@ bool GameDatabase::SaveToCache()
{ {
const u64 gamedb_ts = Host::GetResourceFileTimestamp("gamedb.yaml", false).value_or(0); const u64 gamedb_ts = Host::GetResourceFileTimestamp("gamedb.yaml", false).value_or(0);
std::unique_ptr<ByteStream> stream( Error error;
ByteStream::OpenFile(GetCacheFile().c_str(), BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE | FileSystem::AtomicRenamedFile file = FileSystem::CreateAtomicRenamedFile(GetCacheFile(), "wb", &error);
BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_STREAMED)); if (!file)
if (!stream) {
ERROR_LOG("Failed to open cache file for writing: {}", error.GetDescription());
return false; return false;
}
bool result = stream->WriteU32(GAME_DATABASE_CACHE_SIGNATURE); BinaryFileWriter writer(file.get());
result = result && stream->WriteU32(GAME_DATABASE_CACHE_VERSION); writer.WriteU32(GAME_DATABASE_CACHE_SIGNATURE);
result = result && stream->WriteU64(static_cast<u64>(gamedb_ts)); writer.WriteU32(GAME_DATABASE_CACHE_VERSION);
writer.WriteU64(static_cast<u64>(gamedb_ts));
result = result && stream->WriteU32(static_cast<u32>(s_entries.size())); writer.WriteU32(static_cast<u32>(s_entries.size()));
result = result && stream->WriteU32(static_cast<u32>(s_code_lookup.size())); writer.WriteU32(static_cast<u32>(s_code_lookup.size()));
for (const Entry& entry : s_entries) for (const Entry& entry : s_entries)
{ {
result = result && stream->WriteSizePrefixedString(entry.serial); writer.WriteSizePrefixedString(entry.serial);
result = result && stream->WriteSizePrefixedString(entry.title); writer.WriteSizePrefixedString(entry.title);
result = result && stream->WriteSizePrefixedString(entry.genre); writer.WriteSizePrefixedString(entry.genre);
result = result && stream->WriteSizePrefixedString(entry.developer); writer.WriteSizePrefixedString(entry.developer);
result = result && stream->WriteSizePrefixedString(entry.publisher); writer.WriteSizePrefixedString(entry.publisher);
result = result && stream->WriteSizePrefixedString(entry.compatibility_version_tested); writer.WriteSizePrefixedString(entry.compatibility_version_tested);
result = result && stream->WriteSizePrefixedString(entry.compatibility_comments); writer.WriteSizePrefixedString(entry.compatibility_comments);
result = result && stream->WriteU64(entry.release_date); writer.WriteU64(entry.release_date);
result = result && stream->WriteU8(entry.min_players); writer.WriteU8(entry.min_players);
result = result && stream->WriteU8(entry.max_players); writer.WriteU8(entry.max_players);
result = result && stream->WriteU8(entry.min_blocks); writer.WriteU8(entry.min_blocks);
result = result && stream->WriteU8(entry.max_blocks); writer.WriteU8(entry.max_blocks);
result = result && stream->WriteU16(entry.supported_controllers); writer.WriteU16(entry.supported_controllers);
result = result && stream->WriteU8(static_cast<u8>(entry.compatibility)); writer.WriteU8(static_cast<u8>(entry.compatibility));
constexpr u32 num_bytes = (static_cast<u32>(Trait::Count) + 7) / 8; constexpr u32 num_bytes = (static_cast<u32>(Trait::Count) + 7) / 8;
std::array<u8, num_bytes> bits; std::array<u8, num_bytes> bits;
@ -1047,34 +1015,33 @@ bool GameDatabase::SaveToCache()
bits[j / 8] |= (1u << (j % 8)); bits[j / 8] |= (1u << (j % 8));
} }
result = result && stream->Write2(bits.data(), num_bytes); writer.Write(bits.data(), num_bytes);
result = result && WriteOptionalToStream(stream.get(), entry.display_active_start_offset); writer.WriteOptionalT(entry.display_active_start_offset);
result = result && WriteOptionalToStream(stream.get(), entry.display_active_end_offset); writer.WriteOptionalT(entry.display_active_end_offset);
result = result && WriteOptionalToStream(stream.get(), entry.display_line_start_offset); writer.WriteOptionalT(entry.display_line_start_offset);
result = result && WriteOptionalToStream(stream.get(), entry.display_line_end_offset); writer.WriteOptionalT(entry.display_line_end_offset);
result = result && WriteOptionalToStream(stream.get(), entry.display_deinterlacing_mode); writer.WriteOptionalT(entry.display_deinterlacing_mode);
result = result && WriteOptionalToStream(stream.get(), entry.dma_max_slice_ticks); writer.WriteOptionalT(entry.dma_max_slice_ticks);
result = result && WriteOptionalToStream(stream.get(), entry.dma_halt_ticks); writer.WriteOptionalT(entry.dma_halt_ticks);
result = result && WriteOptionalToStream(stream.get(), entry.gpu_fifo_size); writer.WriteOptionalT(entry.gpu_fifo_size);
result = result && WriteOptionalToStream(stream.get(), entry.gpu_max_run_ahead); writer.WriteOptionalT(entry.gpu_max_run_ahead);
result = result && WriteOptionalToStream(stream.get(), entry.gpu_pgxp_tolerance); writer.WriteOptionalT(entry.gpu_pgxp_tolerance);
result = result && WriteOptionalToStream(stream.get(), entry.gpu_pgxp_depth_threshold); writer.WriteOptionalT(entry.gpu_pgxp_depth_threshold);
result = result && WriteOptionalToStream(stream.get(), entry.gpu_line_detect_mode); writer.WriteOptionalT(entry.gpu_line_detect_mode);
result = result && stream->WriteSizePrefixedString(entry.disc_set_name); writer.WriteSizePrefixedString(entry.disc_set_name);
result = result && stream->WriteU32(static_cast<u32>(entry.disc_set_serials.size())); writer.WriteU32(static_cast<u32>(entry.disc_set_serials.size()));
for (const std::string& serial : entry.disc_set_serials) for (const std::string& serial : entry.disc_set_serials)
result = result && stream->WriteSizePrefixedString(serial); writer.WriteSizePrefixedString(serial);
} }
for (const auto& it : s_code_lookup) for (const auto& it : s_code_lookup)
{ {
result = result && stream->WriteSizePrefixedString(it.first); writer.WriteSizePrefixedString(it.first);
result = result && stream->WriteU32(it.second); writer.WriteU32(it.second);
} }
result = result && stream->Flush();
return true; return true;
} }