sgilissen/llamaplayer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MemoryCard: Purge use of ByteStream

Browse Source
This commit is contained in:
Stenzek
2024-07-28 23:28:13 +10:00
parent b5009da2bc
commit dd8bf2c9d9
8 changed files with 86 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/core/game_list.cpp
View File

@ -1735,8 +1735,9 @@ std::string GameList::GetGameIconPath(std::string_view serial, std::string_view
StringUtil::Strlcpy(serial_entry->serial, index_serial.view(), sizeof(serial_entry->serial));
// Try extracting an icon.
Error error;
MemoryCardImage::DataArray data;
if (MemoryCardImage::LoadFromFile(&data, memcard_path.c_str()))
if (MemoryCardImage::LoadFromFile(&data, memcard_path.c_str(), &error))
{
std::vector<MemoryCardImage::FileInfo> files = MemoryCardImage::EnumerateFiles(data, false);
if (!files.empty())
@ -1760,6 +1761,10 @@ std::string GameList::GetGameIconPath(std::string_view serial, std::string_view
}
}
}
else
{
ERROR_LOG("Failed to load memory card '{}': {}", Path::GetFileName(memcard_path), error.GetDescription());
}
UpdateMemcardTimestampCache(*serial_entry);
return ret;

34
src/core/memory_card.cpp
View File

