cemu-project_Mirror/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-01-09 19:27:32 -03:00
Code Issues Projects Releases Packages Wiki Activity

Separate filestream.h into OS specific implementation files (#190)

Browse source
This commit is contained in:
goeiecool9999 2022-09-07 02:42:25 +02:00 committed by GitHub
parent f8b5024c09
commit e20bfd00ec
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
37 changed files with 550 additions and 471 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/Cafe/Account/Account.cpp
View file

@ -5,7 +5,7 @@
#include "config/ActiveSettings.h"
#include "Cafe/IOSU/legacy/iosu_crypto.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include <random>
#include <boost/random/uniform_int.hpp>

2
src/Cafe/CafeSystem.cpp
View file

@ -24,7 +24,7 @@
#include "Cafe/Filesystem/FST/FST.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "GamePatch.h"

2
src/Cafe/Filesystem/FST/FST.cpp
View file

@ -1,5 +1,5 @@
#include "Common/precompiled.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "Cemu/ncrypto/ncrypto.h"
#include "Cafe/Filesystem/WUD/wud.h"
#include "util/crypto/aes128.h"

2
src/Cafe/Filesystem/FST/KeyCache.cpp
View file

@ -3,7 +3,7 @@
#include "config/ActiveSettings.h"
#include "util/crypto/aes128.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/helpers/StringHelpers.h"
std::mutex mtxKeyCache;

2
src/Cafe/Filesystem/WUD/wud.cpp
View file

@ -2,7 +2,7 @@
#include <string.h>
#include <stdlib.h>
#include "wud.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
wud_t* wud_open(const fs::path& path)
{

2
src/Cafe/Filesystem/fscDeviceHostFS.cpp
View file

@ -2,7 +2,7 @@
#include "Cafe/Filesystem/fsc.h"
#include "Cafe/Filesystem/fscDeviceHostFS.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
/* FSCVirtualFile implementation for HostFS */

2
src/Cafe/GameProfile/GameProfile.cpp
View file

@ -4,7 +4,7 @@
#include "boost/nowide/convert.hpp"
#include "config/ActiveSettings.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/IniParser/IniParser.h"
#include "util/helpers/StringHelpers.h"
#include "Cafe/CafeSystem.h"

2
src/Cafe/GraphicPack/GraphicPack2Patches.cpp
View file

@ -1,5 +1,5 @@
#include "Cafe/GraphicPack/GraphicPack2.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/helpers/StringParser.h"
#include "Cemu/PPCAssembler/ppcAssembler.h"
#include "Cafe/OS/RPL/rpl_structs.h"

2
src/Cafe/GraphicPack/GraphicPack2PatchesApply.cpp
View file

@ -1,5 +1,5 @@
#include "Cafe/GraphicPack/GraphicPack2.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "Cemu/PPCAssembler/ppcAssembler.h"
#include "Cafe/OS/RPL/rpl_structs.h"
#include "Cafe/OS/RPL/rpl_symbol_storage.h"

2
src/Cafe/GraphicPack/GraphicPack2PatchesParser.cpp
View file

@ -1,5 +1,5 @@
#include "Cafe/GraphicPack/GraphicPack2.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/helpers/StringParser.h"
#include "Cemu/PPCAssembler/ppcAssembler.h"
#include "Cafe/OS/RPL/rpl_structs.h"

2
src/Cafe/HW/Latte/Common/RegisterSerializer.cpp
View file

@ -1,7 +1,7 @@
#include "Cafe/HW/Latte/ISA/RegDefines.h"
#include "Cafe/HW/Latte/Core/Latte.h"
#include "Cafe/HW/Latte/Common/RegisterSerializer.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include <zstd.h>
#include <zlib.h>

2
src/Cafe/IOSU/PDM/iosu_pdm.cpp
View file

@ -1,6 +1,6 @@
#include "iosu_pdm.h"
#include "config/ActiveSettings.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/helpers/Semaphore.h"
#if BOOST_OS_LINUX

2
src/Cafe/IOSU/legacy/iosu_crypto.cpp
View file

@ -9,7 +9,7 @@
#include "openssl/ecdsa.h"
#include "util/crypto/aes128.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
uint8 otpMem[1024];
bool hasOtpMem = false;

2
src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp
View file

@ -16,7 +16,7 @@
#include "util/helpers/ConcurrentQueue.h"
#include "Cafe/OS/common/PPCConcurrentQueue.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "config/ActiveSettings.h"
namespace nlibcurl

2
src/Cafe/OS/libs/nn_acp/nn_acp.cpp
View file

@ -14,7 +14,7 @@
#include "Cafe/IOSU/legacy/iosu_ioctl.h"
#include "Cafe/OS/libs/sysapp/sysapp.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "Cafe/CafeSystem.h"
#define acpPrepareRequest() \

2
src/Cafe/OS/libs/nn_aoc/nn_aoc.cpp
View file

@ -6,7 +6,7 @@
#include "Cafe/TitleList/TitleId.h"
#include "Cemu/ncrypto/ncrypto.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
namespace nn
{

2
src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp
View file

@ -3,7 +3,7 @@
#include "Cafe/OS/libs/nn_common.h"
#include "nn_nfp.h"
#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "Cafe/CafeSystem.h"
std::recursive_mutex g_nfpMutex;

2
src/Cafe/TitleList/SaveInfo.cpp
View file

@ -1,6 +1,6 @@
#include "SaveInfo.h"
#include "config/ActiveSettings.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "ParsedMetaXml.h"
SaveInfo::SaveInfo(TitleId titleId) : m_titleId(titleId)

2
src/Cafe/TitleList/TitleInfo.cpp
View file

@ -4,7 +4,7 @@
#include "Cafe/Filesystem/FST/FST.h"
#include "pugixml.hpp"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include <zarchive/zarchivereader.h>
#include "config/ActiveSettings.h"

2
src/Cafe/TitleList/TitleList.cpp
View file

@ -1,5 +1,5 @@
#include "TitleList.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/helpers/helpers.h"

2
src/Cemu/FileCache/FileCache.cpp
View file

@ -4,7 +4,7 @@
#include <mutex>
#include <condition_variable>
#include "zlib.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
struct FileCacheAsyncJob
{

2
src/Cemu/Tools/DownloadManager/DownloadManager.cpp
View file

@ -4,7 +4,7 @@
#include "gui/CemuApp.h"
#include "util/crypto/md5.h"
#include "Cafe/TitleList/TitleId.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "Cemu/FileCache/FileCache.h"
#include "Cemu/ncrypto/ncrypto.h"
#include "config/ActiveSettings.h"

2
src/Common/CMakeLists.txt
View file

@ -10,6 +10,7 @@ if(WIN32)
target_sources(CemuCommon PRIVATE
windows/platform.cpp
windows/platform.h
windows/FileStream_win32.cpp
ExceptionHandler/ExceptionHandler_win32.cpp
)
else()
@ -17,6 +18,7 @@ target_sources(CemuCommon
PRIVATE
unix/platform.cpp
unix/platform.h
unix/FileStream_unix.cpp
ExceptionHandler/ExceptionHandler_posix.cpp
)
endif()

8
src/Common/FileStream.h Normal file
View file

@ -0,0 +1,8 @@
#pragma once
#include "Common/precompiled.h"
#ifdef _WIN32
#include "Common/windows/FileStream_win32.h"
#else
#include "Common/unix/FileStream_unix.h"
#endif

441
src/Common/filestream.h
View file

@ -1,441 +0,0 @@
#pragma once
#include "Common/precompiled.h"
#include <boost/nowide/convert.hpp>
#ifdef _WIN32
class FileStream
{
public:
static FileStream* openFile(std::string_view path)
{
HANDLE hFile = CreateFileW(boost::nowide::widen(path.data(), path.size()).c_str(), FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
static FileStream* openFile(const wchar_t* path, bool allowWrite = false)
{
HANDLE hFile = CreateFileW(path, allowWrite ? (FILE_GENERIC_READ | FILE_GENERIC_WRITE) : FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
static FileStream* openFile2(const fs::path& path, bool allowWrite = false)
{
return openFile(path.generic_wstring().c_str(), allowWrite);
}
static FileStream* createFile(const wchar_t* path)
{
HANDLE hFile = CreateFileW(path, FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
static FileStream* createFile(std::string_view path)
{
auto w = boost::nowide::widen(path.data(), path.size());
HANDLE hFile = CreateFileW(w.c_str(), FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
static FileStream* createFile2(const fs::path& path)
{
return createFile(path.generic_wstring().c_str());
}
// helper function to load a file into memory
static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path)
{
FileStream* fs = openFile2(path);
if (!fs)
return std::nullopt;
uint64 fileSize = fs->GetSize();
if(fileSize > 0xFFFFFFFFull)
{
delete fs;
return std::nullopt;
}
std::optional<std::vector<uint8>> v(fileSize);
if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize)
{
delete fs;
return std::nullopt;
}
delete fs;
return v;
}
// size and seek
void SetPosition(uint64 pos)
{
LONG posHigh = (LONG)(pos >> 32);
LONG posLow = (LONG)(pos);
SetFilePointer(m_hFile, posLow, &posHigh, FILE_BEGIN);
}
uint64 GetSize()
{
DWORD fileSizeHigh = 0;
DWORD fileSizeLow = 0;
fileSizeLow = GetFileSize(m_hFile, &fileSizeHigh);
return ((uint64)fileSizeHigh << 32) | (uint64)fileSizeLow;
}
bool SetEndOfFile()
{
return ::SetEndOfFile(m_hFile) != 0;
}
// reading
void extract(std::vector<uint8>& data)
{
DWORD fileSize = GetFileSize(m_hFile, nullptr);
data.resize(fileSize);
SetFilePointer(m_hFile, 0, 0, FILE_BEGIN);
DWORD bt;
ReadFile(m_hFile, data.data(), fileSize, &bt, nullptr);
}
uint32 readData(void* data, uint32 length)
{
DWORD bytesRead = 0;
ReadFile(m_hFile, data, length, &bytesRead, NULL);
return bytesRead;
}
bool readU64(uint64& v)
{
return readData(&v, sizeof(uint64)) == sizeof(uint64);
}
bool readU32(uint32& v)
{
return readData(&v, sizeof(uint32)) == sizeof(uint32);
}
bool readU8(uint8& v)
{
return readData(&v, sizeof(uint8)) == sizeof(uint8);
}
bool readLine(std::string& line)
{
line.clear();
uint8 c;
bool isEOF = true;
while (readU8(c))
{
isEOF = false;
if(c == '\r')
continue;
if (c == '\n')
break;
line.push_back((char)c);
}
return !isEOF;
}
// writing (binary)
sint32 writeData(const void* data, sint32 length)
{
DWORD bytesWritten = 0;
WriteFile(m_hFile, data, length, &bytesWritten, NULL);
return bytesWritten;
}
void writeU64(uint64 v)
{
writeData(&v, sizeof(uint64));
}
void writeU32(uint32 v)
{
writeData(&v, sizeof(uint32));
}
void writeU8(uint8 v)
{
writeData(&v, sizeof(uint8));
}
// writing (strings)
void writeStringFmt(const char* format, ...)
{
char buffer[2048];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
writeData(buffer, (sint32)strlen(buffer));
}
void writeString(const char* str)
{
writeData(str, (sint32)strlen(str));
}
void writeLine(const char* str)
{
writeData(str, (sint32)strlen(str));
writeData("\r\n", 2);
}
~FileStream()
{
if(m_isValid)
CloseHandle(m_hFile);
}
FileStream() {};
private:
FileStream(HANDLE hFile)
{
m_hFile = hFile;
m_isValid = true;
}
bool m_isValid{};
HANDLE m_hFile;
};
#else
#include <fstream>
class FileStream
{
public:
static FileStream* openFile(std::string_view path)
{
return openFile2(path, false);
}
static FileStream* openFile(const wchar_t* path, bool allowWrite = false)
{
return openFile2(path, allowWrite);
}
static FileStream* openFile2(const fs::path& path, bool allowWrite = false)
{
//return openFile(path.generic_wstring().c_str(), allowWrite);
FileStream* fs = new FileStream(path, true, allowWrite);
if (fs->m_isValid)
return fs;
delete fs;
return nullptr;
}
static FileStream* createFile(const wchar_t* path)
{
return createFile2(path);
}
static FileStream* createFile(std::string_view path)
{
return createFile2(path);
}
static FileStream* createFile2(const fs::path& path)
{
FileStream* fs = new FileStream(path, false, false);
if (fs->m_isValid)
return fs;
delete fs;
return nullptr;
}
// helper function to load a file into memory
static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path)
{
FileStream* fs = openFile2(path);
if (!fs)
return std::nullopt;
uint64 fileSize = fs->GetSize();
if (fileSize > 0xFFFFFFFFull)
{
delete fs;
return std::nullopt;
}
std::optional<std::vector<uint8>> v(fileSize);
if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize)
{
delete fs;
return std::nullopt;
}
delete fs;
return v;
}
// size and seek
void SetPosition(uint64 pos)
{
cemu_assert(m_isValid);
if (m_prevOperationWasWrite)
m_fileStream.seekp((std::streampos)pos);
else
m_fileStream.seekg((std::streampos)pos);
}
uint64 GetSize()
{
cemu_assert(m_isValid);
auto currentPos = m_fileStream.tellg();
m_fileStream.seekg(0, std::ios::end);
auto fileSize = m_fileStream.tellg();
m_fileStream.seekg(currentPos, std::ios::beg);
uint64 fs = (uint64)fileSize;
return fs;
}
bool SetEndOfFile()
{
assert_dbg();
return true;
//return ::SetEndOfFile(m_hFile) != 0;
}
// reading
void extract(std::vector<uint8>& data)
{
uint64 fileSize = GetSize();
SetPosition(0);
data.resize(fileSize);
readData(data.data(), fileSize);
}
uint32 readData(void* data, uint32 length)
{
SyncReadWriteSeek(false);
m_fileStream.read((char*)data, length);
size_t bytesRead = m_fileStream.gcount();
return (uint32)bytesRead;
}
bool readU64(uint64& v)
{
return readData(&v, sizeof(uint64)) == sizeof(uint64);
}
bool readU32(uint32& v)
{
return readData(&v, sizeof(uint32)) == sizeof(uint32);
}
bool readU8(uint8& v)
{
return readData(&v, sizeof(uint8)) == sizeof(uint8);
}
bool readLine(std::string& line)
{
line.clear();
uint8 c;
bool isEOF = true;
while (readU8(c))
{
isEOF = false;
if (c == '\r')
continue;
if (c == '\n')
break;
line.push_back((char)c);
}
return !isEOF;
}
// writing (binary)
sint32 writeData(const void* data, sint32 length)
{
SyncReadWriteSeek(true);
m_fileStream.write((const char*)data, length);
return length;
}
void writeU64(uint64 v)
{
writeData(&v, sizeof(uint64));
}
void writeU32(uint32 v)
{
writeData(&v, sizeof(uint32));
}
void writeU8(uint8 v)
{
writeData(&v, sizeof(uint8));
}
// writing (strings)
void writeStringFmt(const char* format, ...)
{
char buffer[2048];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
writeData(buffer, (sint32)strlen(buffer));
}
void writeString(const char* str)
{
writeData(str, (sint32)strlen(str));
}
void writeLine(const char* str)
{
writeData(str, (sint32)strlen(str));
writeData("\r\n", 2);
}
~FileStream()
{
if (m_isValid)
{
m_fileStream.close();
}
// CloseHandle(m_hFile);
}
FileStream() {};
private:
FileStream(const fs::path& path, bool isOpen, bool isWriteable)
{
if (isOpen)
{
m_fileStream.open(path, isWriteable ? (std::ios_base::in | std::ios_base::out | std::ios_base::binary) : (std::ios_base::in | std::ios_base::binary));
m_isValid = m_fileStream.is_open();
}
else
{
m_fileStream.open(path, std::ios_base::in | std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
m_isValid = m_fileStream.is_open();
}
}
void SyncReadWriteSeek(bool nextOpIsWrite)
{
// nextOpIsWrite == false -> read. Otherwise write
if (nextOpIsWrite == m_prevOperationWasWrite)
return;
if (nextOpIsWrite)
m_fileStream.seekp(m_fileStream.tellg(), std::ios::beg);
else
m_fileStream.seekg(m_fileStream.tellp(), std::ios::beg);
m_prevOperationWasWrite = nextOpIsWrite;
}
bool m_isValid{};
std::fstream m_fileStream;
bool m_prevOperationWasWrite{false};
};
#endif

214
src/Common/unix/FileStream_unix.cpp Normal file
View file

@ -0,0 +1,214 @@
#include "Common/unix/FileStream_unix.h"
FileStream* FileStream::openFile(std::string_view path)
{
return openFile2(path, false);
}
FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite)
{
return openFile2(path, allowWrite);
}
FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite)
{
//return openFile(path.generic_wstring().c_str(), allowWrite);
FileStream* fs = new FileStream(path, true, allowWrite);
if (fs->m_isValid)
return fs;
delete fs;
return nullptr;
}
FileStream* FileStream::createFile(const wchar_t* path)
{
return createFile2(path);
}
FileStream* FileStream::createFile(std::string_view path)
{
return createFile2(path);
}
FileStream* FileStream::createFile2(const fs::path& path)
{
FileStream* fs = new FileStream(path, false, false);
if (fs->m_isValid)
return fs;
delete fs;
return nullptr;
}
std::optional<std::vector<uint8>> FileStream::LoadIntoMemory(const fs::path& path)
{
FileStream* fs = openFile2(path);
if (!fs)
return std::nullopt;
uint64 fileSize = fs->GetSize();
if (fileSize > 0xFFFFFFFFull)
{
delete fs;
return std::nullopt;
}
std::optional<std::vector<uint8>> v(fileSize);
if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize)
{
delete fs;
return std::nullopt;
}
delete fs;
return v;
}
void FileStream::SetPosition(uint64 pos)
{
cemu_assert(m_isValid);
if (m_prevOperationWasWrite)
m_fileStream.seekp((std::streampos)pos);
else
m_fileStream.seekg((std::streampos)pos);
}
uint64 FileStream::GetSize()
{
cemu_assert(m_isValid);
auto currentPos = m_fileStream.tellg();
m_fileStream.seekg(0, std::ios::end);
auto fileSize = m_fileStream.tellg();
m_fileStream.seekg(currentPos, std::ios::beg);
uint64 fs = (uint64)fileSize;
return fs;
}
bool FileStream::SetEndOfFile()
{
assert_dbg();
return true;
//return ::SetEndOfFile(m_hFile) != 0;
}
void FileStream::extract(std::vector<uint8>& data)
{
uint64 fileSize = GetSize();
SetPosition(0);
data.resize(fileSize);
readData(data.data(), fileSize);
}
uint32 FileStream::readData(void* data, uint32 length)
{
SyncReadWriteSeek(false);
m_fileStream.read((char*)data, length);
size_t bytesRead = m_fileStream.gcount();
return (uint32)bytesRead;
}
bool FileStream::readU64(uint64& v)
{
return readData(&v, sizeof(uint64)) == sizeof(uint64);
}
bool FileStream::readU32(uint32& v)
{
return readData(&v, sizeof(uint32)) == sizeof(uint32);
}
bool FileStream::readU8(uint8& v)
{
return readData(&v, sizeof(uint8)) == sizeof(uint8);
}
bool FileStream::readLine(std::string& line)
{
line.clear();
uint8 c;
bool isEOF = true;
while (readU8(c))
{
isEOF = false;
if (c == '\r')
continue;
if (c == '\n')
break;
line.push_back((char)c);
}
return !isEOF;
}
sint32 FileStream::writeData(const void* data, sint32 length)
{
SyncReadWriteSeek(true);
m_fileStream.write((const char*)data, length);
return length;
}
void FileStream::writeU64(uint64 v)
{
writeData(&v, sizeof(uint64));
}
void FileStream::writeU32(uint32 v)
{
writeData(&v, sizeof(uint32));
}
void FileStream::writeU8(uint8 v)
{
writeData(&v, sizeof(uint8));
}
void FileStream::writeStringFmt(const char* format, ...)
{
char buffer[2048];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
writeData(buffer, (sint32)strlen(buffer));
}
void FileStream::writeString(const char* str)
{
writeData(str, (sint32)strlen(str));
}
void FileStream::writeLine(const char* str)
{
writeData(str, (sint32)strlen(str));
writeData("\r\n", 2);
}
FileStream::~FileStream()
{
if (m_isValid)
{
m_fileStream.close();
}
// CloseHandle(m_hFile);
}
FileStream::FileStream(const fs::path& path, bool isOpen, bool isWriteable)
{
if (isOpen)
{
m_fileStream.open(path, isWriteable ? (std::ios_base::in | std::ios_base::out | std::ios_base::binary) : (std::ios_base::in | std::ios_base::binary));
m_isValid = m_fileStream.is_open();
}
else
{
m_fileStream.open(path, std::ios_base::in | std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
m_isValid = m_fileStream.is_open();
}
}
void FileStream::SyncReadWriteSeek(bool nextOpIsWrite)
{
// nextOpIsWrite == false -> read. Otherwise write
if (nextOpIsWrite == m_prevOperationWasWrite)
return;
if (nextOpIsWrite)
m_fileStream.seekp(m_fileStream.tellg(), std::ios::beg);
else
m_fileStream.seekg(m_fileStream.tellp(), std::ios::beg);
m_prevOperationWasWrite = nextOpIsWrite;
}

56
src/Common/unix/FileStream_unix.h Normal file
View file

@ -0,0 +1,56 @@
#pragma once
#include "Common/precompiled.h"
class FileStream
{
public:
static FileStream* openFile(std::string_view path);
static FileStream* openFile(const wchar_t* path, bool allowWrite = false);
static FileStream* openFile2(const fs::path& path, bool allowWrite = false);
static FileStream* createFile(const wchar_t* path);
static FileStream* createFile(std::string_view path);
static FileStream* createFile2(const fs::path& path);
// helper function to load a file into memory
static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path);
// size and seek
void SetPosition(uint64 pos);
uint64 GetSize();
bool SetEndOfFile();
void extract(std::vector<uint8>& data);
// reading
uint32 readData(void* data, uint32 length);
bool readU64(uint64& v);
bool readU32(uint32& v);
bool readU16(uint16& v);
bool readU8(uint8& v);
bool readLine(std::string& line);
// writing (binary)
sint32 writeData(const void* data, sint32 length);
void writeU64(uint64 v);
void writeU32(uint32 v);
void writeU16(uint16 v);
void writeU8(uint8 v);
// writing (strings)
void writeStringFmt(const char* format, ...);
void writeString(const char* str);
void writeLine(const char* str);
~FileStream();
FileStream() {};
private:
void SyncReadWriteSeek(bool nextOpIsWrite);
FileStream(const fs::path& path, bool isOpen, bool isWriteable);
bool m_isValid{};
std::fstream m_fileStream;
bool m_prevOperationWasWrite{false};
};

187
src/Common/windows/FileStream_win32.cpp Normal file
View file

@ -0,0 +1,187 @@
#include "Common/windows/FileStream_win32.h"
FileStream* FileStream::openFile(std::string_view path)
{
HANDLE hFile = CreateFileW(boost::nowide::widen(path.data(), path.size()).c_str(), FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite)
{
HANDLE hFile = CreateFileW(path, allowWrite ? (FILE_GENERIC_READ | FILE_GENERIC_WRITE) : FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite)
{
return openFile(path.generic_wstring().c_str(), allowWrite);
}
FileStream* FileStream::createFile(const wchar_t* path)
{
HANDLE hFile = CreateFileW(path, FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
FileStream* FileStream::createFile(std::string_view path)
{
auto w = boost::nowide::widen(path.data(), path.size());
HANDLE hFile = CreateFileW(w.c_str(), FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0);
if (hFile == INVALID_HANDLE_VALUE)
return nullptr;
return new FileStream(hFile);
}
FileStream* FileStream::createFile2(const fs::path& path)
{
return createFile(path.generic_wstring().c_str());
}
std::optional<std::vector<uint8>> FileStream::LoadIntoMemory(const fs::path& path)
{
FileStream* fs = openFile2(path);
if (!fs)
return std::nullopt;
uint64 fileSize = fs->GetSize();
if(fileSize > 0xFFFFFFFFull)
{
delete fs;
return std::nullopt;
}
std::optional<std::vector<uint8>> v(fileSize);
if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize)
{
delete fs;
return std::nullopt;
}
delete fs;
return v;
}
void FileStream::SetPosition(uint64 pos)
{
LONG posHigh = (LONG)(pos >> 32);
LONG posLow = (LONG)(pos);
SetFilePointer(m_hFile, posLow, &posHigh, FILE_BEGIN);
}
uint64 FileStream::GetSize()
{
DWORD fileSizeHigh = 0;
DWORD fileSizeLow = 0;
fileSizeLow = GetFileSize(m_hFile, &fileSizeHigh);
return ((uint64)fileSizeHigh << 32) | (uint64)fileSizeLow;
}
bool FileStream::SetEndOfFile()
{
return ::SetEndOfFile(m_hFile) != 0;
}
void FileStream::extract(std::vector<uint8>& data)
{
DWORD fileSize = GetFileSize(m_hFile, nullptr);
data.resize(fileSize);
SetFilePointer(m_hFile, 0, 0, FILE_BEGIN);
DWORD bt;
ReadFile(m_hFile, data.data(), fileSize, &bt, nullptr);
}
uint32 FileStream::readData(void* data, uint32 length)
{
DWORD bytesRead = 0;
ReadFile(m_hFile, data, length, &bytesRead, NULL);
return bytesRead;
}
bool FileStream::readU64(uint64& v)
{
return readData(&v, sizeof(uint64)) == sizeof(uint64);
}
bool FileStream::readU32(uint32& v)
{
return readData(&v, sizeof(uint32)) == sizeof(uint32);
}
bool FileStream::readU8(uint8& v)
{
return readData(&v, sizeof(uint8)) == sizeof(uint8);
}
bool FileStream::readLine(std::string& line)
{
line.clear();
uint8 c;
bool isEOF = true;
while (readU8(c))
{
isEOF = false;
if(c == '\r')
continue;
if (c == '\n')
break;
line.push_back((char)c);
}
return !isEOF;
}
sint32 FileStream::writeData(const void* data, sint32 length)
{
DWORD bytesWritten = 0;
WriteFile(m_hFile, data, length, &bytesWritten, NULL);
return bytesWritten;
}
void FileStream::writeU64(uint64 v)
{
writeData(&v, sizeof(uint64));
}
void FileStream::writeU32(uint32 v)
{
writeData(&v, sizeof(uint32));
}
void FileStream::writeU8(uint8 v)
{
writeData(&v, sizeof(uint8));
}
void FileStream::writeStringFmt(const char* format, ...)
{
char buffer[2048];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
writeData(buffer, (sint32)strlen(buffer));
}
void FileStream::writeString(const char* str)
{
writeData(str, (sint32)strlen(str));
}
void FileStream::writeLine(const char* str)
{
writeData(str, (sint32)strlen(str));
writeData("\r\n", 2);
}
FileStream::~FileStream()
{
if(m_isValid)
CloseHandle(m_hFile);
}
FileStream::FileStream(HANDLE hFile)
{
m_hFile = hFile;
m_isValid = true;
}

53
src/Common/windows/FileStream_win32.h Normal file
View file

@ -0,0 +1,53 @@
#pragma once
#include "Common/precompiled.h"
class FileStream
{
public:
static FileStream* openFile(std::string_view path);
static FileStream* openFile(const wchar_t* path, bool allowWrite = false);
static FileStream* openFile2(const fs::path& path, bool allowWrite = false);
static FileStream* createFile(const wchar_t* path);
static FileStream* createFile(std::string_view path);
static FileStream* createFile2(const fs::path& path);
// helper function to load a file into memory
static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path);
// size and seek
void SetPosition(uint64 pos);
uint64 GetSize();
bool SetEndOfFile();
void extract(std::vector<uint8>& data);
// reading
uint32 readData(void* data, uint32 length);
bool readU64(uint64& v);
bool readU32(uint32& v);
bool readU16(uint16& v);
bool readU8(uint8& v);
bool readLine(std::string& line);
// writing (binary)
sint32 writeData(const void* data, sint32 length);
void writeU64(uint64 v);
void writeU32(uint32 v);
void writeU16(uint16 v);
void writeU8(uint8 v);
// writing (strings)
void writeStringFmt(const char* format, ...);
void writeString(const char* str);
void writeLine(const char* str);
~FileStream();
FileStream() {};
private:
FileStream(HANDLE hFile);
bool m_isValid{};
HANDLE m_hFile;
};

2
src/config/XMLConfig.h
View file

@ -1,7 +1,7 @@
#pragma once
#include "util/tinyxml2/tinyxml2.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "config/ConfigValue.h"
#include <string>

2
src/gui/CemuUpdateWindow.cpp
View file

@ -4,7 +4,7 @@
#include "util/helpers/helpers.h"
#include "util/helpers/SystemException.h"
#include "config/ActiveSettings.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include <wx/sizer.h>
#include <wx/gauge.h>

2
src/gui/DownloadGraphicPacksWindow.cpp
View file

@ -8,7 +8,7 @@
#include <boost/algorithm/string.hpp>
#include "config/ActiveSettings.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "Cafe/CafeSystem.h"

2
src/gui/MemorySearcherTool.cpp
View file

@ -8,7 +8,7 @@
#include "config/ActiveSettings.h"
#include "gui/helpers/wxHelpers.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include "util/IniParser/IniParser.h"
#include "util/helpers/StringHelpers.h"
#include "Cafe/CafeSystem.h"

2
src/gui/components/wxTitleManagerList.cpp
View file

@ -31,7 +31,7 @@
#include <zarchive/zarchivewriter.h>
#include <zarchive/zarchivereader.h>
#include "Common/filestream.h"
#include "Common/FileStream.h"
wxDEFINE_EVENT(wxEVT_TITLE_FOUND, wxCommandEvent);
wxDEFINE_EVENT(wxEVT_TITLE_REMOVED, wxCommandEvent);

2
src/mainLLE.cpp
View file

@ -2,7 +2,7 @@
#include "util/crypto/aes128.h"
#include "gui/MainWindow.h"
#include "gui/guiWrapper.h"
#include "Common/filestream.h"
#include "Common/FileStream.h"
void mainEmulatorCommonInit();

2
src/util/ImageWriter/bmp.h
View file

@ -1,4 +1,4 @@
#include "Common/filestream.h"
#include "Common/FileStream.h"
static void _bmp_write(FileStream* fs, sint32 width, sint32 height, uint32 bits, void* pixelData)
{

2
src/util/ImageWriter/tga.h
View file

@ -1,4 +1,4 @@
#include "Common/filestream.h"
#include "Common/FileStream.h"
#include <vector>
static bool tga_write_rgba(wchar_t* path, sint32 width, sint32 height, uint8* pixelData)