ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ByteStream: Move routines from FileSystem to ByteStream

This commit is contained in:
Connor McLaughlin 2022-07-08 20:11:31 +10:00
parent d81e156a29
commit b5bf3593c4
13 changed files with 155 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/common/CMakeLists.txt
View File

@ -118,7 +118,8 @@ add_library(common
target_include_directories(common PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/..")
target_include_directories(common PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/..")
target_link_libraries(common PRIVATE glad stb Threads::Threads libchdr glslang vulkan-loader zlib minizip samplerate)
target_link_libraries(common PUBLIC fmt Threads::Threads)
target_link_libraries(common PRIVATE glad stb libchdr glslang vulkan-loader zlib minizip samplerate)
if(WIN32)
target_sources(common PRIVATE

292
src/common/byte_stream.cpp
View File

@ -896,9 +896,7 @@ void GrowableMemoryByteStream::Grow(u32 MinimumGrowth)
ResizeMemory(NewSize);
}
#if defined(_MSC_VER)
std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32 openMode)
std::unique_ptr<ByteStream> ByteStream::OpenFile(const char* fileName, u32 openMode)
{
if ((openMode & (BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE)) == BYTESTREAM_OPEN_WRITE)
{
@ -945,80 +943,10 @@ std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32
modeString[modeStringLength] = 0;
if (openMode & BYTESTREAM_OPEN_CREATE_PATH)
{
u32 i;
u32 fileNameLength = static_cast<u32>(std::strlen(fileName));
char* tempStr = (char*)alloca(fileNameLength + 1);
// check if it starts with a drive letter. if so, skip ahead
if (fileNameLength >= 2 && fileName[1] == ':')
{
if (fileNameLength <= 3)
{
// create a file called driveletter: or driveletter:\ ? you must be crazy
i = fileNameLength;
}
else
{
std::memcpy(tempStr, fileName, 3);
i = 3;
}
}
else
{
// start at beginning
i = 0;
}
// step through each path component, create folders as necessary
for (; i < fileNameLength; i++)
{
if (i > 0 && (fileName[i] == '\\' || fileName[i] == '/'))
{
// terminate the string
tempStr[i] = '\0';
// check if it exists
struct stat s;
if (stat(tempStr, &s) < 0)
{
if (errno == ENOENT)
{
// try creating it
if (_mkdir(tempStr) < 0)
{
// no point trying any further down the chain
break;
}
}
else // if (errno == ENOTDIR)
{
// well.. someone's trying to open a fucking weird path that is comprised of both directories and files...
// I aint sticking around here to find out what disaster awaits... let fopen deal with it
break;
}
}
// append platform path seperator
#if defined(_WIN32)
tempStr[i] = '\\';
#else
tempStr[i] = '/';
#endif
}
else
{
// append character to temp string
tempStr[i] = fileName[i];
}
}
}
if (openMode & BYTESTREAM_OPEN_ATOMIC_UPDATE)
{
DebugAssert(openMode & (BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE));
#ifdef _WIN32
#ifndef _UWP
// generate the temporary file name
u32 fileNameLength = static_cast<u32>(std::strlen(fileName));
@ -1116,131 +1044,7 @@ std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32
// return pointer
return pStream;
}
else
{
// forward through
FILE* pFile = FileSystem::OpenCFile(fileName, modeString);
if (!pFile)
return nullptr;
return std::make_unique<FileByteStream>(pFile);
}
}
#else
std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32 openMode)
{
if ((openMode & (BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE)) == BYTESTREAM_OPEN_WRITE)
{
// if opening with write but not create, the path must exist.
struct stat s;
if (stat(fileName, &s) < 0)
return nullptr;
}
char modeString[16];
u32 modeStringLength = 0;
if (openMode & BYTESTREAM_OPEN_WRITE)
{
if (openMode & BYTESTREAM_OPEN_TRUNCATE)
modeString[modeStringLength++] = 'w';
else
modeString[modeStringLength++] = 'a';
modeString[modeStringLength++] = 'b';
if (openMode & BYTESTREAM_OPEN_READ)
modeString[modeStringLength++] = '+';
}
else if (openMode & BYTESTREAM_OPEN_READ)
{
modeString[modeStringLength++] = 'r';
modeString[modeStringLength++] = 'b';
}
modeString[modeStringLength] = 0;
if (openMode & BYTESTREAM_OPEN_CREATE_PATH)
{
u32 i;
const u32 fileNameLength = static_cast<u32>(std::strlen(fileName));
char* tempStr = (char*)alloca(fileNameLength + 1);
#if defined(_WIN32)
// check if it starts with a drive letter. if so, skip ahead
if (fileNameLength >= 2 && fileName[1] == ':')
{
if (fileNameLength <= 3)
{
// create a file called driveletter: or driveletter:\ ? you must be crazy
i = fileNameLength;
}
else
{
std::memcpy(tempStr, fileName, 3);
i = 3;
}
}
else
{
// start at beginning
i = 0;
}
#endif
// step through each path component, create folders as necessary
for (i = 0; i < fileNameLength; i++)
{
if (i > 0 && (fileName[i] == '\\' || fileName[i] == '/') && fileName[i] != ':')
{
// terminate the string
tempStr[i] = '\0';
// check if it exists
struct stat s;
if (stat(tempStr, &s) < 0)
{
if (errno == ENOENT)
{
// try creating it
#if defined(_WIN32)
if (mkdir(tempStr) < 0)
#else
if (mkdir(tempStr, 0777) < 0)
#endif
{
// no point trying any further down the chain
break;
}
}
else // if (errno == ENOTDIR)
{
// well.. someone's trying to open a fucking weird path that is comprised of both directories and
// files... I aint sticking around here to find out what disaster awaits... let fopen deal with it
break;
}
}
// append platform path seperator
#if defined(_WIN32)
tempStr[i] = '\\';
#else
tempStr[i] = '/';
#endif
}
else
{
// append character to temp string
tempStr[i] = fileName[i];
}
}
}
if (openMode & BYTESTREAM_OPEN_ATOMIC_UPDATE)
{
DebugAssert(openMode & (BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE));
// generate the temporary file name
@ -1256,7 +1060,7 @@ std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32
#endif
// open the file
std::FILE* pTemporaryFile = std::fopen(temporaryFileName, modeString);
std::FILE* pTemporaryFile = FileSystem::OpenCFile(temporaryFileName, modeString);
if (pTemporaryFile == nullptr)
return nullptr;
@ -1267,7 +1071,7 @@ std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32
// do we need to copy the existing file into this one?
if (!(openMode & BYTESTREAM_OPEN_TRUNCATE))
{
std::FILE* pOriginalFile = std::fopen(fileName, "rb");
std::FILE* pOriginalFile = FileSystem::OpenCFile(fileName, "rb");
if (!pOriginalFile)
{
// this will delete the temporary file
@ -1297,10 +1101,12 @@ std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32
// return pointer
return pStream;
#endif
}
else
{
std::FILE* pFile = std::fopen(fileName, modeString);
// forward through
std::FILE* pFile = FileSystem::OpenCFile(fileName, modeString);
if (!pFile)
return nullptr;
@ -1308,36 +1114,34 @@ std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* fileName, u32
}
}
#endif
std::unique_ptr<MemoryByteStream> ByteStream_CreateMemoryStream(void* pMemory, u32 Size)
std::unique_ptr<MemoryByteStream> ByteStream::CreateMemoryStream(void* pMemory, u32 Size)
{
DebugAssert(pMemory != nullptr && Size > 0);
return std::make_unique<MemoryByteStream>(pMemory, Size);
}
std::unique_ptr<ReadOnlyMemoryByteStream> ByteStream_CreateReadOnlyMemoryStream(const void* pMemory, u32 Size)
std::unique_ptr<ReadOnlyMemoryByteStream> ByteStream::CreateReadOnlyMemoryStream(const void* pMemory, u32 Size)
{
DebugAssert(pMemory != nullptr && Size > 0);
return std::make_unique<ReadOnlyMemoryByteStream>(pMemory, Size);
}
std::unique_ptr<NullByteStream> ByteStream_CreateNullStream()
std::unique_ptr<NullByteStream> ByteStream::CreateNullStream()
{
return std::make_unique<NullByteStream>();
}
std::unique_ptr<GrowableMemoryByteStream> ByteStream_CreateGrowableMemoryStream(void* pInitialMemory, u32 InitialSize)
std::unique_ptr<GrowableMemoryByteStream> ByteStream::CreateGrowableMemoryStream(void* pInitialMemory, u32 InitialSize)
{
return std::make_unique<GrowableMemoryByteStream>(pInitialMemory, InitialSize);
}
std::unique_ptr<GrowableMemoryByteStream> ByteStream_CreateGrowableMemoryStream()
std::unique_ptr<GrowableMemoryByteStream> ByteStream::CreateGrowableMemoryStream()
{
return std::make_unique<GrowableMemoryByteStream>(nullptr, 0);
}
bool ByteStream_CopyStream(ByteStream* pDestinationStream, ByteStream* pSourceStream)
bool ByteStream::CopyStream(ByteStream* pDestinationStream, ByteStream* pSourceStream)
{
const u32 chunkSize = 4096;
u8 chunkData[chunkSize];
@ -1363,7 +1167,7 @@ bool ByteStream_CopyStream(ByteStream* pDestinationStream, ByteStream* pSourceSt
return (pSourceStream->SeekAbsolute(oldSourcePosition) && success);
}
bool ByteStream_AppendStream(ByteStream* pSourceStream, ByteStream* pDestinationStream)
bool ByteStream::AppendStream(ByteStream* pSourceStream, ByteStream* pDestinationStream)
{
const u32 chunkSize = 4096;
u8 chunkData[chunkSize];
@ -1389,7 +1193,7 @@ bool ByteStream_AppendStream(ByteStream* pSourceStream, ByteStream* pDestination
return (pSourceStream->SeekAbsolute(oldSourcePosition) && success);
}
u32 ByteStream_CopyBytes(ByteStream* pSourceStream, u32 byteCount, ByteStream* pDestinationStream)
u32 ByteStream::CopyBytes(ByteStream* pSourceStream, u32 byteCount, ByteStream* pDestinationStream)
{
const u32 chunkSize = 4096;
u8 chunkData[chunkSize];
@ -1411,3 +1215,69 @@ u32 ByteStream_CopyBytes(ByteStream* pSourceStream, u32 byteCount, ByteStream* p
return byteCount - remaining;
}
std::string ByteStream::ReadStreamToString(ByteStream* stream, bool seek_to_start /* = true */)
{
u64 pos = stream->GetPosition();
u64 size = stream->GetSize();
if (pos > 0 && seek_to_start)
{
if (!stream->SeekAbsolute(0))
return {};
pos = 0;
}
Assert(size >= pos);
size -= pos;
if (size == 0 || size > std::numeric_limits<u32>::max())
return {};
std::string ret;
ret.resize(static_cast<size_t>(size));
if (!stream->Read2(ret.data(), static_cast<u32>(size)))
return {};
return ret;
}
bool ByteStream::WriteStreamToString(const std::string_view& sv, ByteStream* stream)
{
if (sv.size() > std::numeric_limits<u32>::max())
return false;
return stream->Write2(sv.data(), static_cast<u32>(sv.size()));
}
std::vector<u8> ByteStream::ReadBinaryStream(ByteStream* stream, bool seek_to_start /*= true*/)
{
u64 pos = stream->GetPosition();
u64 size = stream->GetSize();
if (pos > 0 && seek_to_start)
{
if (!stream->SeekAbsolute(0))
return {};
pos = 0;
}
Assert(size >= pos);
size -= pos;
if (size == 0 || size > std::numeric_limits<u32>::max())
return {};
std::vector<u8> ret;
ret.resize(static_cast<size_t>(size));
if (!stream->Read2(ret.data(), static_cast<u32>(size)))
return {};
return ret;
}
bool ByteStream::WriteBinaryToStream(ByteStream* stream, const void* data, size_t data_length)
{
if (data_length > std::numeric_limits<u32>::max())
return false;
return stream->Write2(data, static_cast<u32>(data_length));
}

76
src/common/byte_stream.h
View File

@ -1,6 +1,8 @@
#pragma once
#include "types.h"
#include <memory>
#include <string>
#include <vector>
// base byte stream creation functions
enum BYTESTREAM_OPEN_MODE
@ -10,12 +12,18 @@ enum BYTESTREAM_OPEN_MODE
BYTESTREAM_OPEN_APPEND = 4, // seek to the end
BYTESTREAM_OPEN_TRUNCATE = 8, // truncate the file, seek to start
BYTESTREAM_OPEN_CREATE = 16, // if the file does not exist, create it
BYTESTREAM_OPEN_CREATE_PATH = 32, // if the file parent directories don't exist, create them
BYTESTREAM_OPEN_ATOMIC_UPDATE = 64, //
BYTESTREAM_OPEN_SEEKABLE = 128,
BYTESTREAM_OPEN_STREAMED = 256,
};
// forward declarations for implemented classes
class ByteStream;
class MemoryByteStream;
class GrowableMemoryByteStream;
class ReadOnlyMemoryByteStream;
class NullByteStream;
// interface class used by readers, writers, etc.
class ByteStream
{
@ -68,6 +76,42 @@ public:
inline void SetErrorState() { m_errorState = true; }
inline void ClearErrorState() { m_errorState = false; }
// base byte stream creation functions
// opens a local file-based stream. fills in error if passed, and returns false if the file cannot be opened.
static std::unique_ptr<ByteStream> OpenFile(const char* FileName, u32 OpenMode);
// memory byte stream, caller is responsible for management, therefore it can be located on either the stack or on the
// heap.
static std::unique_ptr<MemoryByteStream> CreateMemoryStream(void* pMemory, u32 Size);
// a growable memory byte stream will automatically allocate its own memory if the provided memory is overflowed.
// a "pure heap" buffer, i.e. a buffer completely managed by this implementation, can be created by supplying a NULL
// pointer and initialSize of zero.
static std::unique_ptr<GrowableMemoryByteStream> CreateGrowableMemoryStream(void* pInitialMemory, u32 InitialSize);
static std::unique_ptr<GrowableMemoryByteStream> CreateGrowableMemoryStream();
// readable memory stream
static std::unique_ptr<ReadOnlyMemoryByteStream> CreateReadOnlyMemoryStream(const void* pMemory, u32 Size);
// null memory stream
static std::unique_ptr<NullByteStream> CreateNullStream();
// copies one stream's contents to another. rewinds source streams automatically, and returns it back to its old
// position.
static bool CopyStream(ByteStream* pDestinationStream, ByteStream* pSourceStream);
// appends one stream's contents to another.
static bool AppendStream(ByteStream* pSourceStream, ByteStream* pDestinationStream);
// copies a number of bytes from one to another
static u32 CopyBytes(ByteStream* pSourceStream, u32 byteCount, ByteStream* pDestinationStream);
static std::string ReadStreamToString(ByteStream* stream, bool seek_to_start = true);
static bool WriteStreamToString(const std::string_view& sv, ByteStream* stream);
static std::vector<u8> ReadBinaryStream(ByteStream* stream, bool seek_to_start = true);
static bool WriteBinaryToStream(ByteStream* stream, const void* data, size_t data_length);
protected:
ByteStream() : m_errorState(false) {}
@ -199,33 +243,3 @@ private:
u32 m_iSize;
u32 m_iMemorySize;
};
// base byte stream creation functions
// opens a local file-based stream. fills in error if passed, and returns false if the file cannot be opened.
std::unique_ptr<ByteStream> ByteStream_OpenFileStream(const char* FileName, u32 OpenMode);
// memory byte stream, caller is responsible for management, therefore it can be located on either the stack or on the
// heap.
std::unique_ptr<MemoryByteStream> ByteStream_CreateMemoryStream(void* pMemory, u32 Size);
// a growable memory byte stream will automatically allocate its own memory if the provided memory is overflowed.
// a "pure heap" buffer, i.e. a buffer completely managed by this implementation, can be created by supplying a NULL
// pointer and initialSize of zero.
std::unique_ptr<GrowableMemoryByteStream> ByteStream_CreateGrowableMemoryStream(void* pInitialMemory, u32 InitialSize);
std::unique_ptr<GrowableMemoryByteStream> ByteStream_CreateGrowableMemoryStream();
// readable memory stream
std::unique_ptr<ReadOnlyMemoryByteStream> ByteStream_CreateReadOnlyMemoryStream(const void* pMemory, u32 Size);
// null memory stream
std::unique_ptr<NullByteStream> ByteStream_CreateNullStream();
// copies one stream's contents to another. rewinds source streams automatically, and returns it back to its old
// position.
bool ByteStream_CopyStream(ByteStream* pDestinationStream, ByteStream* pSourceStream);
// appends one stream's contents to another.
bool ByteStream_AppendStream(ByteStream* pSourceStream, ByteStream* pDestinationStream);
// copies a number of bytes from one to another
u32 ByteStream_CopyBytes(ByteStream* pSourceStream, u32 byteCount, ByteStream* pDestinationStream);

78
src/common/file_system.cpp
View File

@ -844,18 +844,6 @@ std::string BuildRelativePath(const std::string_view& filename, const std::strin
return new_string;
}
std::unique_ptr<ByteStream> OpenFile(const char* FileName, u32 Flags)
{
// has a path
if (FileName[0] == '\0')
return nullptr;
// TODO: Handle Android content URIs here.
// forward to local file wrapper
return ByteStream_OpenFileStream(FileName, Flags);
}
FileSystem::ManagedCFilePtr OpenManagedCFile(const char* filename, const char* mode)
{
return ManagedCFilePtr(OpenCFile(filename, mode), [](std::FILE* fp) { std::fclose(fp); });
@ -1116,72 +1104,6 @@ bool WriteFileToString(const char* filename, const std::string_view& sv)
return true;
}
std::string ReadStreamToString(ByteStream* stream, bool seek_to_start /* = true */)
{
u64 pos = stream->GetPosition();
u64 size = stream->GetSize();
if (pos > 0 && seek_to_start)
{
if (!stream->SeekAbsolute(0))
return {};
pos = 0;
}
Assert(size >= pos);
size -= pos;
if (size == 0 || size > std::numeric_limits<u32>::max())
return {};
std::string ret;
ret.resize(static_cast<size_t>(size));
if (!stream->Read2(ret.data(), static_cast<u32>(size)))
return {};
return ret;
}
bool WriteStreamToString(const std::string_view& sv, ByteStream* stream)
{
if (sv.size() > std::numeric_limits<u32>::max())
return false;
return stream->Write2(sv.data(), static_cast<u32>(sv.size()));
}
std::vector<u8> ReadBinaryStream(ByteStream* stream, bool seek_to_start /*= true*/)
{
u64 pos = stream->GetPosition();
u64 size = stream->GetSize();
if (pos > 0 && seek_to_start)
{
if (!stream->SeekAbsolute(0))
return {};
pos = 0;
}
Assert(size >= pos);
size -= pos;
if (size == 0 || size > std::numeric_limits<u32>::max())
return {};
std::vector<u8> ret;
ret.resize(static_cast<size_t>(size));
if (!stream->Read2(ret.data(), static_cast<u32>(size)))
return {};
return ret;
}
bool WriteBinaryToSTream(ByteStream* stream, const void* data, size_t data_length)
{
if (data_length > std::numeric_limits<u32>::max())
return false;
return stream->Write2(data, static_cast<u32>(data_length));
}
void BuildOSPath(char* Destination, u32 cbDestination, const char* Path)
{
u32 i;

13
src/common/file_system.h
View File

@ -2,12 +2,12 @@
#include "timestamp.h"
#include "types.h"
#include <cstdio>
#include <ctime>
#include <memory>
#include <optional>
#include <string>
#include <vector>
class ByteStream;
#include <sys/stat.h>
#ifdef _WIN32
#define FS_OSPATH_SEPARATOR_CHARACTER '\\'
@ -185,9 +185,6 @@ bool DeleteFile(const char* Path);
// rename file
bool RenamePath(const char* OldPath, const char* NewPath);
// open files
std::unique_ptr<ByteStream> OpenFile(const char* FileName, u32 Flags);
using ManagedCFilePtr = std::unique_ptr<std::FILE, void (*)(std::FILE*)>;
ManagedCFilePtr OpenManagedCFile(const char* filename, const char* mode);
std::FILE* OpenCFile(const char* filename, const char* mode);
@ -201,12 +198,6 @@ std::optional<std::string> ReadFileToString(std::FILE* fp);
bool WriteBinaryFile(const char* filename, const void* data, size_t data_length);
bool WriteFileToString(const char* filename, const std::string_view& sv);
std::string ReadStreamToString(ByteStream* stream, bool seek_to_start = true);
bool WriteStreamToString(const std::string_view& sv, ByteStream* stream);
std::vector<u8> ReadBinaryStream(ByteStream* stream, bool seek_to_start = true);
bool WriteBinaryToSTream(ByteStream* stream, const void* data, size_t data_length);
// creates a directory in the local filesystem
// if the directory already exists, the return value will be true.
// if Recursive is specified, all parent directories will be created

2
src/core/cheats.cpp
View File

@ -691,7 +691,7 @@ bool CheatList::LoadFromPackage(const std::string& game_code)
if (!stream)
return false;
std::string db_string = FileSystem::ReadStreamToString(stream.get());
std::string db_string = ByteStream::ReadStreamToString(stream.get());
stream.reset();
if (db_string.empty())
return false;

6
src/core/host_interface.cpp
View File

@ -409,7 +409,7 @@ bool HostInterface::HasAnyBIOSImages()
bool HostInterface::LoadState(const char* filename)
{
std::unique_ptr<ByteStream> stream = FileSystem::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
std::unique_ptr<ByteStream> stream = ByteStream::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!stream)
return false;
@ -441,7 +441,7 @@ bool HostInterface::LoadState(const char* filename)
bool HostInterface::SaveState(const char* filename)
{
std::unique_ptr<ByteStream> stream =
FileSystem::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE | BYTESTREAM_OPEN_TRUNCATE |
ByteStream::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE | BYTESTREAM_OPEN_TRUNCATE |
BYTESTREAM_OPEN_ATOMIC_UPDATE | BYTESTREAM_OPEN_STREAMED);
if (!stream)
return false;
@ -1140,7 +1140,7 @@ void HostInterface::RecreateSystem()
{
Assert(!System::IsShutdown());
std::unique_ptr<ByteStream> stream = ByteStream_CreateGrowableMemoryStream(nullptr, 8 * 1024);
std::unique_ptr<ByteStream> stream = ByteStream::CreateGrowableMemoryStream(nullptr, 8 * 1024);
if (!System::SaveState(stream.get(), 0) || !stream->SeekAbsolute(0))
{
ReportError("Failed to save state before system recreation. Shutting down.");

8
src/core/memory_card_image.cpp
View File

@ -97,7 +97,7 @@ bool LoadFromFile(DataArray* data, const char* filename)
if (!FileSystem::StatFile(filename, &sd) || sd.Size != DATA_SIZE)
return false;
std::unique_ptr<ByteStream> stream = FileSystem::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
std::unique_ptr<ByteStream> stream = ByteStream::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!stream || stream->GetSize() != DATA_SIZE)
return false;
@ -115,7 +115,7 @@ bool LoadFromFile(DataArray* data, const char* filename)
bool SaveToFile(const DataArray& data, const char* filename)
{
std::unique_ptr<ByteStream> stream =
FileSystem::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_WRITE |
ByteStream::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_WRITE |
BYTESTREAM_OPEN_ATOMIC_UPDATE | BYTESTREAM_OPEN_STREAMED);
if (!stream)
{
@ -560,7 +560,7 @@ bool ImportCard(DataArray* data, const char* filename)
bool ExportSave(DataArray* data, const FileInfo& fi, const char* filename)
{
std::unique_ptr<ByteStream> stream =
FileSystem::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_WRITE |
ByteStream::OpenFile(filename, BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_TRUNCATE | BYTESTREAM_OPEN_WRITE |
BYTESTREAM_OPEN_ATOMIC_UPDATE | BYTESTREAM_OPEN_STREAMED);
if (!stream)
{
@ -599,7 +599,7 @@ static bool ImportSaveWithDirectoryFrame(DataArray* data, const char* filename,
return false;
}
std::unique_ptr<ByteStream> stream = FileSystem::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
std::unique_ptr<ByteStream> stream = ByteStream::OpenFile(filename, BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!stream)
{
Log_ErrorPrintf("Failed to open '%s' for reading", filename);

2
src/core/system.cpp
View File

@ -634,7 +634,7 @@ bool RecreateGPU(GPURenderer renderer, bool update_display /* = true*/)
g_gpu->RestoreGraphicsAPIState();
// save current state
std::unique_ptr<ByteStream> state_stream = ByteStream_CreateGrowableMemoryStream();
std::unique_ptr<ByteStream> state_stream = ByteStream::CreateGrowableMemoryStream();
StateWrapper sw(state_stream.get(), StateWrapper::Mode::Write, SAVE_STATE_VERSION);
const bool state_valid = g_gpu->DoState(sw, nullptr, false) && TimingEvents::DoState(sw);
if (!state_valid)

12
src/frontend-common/common_host_interface.cpp
View File

@ -483,7 +483,7 @@ bool CommonHostInterface::ParseCommandLineParameters(int argc, char* argv[],
if (!state_filename.empty())
{
std::unique_ptr<ByteStream> state_stream =
FileSystem::OpenFile(state_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
ByteStream::OpenFile(state_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!state_stream)
{
Log_ErrorPrintf("Failed to open save state file '%s'", state_filename.c_str());
@ -565,7 +565,7 @@ bool CommonHostInterface::CreateHostDisplayResources()
std::unique_ptr<ByteStream> stream = OpenPackageFile("resources" FS_OSPATH_SEPARATOR_STR "roboto-regular.ttf",
BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
std::vector<u8> font_data;
if (!stream || (font_data = FileSystem::ReadBinaryStream(stream.get()), font_data.empty()))
if (!stream || (font_data = ByteStream::ReadBinaryStream(stream.get()), font_data.empty()))
{
ReportError("Failed to load text font");
m_display->DestroyImGuiContext();
@ -580,7 +580,7 @@ bool CommonHostInterface::CreateHostDisplayResources()
std::unique_ptr<ByteStream> stream = OpenPackageFile("resources" FS_OSPATH_SEPARATOR_STR "fa-solid-900.ttf",
BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
std::vector<u8> font_data;
if (!stream || (font_data = FileSystem::ReadBinaryStream(stream.get()), font_data.empty()))
if (!stream || (font_data = ByteStream::ReadBinaryStream(stream.get()), font_data.empty()))
{
ReportError("Failed to load icon font");
m_display->DestroyImGuiContext();
@ -779,7 +779,7 @@ bool CommonHostInterface::SaveUndoLoadState()
if (m_undo_load_state)
m_undo_load_state.reset();
m_undo_load_state = ByteStream_CreateGrowableMemoryStream(nullptr, System::MAX_SAVE_STATE_SIZE);
m_undo_load_state = ByteStream::CreateGrowableMemoryStream(nullptr, System::MAX_SAVE_STATE_SIZE);
if (!System::SaveState(m_undo_load_state.get()))
{
AddOSDMessage(TranslateStdString("OSDMessage", "Failed to save undo load state."), 15.0f);
@ -3183,7 +3183,7 @@ CommonHostInterface::GetExtendedSaveStateInfo(const char* game_code, s32 slot)
return std::nullopt;
std::unique_ptr<ByteStream> stream =
FileSystem::OpenFile(path.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_SEEKABLE);
ByteStream::OpenFile(path.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_SEEKABLE);
if (!stream)
return std::nullopt;
@ -4249,7 +4249,7 @@ std::unique_ptr<ByteStream> CommonHostInterface::OpenPackageFile(const char* pat
StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s", m_program_directory.c_str(), path));
const u32 real_flags = (flags & allowed_flags) | BYTESTREAM_OPEN_READ;
Log_DevPrintf("Requesting package file '%s'", path);
return FileSystem::OpenFile(full_path.c_str(), real_flags);
return ByteStream::OpenFile(full_path.c_str(), real_flags);
}
bool CommonHostInterface::IsControllerNavigationActive() const

2
src/frontend-common/fullscreen_ui.cpp
View File

@ -482,7 +482,7 @@ static std::unique_ptr<HostDisplayTexture> LoadTexture(const char* path, bool fr
if (from_package)
stream = g_host_interface->OpenPackageFile(path, BYTESTREAM_OPEN_READ);
else
stream = FileSystem::OpenFile(path, BYTESTREAM_OPEN_READ);
stream = ByteStream::OpenFile(path, BYTESTREAM_OPEN_READ);
if (!stream)
{
Log_ErrorPrintf("Failed to open texture resource '%s'", path);

2
src/frontend-common/game_database.cpp
View File

@ -31,7 +31,7 @@ bool GameDatabase::Load()
return false;
}
std::string gamedb_data(FileSystem::ReadStreamToString(stream.get(), false));
std::string gamedb_data(ByteStream::ReadStreamToString(stream.get(), false));
if (gamedb_data.empty())
{
Log_ErrorPrintf("Failed to read game database");

16
src/frontend-common/game_list.cpp
View File

@ -249,7 +249,7 @@ void GameList::LoadCache()
return;
std::unique_ptr<ByteStream> stream =
FileSystem::OpenFile(m_cache_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
ByteStream::OpenFile(m_cache_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (!stream)
return;
@ -373,7 +373,7 @@ bool GameList::OpenCacheForWriting()
Assert(!m_cache_write_stream);
m_cache_write_stream =
FileSystem::OpenFile(m_cache_filename.c_str(), BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE |
ByteStream::OpenFile(m_cache_filename.c_str(), BYTESTREAM_OPEN_CREATE | BYTESTREAM_OPEN_WRITE |
BYTESTREAM_OPEN_APPEND | BYTESTREAM_OPEN_STREAMED);
if (!m_cache_write_stream || !m_cache_write_stream->SeekToEnd())
{
@ -793,7 +793,7 @@ void GameList::LoadCompatibilityList()
g_host_interface->OpenPackageFile("database/compatibility.xml", BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (file)
{
LoadCompatibilityListFromXML(FileSystem::ReadStreamToString(file.get()));
LoadCompatibilityListFromXML(ByteStream::ReadStreamToString(file.get()));
}
else
{
@ -805,9 +805,9 @@ void GameList::LoadCompatibilityList()
if (!m_user_compatibility_list_filename.empty() && FileSystem::FileExists(m_user_compatibility_list_filename.c_str()))
{
std::unique_ptr<ByteStream> file =
FileSystem::OpenFile(m_user_compatibility_list_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
ByteStream::OpenFile(m_user_compatibility_list_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (file)
LoadCompatibilityListFromXML(FileSystem::ReadStreamToString(file.get()));
LoadCompatibilityListFromXML(ByteStream::ReadStreamToString(file.get()));
}
}
@ -1011,7 +1011,7 @@ void GameList::LoadGameSettings()
g_host_interface->OpenPackageFile("database/gamesettings.ini", BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (file)
{
m_game_settings.Load(FileSystem::ReadStreamToString(file.get()));
m_game_settings.Load(ByteStream::ReadStreamToString(file.get()));
}
else
{
@ -1023,9 +1023,9 @@ void GameList::LoadGameSettings()
if (!m_user_game_settings_filename.empty() && FileSystem::FileExists(m_user_game_settings_filename.c_str()))
{
std::unique_ptr<ByteStream> file =
FileSystem::OpenFile(m_user_game_settings_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
ByteStream::OpenFile(m_user_game_settings_filename.c_str(), BYTESTREAM_OPEN_READ | BYTESTREAM_OPEN_STREAMED);
if (file)
m_game_settings.Load(FileSystem::ReadStreamToString(file.get()));
m_game_settings.Load(ByteStream::ReadStreamToString(file.get()));
}
}