@ -10,6 +10,7 @@
#include "common/bitutils.h"
#include "common/byte_stream.h"
#include "common/error.h"
#include "common/file_system.h"
#include "common/log.h"
#include "common/path.h"
@ -298,11 +299,20 @@ std::unique_ptr<MemoryCard> MemoryCard::Open(std::string_view filename)
{
std::unique_ptr<MemoryCard> mc = std::make_unique<MemoryCard>();
mc->m_filename = filename;
if (!mc->LoadFromFile()) [[unlikely]]
Error error;
if (!FileSystem::FileExists(mc->m_filename.c_str())) [[unlikely]]
{
INFO_LOG("Memory card at '{}' could not be read, formatting.", mc->m_filename);
Host::AddIconOSDMessage(fmt::format("memory_card_{}", filename), ICON_FA_SD_CARD,
fmt::format(TRANSLATE_FS("OSDMessage", "Memory card '{}' could not be read, formatting."),
fmt::format(TRANSLATE_FS("OSDMessage", "Memory card '{}' does not exist, creating."),
Path::GetFileName(filename), Host::OSD_INFO_DURATION));
mc->Format();
mc->SaveIfChanged(true);
}
else if (!MemoryCardImage::LoadFromFile(&mc->m_data, mc->m_filename.c_str(), &error)) [[unlikely]]
{
Host::AddIconOSDMessage(fmt::format("memory_card_{}", filename), ICON_FA_SD_CARD,
fmt::format(TRANSLATE_FS("OSDMessage", "Memory card '{}' could not be read: {}"),
Path::GetFileName(filename), Host::OSD_INFO_DURATION));
mc->Format();
}
@ -316,11 +326,6 @@ void MemoryCard::Format()
m_changed = true;
}
bool MemoryCard::LoadFromFile()
{
return MemoryCardImage::LoadFromFile(&m_data, m_filename.c_str());
}
bool MemoryCard::SaveIfChanged(bool display_osd_message)
{
m_save_event.Deactivate();
@ -341,14 +346,17 @@ bool MemoryCard::SaveIfChanged(bool display_osd_message)
display_name = FileSystem::GetDisplayNameFromPath(m_filename);
}
if (!MemoryCardImage::SaveToFile(m_data, m_filename.c_str()))
INFO_LOG("Saving memory card to {}...", Path::GetFileTitle(m_filename));
Error error;
if (!MemoryCardImage::SaveToFile(m_data, m_filename.c_str(), &error))
{
if (display_osd_message)
{
Host::AddIconOSDMessage(
std::move(osd_key), ICON_FA_SD_CARD,
fmt::format(TRANSLATE_FS("OSDMessage", "Failed to save memory card to '{}'."), Path::GetFileName(display_name)),
Host::OSD_ERROR_DURATION);
Host::AddIconOSDMessage(std::move(osd_key), ICON_FA_SD_CARD,
fmt::format(TRANSLATE_FS("OSDMessage", "Failed to save memory card to '{}': {}"),
Path::GetFileName(display_name), error.GetDescription()),
Host::OSD_ERROR_DURATION);
}
return false;

1
src/core/memory_card.h
View File

@ -95,7 +95,6 @@ private:
static TickCount GetSaveDelayInTicks();
bool LoadFromFile();
bool SaveIfChanged(bool display_osd_message);
void QueueFileSave();

78
src/core/memory_card_image.cpp
View File

@ -9,7 +9,6 @@
#include "util/state_wrapper.h"
#include "common/bitutils.h"
#include "common/byte_stream.h"
#include "common/error.h"
#include "common/file_system.h"
#include "common/log.h"
@ -97,17 +96,21 @@ static bool ImportSaveWithDirectoryFrame(DataArray* data, const char* filename,
static bool ImportRawSave(DataArray* data, const char* filename, const FILESYSTEM_STAT_DATA& sd, Error* error);
} // namespace MemoryCardImage
bool MemoryCardImage::LoadFromFile(DataArray* data, const char* filename)
bool MemoryCardImage::LoadFromFile(DataArray* data, const char* filename, Error* error)
{
FILESYSTEM_STAT_DATA sd;
if (!FileSystem::StatFile(filename, &sd) || sd.Size != DATA_SIZE)
FileSystem::ManagedCFilePtr fp = FileSystem::OpenManagedCFile(filename, "rb", error);
if (!fp)
return false;
std::unique_ptr<ByteStream> stream = ByteStream::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!stream || stream->GetSize() != DATA_SIZE)
const s64 size = FileSystem::FSize64(fp.get());
if (size != static_cast<s64>(DATA_SIZE))
{
ERROR_LOG("Memory card {} is incorrect size (expected {} got {})", Path::GetFileName(filename),
static_cast<u32>(DATA_SIZE), size);
return false;
}
const size_t num_read = stream->Read(data->data(), DATA_SIZE);
const size_t num_read = std::fread(data->data(), 1, DATA_SIZE, fp.get());
if (num_read != DATA_SIZE)
{
ERROR_LOG("Only read {} of {} sectors from '{}'", num_read / FRAME_SIZE, static_cast<u32>(NUM_FRAMES), filename);
@ -118,25 +121,17 @@ bool MemoryCardImage::LoadFromFile(DataArray* data, const char* filename)
return true;
}
bool MemoryCardImage::SaveToFile(const DataArray& data, const char* filename)
bool MemoryCardImage::SaveToFile(const DataArray& data, const char* filename, Error* error)
{
std::unique_ptr<ByteStream> stream =
ByteStream::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_WRITE |
BYTESTREAM_OPEN_ATOMIC_UPDATE | BYTESTREAM_OPEN_STREAMED);
if (!stream)
Error local_error;
if (!FileSystem::WriteAtomicRenamedFile(filename, data.data(), data.size(), error ? error : &local_error))
[[unlikely]]
{
ERROR_LOG("Failed to open '{}' for writing.", filename);
ERROR_LOG("Failed to save memory card '{}': {}", Path::GetFileName(filename),
(error ? error : &local_error)->GetDescription());
return false;
}
if (!stream->Write2(data.data(), DATA_SIZE) || !stream->Commit())
{
ERROR_LOG("Failed to write sectors to '{}'", filename);
stream->Discard();
return false;
}
VERBOSE_LOG("Saved memory card to '{}'", filename);
return true;
}
@ -634,27 +629,21 @@ bool MemoryCardImage::ImportCard(DataArray* data, const char* filename, Error* e
bool MemoryCardImage::ExportSave(DataArray* data, const FileInfo& fi, const char* filename, Error* error)
{
std::unique_ptr<ByteStream> stream =
ByteStream::OpenFile(filename,
BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_WRITE |
BYTESTREAM_OPEN_ATOMIC_UPDATE | BYTESTREAM_OPEN_STREAMED,
error);
if (!stream)
// TODO: This could be span...
std::vector<u8> file_data;
if (!ReadFile(*data, fi, &file_data, error))
return false;
auto fp = FileSystem::CreateAtomicRenamedFile(filename, "wb", error);
if (!fp)
return false;
DirectoryFrame* df_ptr = GetFramePtr<DirectoryFrame>(data, 0, fi.first_block);
std::vector<u8> header = std::vector<u8>(static_cast<size_t>(FRAME_SIZE));
std::memcpy(header.data(), df_ptr, sizeof(*df_ptr));
std::vector<u8> blocks;
if (!ReadFile(*data, fi, &blocks, error))
return false;
if (!stream->Write(header.data(), static_cast<u32>(header.size())) ||
!stream->Write(blocks.data(), static_cast<u32>(blocks.size())) || !stream->Commit())
if (std::fwrite(df_ptr, sizeof(DirectoryFrame), 1, fp.get()) != 1 ||
std::fwrite(file_data.data(), file_data.size(), 1, fp.get()) != 1)
{
Error::SetStringView(error, "Failed to write exported save.");
stream->Discard();
Error::SetErrno(error, "fwrite() failed: ", errno);
FileSystem::DiscardAtomicRenamedFile(fp);
return false;
}
@ -671,15 +660,14 @@ bool MemoryCardImage::ImportSaveWithDirectoryFrame(DataArray* data, const char*
return false;
}
std::unique_ptr<ByteStream> stream =
ByteStream::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED, error);
if (!stream)
auto fp = FileSystem::OpenManagedCFile(filename, "rb", error);
if (!fp)
return false;
DirectoryFrame df;
if (stream->Read(&df, FRAME_SIZE) != FRAME_SIZE)
if (std::fread(&df, sizeof(df), 1, fp.get()) != 1)
{
Error::SetStringView(error, "Failed to read directory frame.");
Error::SetErrno(error, "Failed to read directory frame: ", errno);
return false;
}
@ -691,9 +679,9 @@ bool MemoryCardImage::ImportSaveWithDirectoryFrame(DataArray* data, const char*
}
std::vector<u8> blocks = std::vector<u8>(static_cast<size_t>(df.file_size));
if (stream->Read(blocks.data(), df.file_size) != df.file_size)
if (std::fread(blocks.data(), df.file_size, 1, fp.get()) != 1)
{
Error::SetStringView(error, "Failed to read block bytes.");
Error::SetErrno(error, "Failed to read block bytes: ", errno);
return false;
}

4
src/core/memory_card_image.h
View File

@ -25,8 +25,8 @@ enum : u32
using DataArray = std::array<u8, DATA_SIZE>;
bool LoadFromFile(DataArray* data, const char* filename);
bool SaveToFile(const DataArray& data, const char* filename);
bool LoadFromFile(DataArray* data, const char* filename, Error* error);
bool SaveToFile(const DataArray& data, const char* filename, Error* error);
void Format(DataArray* data);