mirror of https://github.com/PCSX2/pcsx2.git
Separate compressed file types into separate files.
Cleaner this way.
This commit is contained in:
Unknown W. Brackets
parent
4ffbd3765b
commit
334f648eaa
|
|
@ -97,22 +97,6 @@ public:
|
|||
virtual void SetDataOffset(int bytes) { m_dataoffset = bytes; }
|
||||
};
|
||||
|
||||
// Factory - creates an AsyncFileReader derived instance which can read a compressed file
|
||||
class CompressedFileReader {
|
||||
public:
|
||||
// Checks if any of the available compressed file handlers can open this
|
||||
static bool DetectCompressed(AsyncFileReader* pReader);
|
||||
|
||||
// fileName is only used to choose the compressed reader.
|
||||
// If no matching handler is found then an arbitrary handlers will be returned.
|
||||
// The returned instance still needs ->Open(filename) before usage.
|
||||
// Open(filename) may still fail.
|
||||
static AsyncFileReader* GetNewReader(const wxString& fileName);
|
||||
|
||||
private:
|
||||
virtual ~CompressedFileReader() = 0;
|
||||
};
|
||||
|
||||
class MultipartFileReader : public AsyncFileReader
|
||||
{
|
||||
DeclareNoncopyableObject( MultipartFileReader );
|
||||
|
|
|
|||
|
|
@ -0,0 +1,52 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "PrecompiledHeader.h"
|
||||
#include "ChunksCache.h"
|
||||
|
||||
void ChunksCache::SetLimit(uint megabytes) {
|
||||
m_limit = (PX_off_t)megabytes * 1024 * 1024;
|
||||
MatchLimit();
|
||||
}
|
||||
|
||||
void ChunksCache::MatchLimit(bool removeAll) {
|
||||
std::list<CacheEntry*>::reverse_iterator rit;
|
||||
while (m_entries.size() && (removeAll || m_size > m_limit)) {
|
||||
rit = m_entries.rbegin();
|
||||
m_size -= (*rit)->size;
|
||||
delete(*rit);
|
||||
m_entries.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
void ChunksCache::Take(void* pMallocedSrc, PX_off_t offset, int length, int coverage) {
|
||||
m_entries.push_front(new CacheEntry(pMallocedSrc, offset, length, coverage));
|
||||
m_size += length;
|
||||
MatchLimit();
|
||||
}
|
||||
|
||||
// By design, succeed only if the entire request is in a single cached chunk
|
||||
int ChunksCache::Read(void* pDest, PX_off_t offset, int length) {
|
||||
for (auto it = m_entries.begin(); it != m_entries.end(); it++) {
|
||||
CacheEntry* e = *it;
|
||||
if (e && offset >= e->offset && (offset + length) <= (e->offset + e->coverage)) {
|
||||
if (it != m_entries.begin())
|
||||
m_entries.splice(m_entries.begin(), m_entries, it); // Move to top (MRU)
|
||||
return CopyAvailable(e->data, e->offset, e->size, pDest, offset, length);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "zlib_indexed.h"
|
||||
|
||||
#define CLAMP(val, minval, maxval) (std::min(maxval, std::max(minval, val)))
|
||||
|
||||
class ChunksCache {
|
||||
public:
|
||||
ChunksCache(uint initialLimitMb) : m_entries(0), m_size(0), m_limit(initialLimitMb * 1024 * 1024) {};
|
||||
~ChunksCache() { Clear(); };
|
||||
void SetLimit(uint megabytes);
|
||||
void Clear() { MatchLimit(true); };
|
||||
|
||||
void Take(void* pMallocedSrc, PX_off_t offset, int length, int coverage);
|
||||
int Read(void* pDest, PX_off_t offset, int length);
|
||||
|
||||
static int CopyAvailable(void* pSrc, PX_off_t srcOffset, int srcSize,
|
||||
void* pDst, PX_off_t dstOffset, int maxCopySize) {
|
||||
int available = CLAMP(maxCopySize, 0, (int)(srcOffset + srcSize - dstOffset));
|
||||
memcpy(pDst, (char*)pSrc + (dstOffset - srcOffset), available);
|
||||
return available;
|
||||
};
|
||||
|
||||
private:
|
||||
class CacheEntry {
|
||||
public:
|
||||
CacheEntry(void* pMallocedSrc, PX_off_t offset, int length, int coverage) :
|
||||
data(pMallocedSrc),
|
||||
offset(offset),
|
||||
coverage(coverage),
|
||||
size(length)
|
||||
{};
|
||||
|
||||
~CacheEntry() { if (data) free(data); };
|
||||
|
||||
void* data;
|
||||
PX_off_t offset;
|
||||
int coverage;
|
||||
int size;
|
||||
};
|
||||
|
||||
std::list<CacheEntry*> m_entries;
|
||||
void MatchLimit(bool removeAll = false);
|
||||
PX_off_t m_size;
|
||||
PX_off_t m_limit;
|
||||
};
|
||||
|
||||
#undef CLAMP
|
||||
|
|
@ -14,931 +14,10 @@
|
|||
*/
|
||||
|
||||
#include "PrecompiledHeader.h"
|
||||
#include <wx/stdpaths.h>
|
||||
#include "AppConfig.h"
|
||||
#include "AsyncFileReader.h"
|
||||
#include "Pcsx2Types.h"
|
||||
|
||||
#include "zlib_indexed.h"
|
||||
|
||||
/////////// Some complementary utilities for zlib_indexed.c //////////
|
||||
|
||||
#include <fstream>
|
||||
|
||||
// This is ugly, but it's hard to find something which will work/compile for both
|
||||
// windows and *nix and work with non-english file names.
|
||||
// Maybe some day we'll convert all file related ops to wxWidgets, which means also the
|
||||
// instances at zlib_indexed.h (which use plain stdio FILE*)
|
||||
#ifdef WIN32
|
||||
# define PX_wfilename(name_wxstr) (WX_STR(name_wxstr))
|
||||
# define PX_fopen_rb(name_wxstr) (_wfopen(PX_wfilename(name_wxstr), L"rb"))
|
||||
#else
|
||||
# define PX_wfilename(name_wxstr) (name_wxstr.mbc_str())
|
||||
# define PX_fopen_rb(name_wxstr) (fopen(PX_wfilename(name_wxstr), "rb"))
|
||||
#endif
|
||||
|
||||
|
||||
static s64 fsize(const wxString& filename) {
|
||||
if (!wxFileName::FileExists(filename))
|
||||
return -1;
|
||||
|
||||
std::ifstream f(PX_wfilename(filename), std::ifstream::binary);
|
||||
f.seekg(0, f.end);
|
||||
s64 size = f.tellg();
|
||||
f.close();
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
#define GZIP_ID "PCSX2.index.gzip.v1|"
|
||||
#define GZIP_ID_LEN (sizeof(GZIP_ID) - 1) /* sizeof includes the \0 terminator */
|
||||
|
||||
// File format is:
|
||||
// - [GZIP_ID_LEN] GZIP_ID (no \0)
|
||||
// - [sizeof(Access)] index (should be allocated, contains various sizes)
|
||||
// - [rest] the indexed data points (should be allocated, index->list should then point to it)
|
||||
static Access* ReadIndexFromFile(const wxString& filename) {
|
||||
s64 size = fsize(filename);
|
||||
if (size <= 0) {
|
||||
Console.Error(L"Error: Can't open index file: '%s'", WX_STR(filename));
|
||||
return 0;
|
||||
}
|
||||
std::ifstream infile(PX_wfilename(filename), std::ifstream::binary);
|
||||
|
||||
char fileId[GZIP_ID_LEN + 1] = { 0 };
|
||||
infile.read(fileId, GZIP_ID_LEN);
|
||||
if (wxString::From8BitData(GZIP_ID) != wxString::From8BitData(fileId)) {
|
||||
Console.Error(L"Error: Incompatible gzip index, please delete it manually: '%s'", WX_STR(filename));
|
||||
infile.close();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Access* index = (Access*)malloc(sizeof(Access));
|
||||
infile.read((char*)index, sizeof(Access));
|
||||
|
||||
s64 datasize = size - GZIP_ID_LEN - sizeof(Access);
|
||||
if (datasize != index->have * sizeof(Point)) {
|
||||
Console.Error(L"Error: unexpected size of gzip index, please delete it manually: '%s'.", WX_STR(filename));
|
||||
infile.close();
|
||||
free(index);
|
||||
return 0;
|
||||
}
|
||||
|
||||
char* buffer = (char*)malloc(datasize);
|
||||
infile.read(buffer, datasize);
|
||||
infile.close();
|
||||
index->list = (Point*)buffer; // adjust list pointer
|
||||
return index;
|
||||
}
|
||||
|
||||
static void WriteIndexToFile(Access* index, const wxString filename) {
|
||||
if (wxFileName::FileExists(filename)) {
|
||||
Console.Warning(L"WARNING: Won't write index - file name exists (please delete it manually): '%s'", WX_STR(filename));
|
||||
return;
|
||||
}
|
||||
|
||||
std::ofstream outfile(PX_wfilename(filename), std::ofstream::binary);
|
||||
outfile.write(GZIP_ID, GZIP_ID_LEN);
|
||||
|
||||
Point* tmp = index->list;
|
||||
index->list = 0; // current pointer is useless on disk, normalize it as 0.
|
||||
outfile.write((char*)index, sizeof(Access));
|
||||
index->list = tmp;
|
||||
|
||||
outfile.write((char*)index->list, sizeof(Point) * index->have);
|
||||
outfile.close();
|
||||
|
||||
// Verify
|
||||
if (fsize(filename) != (s64)GZIP_ID_LEN + sizeof(Access) + sizeof(Point) * index->have) {
|
||||
Console.Warning(L"Warning: Can't write index file to disk: '%s'", WX_STR(filename));
|
||||
} else {
|
||||
Console.WriteLn(Color_Green, L"OK: Gzip quick access index file saved to disk: '%s'", WX_STR(filename));
|
||||
}
|
||||
}
|
||||
|
||||
/////////// End of complementary utilities for zlib_indexed.c //////////
|
||||
#define CLAMP(val, minval, maxval) (std::min(maxval, std::max(minval, val)))
|
||||
|
||||
class ChunksCache {
|
||||
public:
|
||||
ChunksCache(uint initialLimitMb) : m_entries(0), m_size(0), m_limit(initialLimitMb * 1024 * 1024) {};
|
||||
~ChunksCache() { Clear(); };
|
||||
void SetLimit(uint megabytes);
|
||||
void Clear() { MatchLimit(true); };
|
||||
|
||||
void Take(void* pMallocedSrc, PX_off_t offset, int length, int coverage);
|
||||
int Read(void* pDest, PX_off_t offset, int length);
|
||||
|
||||
static int CopyAvailable(void* pSrc, PX_off_t srcOffset, int srcSize,
|
||||
void* pDst, PX_off_t dstOffset, int maxCopySize) {
|
||||
int available = CLAMP(maxCopySize, 0, (int)(srcOffset + srcSize - dstOffset));
|
||||
memcpy(pDst, (char*)pSrc + (dstOffset - srcOffset), available);
|
||||
return available;
|
||||
};
|
||||
|
||||
private:
|
||||
class CacheEntry {
|
||||
public:
|
||||
CacheEntry(void* pMallocedSrc, PX_off_t offset, int length, int coverage) :
|
||||
data(pMallocedSrc),
|
||||
offset(offset),
|
||||
coverage(coverage),
|
||||
size(length)
|
||||
{};
|
||||
|
||||
~CacheEntry() { if (data) free(data); };
|
||||
|
||||
void* data;
|
||||
PX_off_t offset;
|
||||
int coverage;
|
||||
int size;
|
||||
};
|
||||
|
||||
std::list<CacheEntry*> m_entries;
|
||||
void MatchLimit(bool removeAll = false);
|
||||
PX_off_t m_size;
|
||||
PX_off_t m_limit;
|
||||
};
|
||||
|
||||
void ChunksCache::SetLimit(uint megabytes) {
|
||||
m_limit = (PX_off_t)megabytes * 1024 * 1024;
|
||||
MatchLimit();
|
||||
}
|
||||
|
||||
void ChunksCache::MatchLimit(bool removeAll) {
|
||||
std::list<CacheEntry*>::reverse_iterator rit;
|
||||
while (m_entries.size() && (removeAll || m_size > m_limit)) {
|
||||
rit = m_entries.rbegin();
|
||||
m_size -= (*rit)->size;
|
||||
delete(*rit);
|
||||
m_entries.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
void ChunksCache::Take(void* pMallocedSrc, PX_off_t offset, int length, int coverage) {
|
||||
m_entries.push_front(new CacheEntry(pMallocedSrc, offset, length, coverage));
|
||||
m_size += length;
|
||||
MatchLimit();
|
||||
}
|
||||
|
||||
// By design, succeed only if the entire request is in a single cached chunk
|
||||
int ChunksCache::Read(void* pDest, PX_off_t offset, int length) {
|
||||
for (auto it = m_entries.begin(); it != m_entries.end(); it++) {
|
||||
CacheEntry* e = *it;
|
||||
if (e && offset >= e->offset && (offset + length) <= (e->offset + e->coverage)) {
|
||||
if (it != m_entries.begin())
|
||||
m_entries.splice(m_entries.begin(), m_entries, it); // Move to top (MRU)
|
||||
return CopyAvailable(e->data, e->offset, e->size, pDest, offset, length);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static wxString INDEX_TEMPLATE_KEY(L"$(f)");
|
||||
// template:
|
||||
// must contain one and only one instance of '$(f)' (without the quotes)
|
||||
// if if !canEndWithKey -> must not end with $(f)
|
||||
// if starts with $(f) then it expands to the full path + file name.
|
||||
// if doesn't start with $(f) then it's expanded to file name only (with extension)
|
||||
// if doesn't start with $(f) and ends up relative,
|
||||
// then it's relative to base (not to cwd)
|
||||
// No checks are performed if the result file name can be created.
|
||||
// If this proves useful, we can move it into Path:: . Right now there's no need.
|
||||
static wxString ApplyTemplate(const wxString &name, const wxDirName &base,
|
||||
const wxString &fileTemplate, const wxString &filename,
|
||||
bool canEndWithKey)
|
||||
{
|
||||
wxString tem(fileTemplate);
|
||||
wxString key = INDEX_TEMPLATE_KEY;
|
||||
tem = tem.Trim(true).Trim(false); // both sides
|
||||
|
||||
int first = tem.find(key);
|
||||
if (first < 0 // not found
|
||||
|| first != tem.rfind(key) // more than one instance
|
||||
|| !canEndWithKey && first == tem.length() - key.length())
|
||||
{
|
||||
Console.Error(L"Invalid %s template '%s'.\n"
|
||||
L"Template must contain exactly one '%s' and must not end with it. Abotring.",
|
||||
WX_STR(name), WX_STR(tem), WX_STR(key));
|
||||
return L"";
|
||||
}
|
||||
|
||||
wxString fname(filename);
|
||||
if (first > 0)
|
||||
fname = Path::GetFilename(fname); // without path
|
||||
|
||||
tem.Replace(key, fname);
|
||||
if (first > 0)
|
||||
tem = Path::Combine(base, tem); // ignores appRoot if tem is absolute
|
||||
|
||||
return tem;
|
||||
}
|
||||
|
||||
/*
|
||||
static void TestTemplate(const wxDirName &base, const wxString &fname, bool canEndWithKey)
|
||||
{
|
||||
const char *ins[] = {
|
||||
"$(f).pindex.tmp", // same folder as the original file
|
||||
" $(f).pindex.tmp ", // same folder as the original file (trimmed silently)
|
||||
"cache/$(f).pindex", // relative to base
|
||||
"../$(f).pindex", // relative to base
|
||||
"%appdata%/pcsx2/cache/$(f).pindex", // c:/Users/<user>/AppData/Roaming/pcsx2/cache/ ...
|
||||
"c:\\pcsx2-cache/$(f).pindex", // absolute
|
||||
"~/.cache/$(f).pindex", // TODO: check if this works on *nix. It should...
|
||||
// (on windows ~ isn't recognized as special)
|
||||
"cache/$(f)/$(f).index", // invalid: appears twice
|
||||
"hello", // invalid: doesn't contain $(f)
|
||||
"hello$(f)", // invalid, can't end with $(f)
|
||||
NULL
|
||||
};
|
||||
|
||||
for (int i = 0; ins[i]; i++) {
|
||||
wxString tem(wxString::From8BitData(ins[i]));
|
||||
Console.WriteLn(Color_Green, L"test: '%s' -> '%s'",
|
||||
WX_STR(tem),
|
||||
WX_STR(ApplyTemplate(L"test", base, tem, fname, canEndWithKey)));
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
static wxString iso2indexname(const wxString& isoname) {
|
||||
//testTemplate(isoname);
|
||||
wxDirName appRoot = // TODO: have only one of this in PCSX2. Right now have few...
|
||||
(wxDirName)(wxFileName(wxStandardPaths::Get().GetExecutablePath()).GetPath());
|
||||
//TestTemplate(appRoot, isoname, false);
|
||||
return ApplyTemplate(L"gzip index", appRoot, g_Conf->GzipIsoIndexTemplate, isoname, false);
|
||||
}
|
||||
|
||||
#define SPAN_DEFAULT (1048576L * 4) /* distance between direct access points when creating a new index */
|
||||
#define READ_CHUNK_SIZE (256 * 1024) /* zlib extraction chunks size (at 0-based boundaries) */
|
||||
#define CACHE_SIZE_MB 200 /* cache size for extracted data. must be at least READ_CHUNK_SIZE (in MB)*/
|
||||
|
||||
class GzippedFileReader : public AsyncFileReader
|
||||
{
|
||||
DeclareNoncopyableObject(GzippedFileReader);
|
||||
public:
|
||||
GzippedFileReader(void) :
|
||||
m_pIndex(0),
|
||||
m_zstates(0),
|
||||
m_src(0),
|
||||
m_cache(CACHE_SIZE_MB) {
|
||||
m_blocksize = 2048;
|
||||
AsyncPrefetchReset();
|
||||
};
|
||||
|
||||
virtual ~GzippedFileReader(void) { Close(); };
|
||||
|
||||
static bool CanHandle(const wxString& fileName);
|
||||
virtual bool Open(const wxString& fileName);
|
||||
|
||||
virtual int ReadSync(void* pBuffer, uint sector, uint count);
|
||||
|
||||
virtual void BeginRead(void* pBuffer, uint sector, uint count);
|
||||
virtual int FinishRead(void);
|
||||
virtual void CancelRead(void) {};
|
||||
|
||||
virtual void Close(void);
|
||||
|
||||
virtual uint GetBlockCount(void) const {
|
||||
// type and formula copied from FlatFileReader
|
||||
// FIXME? : Shouldn't it be uint and (size - m_dataoffset) / m_blocksize ?
|
||||
return (int)((m_pIndex ? m_pIndex->uncompressed_size : 0) / m_blocksize);
|
||||
};
|
||||
|
||||
virtual void SetBlockSize(uint bytes) { m_blocksize = bytes; }
|
||||
virtual void SetDataOffset(int bytes) { m_dataoffset = bytes; }
|
||||
private:
|
||||
class Czstate {
|
||||
public:
|
||||
Czstate() { state.isValid = 0; };
|
||||
~Czstate() { Kill(); };
|
||||
void Kill() {
|
||||
if (state.isValid)
|
||||
inflateEnd(&state.strm);
|
||||
state.isValid = 0;
|
||||
}
|
||||
Zstate state;
|
||||
};
|
||||
|
||||
bool OkIndex(); // Verifies that we have an index, or try to create one
|
||||
PX_off_t GetOptimalExtractionStart(PX_off_t offset);
|
||||
int _ReadSync(void* pBuffer, PX_off_t offset, uint bytesToRead);
|
||||
void InitZstates();
|
||||
|
||||
int mBytesRead; // Temp sync read result when simulating async read
|
||||
Access* m_pIndex; // Quick access index
|
||||
Czstate* m_zstates;
|
||||
FILE* m_src;
|
||||
|
||||
ChunksCache m_cache;
|
||||
|
||||
#ifdef WIN32
|
||||
// Used by async prefetch
|
||||
HANDLE hOverlappedFile;
|
||||
OVERLAPPED asyncOperationContext;
|
||||
bool asyncInProgress;
|
||||
byte mDummyAsyncPrefetchTarget[READ_CHUNK_SIZE];
|
||||
#endif
|
||||
|
||||
void AsyncPrefetchReset();
|
||||
void AsyncPrefetchOpen();
|
||||
void AsyncPrefetchClose();
|
||||
void AsyncPrefetchChunk(PX_off_t dummy);
|
||||
void AsyncPrefetchCancel();
|
||||
};
|
||||
|
||||
void GzippedFileReader::InitZstates() {
|
||||
if (m_zstates) {
|
||||
delete[] m_zstates;
|
||||
m_zstates = 0;
|
||||
}
|
||||
if (!m_pIndex)
|
||||
return;
|
||||
|
||||
// having another extra element helps avoiding logic for last (so 2+ instead of 1+)
|
||||
int size = 2 + m_pIndex->uncompressed_size / m_pIndex->span;
|
||||
m_zstates = new Czstate[size]();
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
void GzippedFileReader::AsyncPrefetchReset() {};
|
||||
void GzippedFileReader::AsyncPrefetchOpen() {};
|
||||
void GzippedFileReader::AsyncPrefetchClose() {};
|
||||
void GzippedFileReader::AsyncPrefetchChunk(PX_off_t dummy) {};
|
||||
void GzippedFileReader::AsyncPrefetchCancel() {};
|
||||
#else
|
||||
// AsyncPrefetch works as follows:
|
||||
// ater extracting a chunk from the compressed file, ask the OS to asynchronously
|
||||
// read the next chunk from the file, and then completely ignore the result and
|
||||
// cancel the async read before the next extract. the next extract then reads the
|
||||
// data from the disk buf if it's overlapping/contained within the chunk we've
|
||||
// asked the OS to prefetch, then the OS is likely to already have it cached.
|
||||
// This procedure is frequently able to overcome seek time due to fragmentation of the
|
||||
// compressed file on disk without any meaningful penalty.
|
||||
// This system is only enabled for win32 where we have this async read request.
|
||||
void GzippedFileReader::AsyncPrefetchReset() {
|
||||
hOverlappedFile = INVALID_HANDLE_VALUE;
|
||||
asyncInProgress = false;
|
||||
}
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchOpen() {
|
||||
hOverlappedFile = CreateFile(
|
||||
m_filename,
|
||||
GENERIC_READ,
|
||||
FILE_SHARE_READ,
|
||||
NULL,
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_OVERLAPPED,
|
||||
NULL);
|
||||
};
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchClose()
|
||||
{
|
||||
AsyncPrefetchCancel();
|
||||
|
||||
if (hOverlappedFile != INVALID_HANDLE_VALUE)
|
||||
CloseHandle(hOverlappedFile);
|
||||
|
||||
AsyncPrefetchReset();
|
||||
};
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchChunk(PX_off_t start)
|
||||
{
|
||||
if (hOverlappedFile == INVALID_HANDLE_VALUE || asyncInProgress) {
|
||||
Console.Warning(L"Unexpected file handle or progress state. Aborting prefetch.");
|
||||
return;
|
||||
}
|
||||
|
||||
LARGE_INTEGER offset;
|
||||
offset.QuadPart = start;
|
||||
|
||||
DWORD bytesToRead = READ_CHUNK_SIZE;
|
||||
|
||||
ZeroMemory(&asyncOperationContext, sizeof(asyncOperationContext));
|
||||
asyncOperationContext.hEvent = 0;
|
||||
asyncOperationContext.Offset = offset.LowPart;
|
||||
asyncOperationContext.OffsetHigh = offset.HighPart;
|
||||
|
||||
ReadFile(hOverlappedFile, mDummyAsyncPrefetchTarget, bytesToRead, NULL, &asyncOperationContext);
|
||||
asyncInProgress = true;
|
||||
};
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchCancel()
|
||||
{
|
||||
if (!asyncInProgress)
|
||||
return;
|
||||
|
||||
if (!CancelIo(hOverlappedFile)) {
|
||||
Console.Warning("canceling gz prefetch failed. following prefetching will not work.");
|
||||
return;
|
||||
}
|
||||
|
||||
asyncInProgress = false;
|
||||
};
|
||||
#endif /* WIN32 */
|
||||
|
||||
// TODO: do better than just checking existance and extension
|
||||
bool GzippedFileReader::CanHandle(const wxString& fileName) {
|
||||
return wxFileName::FileExists(fileName) && fileName.Lower().EndsWith(L".gz");
|
||||
}
|
||||
|
||||
bool GzippedFileReader::OkIndex() {
|
||||
if (m_pIndex)
|
||||
return true;
|
||||
|
||||
// Try to read index from disk
|
||||
wxString indexfile = iso2indexname(m_filename);
|
||||
if (indexfile.length() == 0)
|
||||
return false; // iso2indexname(...) will print errors if it can't apply the template
|
||||
|
||||
if (wxFileName::FileExists(indexfile) && (m_pIndex = ReadIndexFromFile(indexfile))) {
|
||||
Console.WriteLn(Color_Green, L"OK: Gzip quick access index read from disk: '%s'", WX_STR(indexfile));
|
||||
if (m_pIndex->span != SPAN_DEFAULT) {
|
||||
Console.Warning(L"Note: This index has %1.1f MB intervals, while the current default for new indexes is %1.1f MB.",
|
||||
(float)m_pIndex->span / 1024 / 1024, (float)SPAN_DEFAULT / 1024 / 1024);
|
||||
Console.Warning(L"It will work fine, but if you want to generate a new index with default intervals, delete this index file.");
|
||||
Console.Warning(L"(smaller intervals mean bigger index file and quicker but more frequent decompressions)");
|
||||
}
|
||||
InitZstates();
|
||||
return true;
|
||||
}
|
||||
|
||||
// No valid index file. Generate an index
|
||||
Console.Warning(L"This may take a while (but only once). Scanning compressed file to generate a quick access index...");
|
||||
|
||||
Access *index;
|
||||
FILE* infile = PX_fopen_rb(m_filename);
|
||||
int len = build_index(infile, SPAN_DEFAULT, &index);
|
||||
printf("\n"); // build_index prints progress without \n's
|
||||
fclose(infile);
|
||||
|
||||
if (len >= 0) {
|
||||
m_pIndex = index;
|
||||
WriteIndexToFile((Access*)m_pIndex, indexfile);
|
||||
} else {
|
||||
Console.Error(L"ERROR (%d): index could not be generated for file '%s'", len, WX_STR(m_filename));
|
||||
InitZstates();
|
||||
return false;
|
||||
}
|
||||
|
||||
InitZstates();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GzippedFileReader::Open(const wxString& fileName) {
|
||||
Close();
|
||||
m_filename = fileName;
|
||||
if (!(m_src = PX_fopen_rb(m_filename)) || !CanHandle(fileName) || !OkIndex()) {
|
||||
Close();
|
||||
return false;
|
||||
};
|
||||
|
||||
AsyncPrefetchOpen();
|
||||
return true;
|
||||
};
|
||||
|
||||
void GzippedFileReader::BeginRead(void* pBuffer, uint sector, uint count) {
|
||||
// No a-sync support yet, implement as sync
|
||||
mBytesRead = ReadSync(pBuffer, sector, count);
|
||||
return;
|
||||
};
|
||||
|
||||
int GzippedFileReader::FinishRead(void) {
|
||||
int res = mBytesRead;
|
||||
mBytesRead = -1;
|
||||
return res;
|
||||
};
|
||||
|
||||
#define PTT clock_t
|
||||
#define NOW() (clock() / (CLOCKS_PER_SEC / 1000))
|
||||
|
||||
int GzippedFileReader::ReadSync(void* pBuffer, uint sector, uint count) {
|
||||
PX_off_t offset = (s64)sector * m_blocksize + m_dataoffset;
|
||||
int bytesToRead = count * m_blocksize;
|
||||
int res = _ReadSync(pBuffer, offset, bytesToRead);
|
||||
if (res < 0)
|
||||
Console.Error(L"Error: iso-gzip read unsuccessful.");
|
||||
return res;
|
||||
}
|
||||
|
||||
// If we have a valid and adequate zstate for this span, use it, else, use the index
|
||||
PX_off_t GzippedFileReader::GetOptimalExtractionStart(PX_off_t offset) {
|
||||
int span = m_pIndex->span;
|
||||
Czstate& cstate = m_zstates[offset / span];
|
||||
PX_off_t stateOffset = cstate.state.isValid ? cstate.state.out_offset : 0;
|
||||
if (stateOffset && stateOffset <= offset)
|
||||
return stateOffset; // state is faster than indexed
|
||||
|
||||
// If span is not exact multiples of READ_CHUNK_SIZE (because it was configured badly),
|
||||
// we fallback to always READ_CHUNK_SIZE boundaries
|
||||
if (span % READ_CHUNK_SIZE)
|
||||
return offset / READ_CHUNK_SIZE * READ_CHUNK_SIZE;
|
||||
|
||||
return span * (offset / span); // index direct access boundaries
|
||||
}
|
||||
|
||||
int GzippedFileReader::_ReadSync(void* pBuffer, PX_off_t offset, uint bytesToRead) {
|
||||
if (!OkIndex())
|
||||
return -1;
|
||||
|
||||
// Without all the caching, chunking and states, this would be enough:
|
||||
// return extract(m_src, m_pIndex, offset, (unsigned char*)pBuffer, bytesToRead);
|
||||
|
||||
// Split request to READ_CHUNK_SIZE chunks at READ_CHUNK_SIZE boundaries
|
||||
uint maxInChunk = READ_CHUNK_SIZE - offset % READ_CHUNK_SIZE;
|
||||
if (bytesToRead > maxInChunk) {
|
||||
int first = _ReadSync(pBuffer, offset, maxInChunk);
|
||||
if (first != maxInChunk)
|
||||
return first; // EOF or failure
|
||||
|
||||
int rest = _ReadSync((char*)pBuffer + maxInChunk, offset + maxInChunk, bytesToRead - maxInChunk);
|
||||
if (rest < 0)
|
||||
return rest;
|
||||
|
||||
return first + rest;
|
||||
}
|
||||
|
||||
// From here onwards it's guarenteed that the request is inside a single READ_CHUNK_SIZE boundaries
|
||||
|
||||
int res = m_cache.Read(pBuffer, offset, bytesToRead);
|
||||
if (res >= 0)
|
||||
return res;
|
||||
|
||||
// Not available from cache. Decompress from optimal starting
|
||||
// point in READ_CHUNK_SIZE chunks and cache each chunk.
|
||||
PTT s = NOW();
|
||||
PX_off_t extractOffset = GetOptimalExtractionStart(offset); // guaranteed in READ_CHUNK_SIZE boundaries
|
||||
int size = offset + maxInChunk - extractOffset;
|
||||
unsigned char* extracted = (unsigned char*)malloc(size);
|
||||
|
||||
int span = m_pIndex->span;
|
||||
int spanix = extractOffset / span;
|
||||
AsyncPrefetchCancel();
|
||||
res = extract(m_src, m_pIndex, extractOffset, extracted, size, &(m_zstates[spanix].state));
|
||||
if (res < 0) {
|
||||
free(extracted);
|
||||
return res;
|
||||
}
|
||||
AsyncPrefetchChunk(getInOffset(&(m_zstates[spanix].state)));
|
||||
|
||||
int copied = ChunksCache::CopyAvailable(extracted, extractOffset, res, pBuffer, offset, bytesToRead);
|
||||
|
||||
if (m_zstates[spanix].state.isValid && (extractOffset + res) / span != offset / span) {
|
||||
// The state no longer matches this span.
|
||||
// move the state to the appropriate span because it will be faster than using the index
|
||||
int targetix = (extractOffset + res) / span;
|
||||
m_zstates[targetix].Kill();
|
||||
m_zstates[targetix] = m_zstates[spanix]; // We have elements for the entire file, and another one.
|
||||
m_zstates[spanix].state.isValid = 0; // Not killing because we need the state.
|
||||
}
|
||||
|
||||
if (size <= READ_CHUNK_SIZE)
|
||||
m_cache.Take(extracted, extractOffset, res, size);
|
||||
else { // split into cacheable chunks
|
||||
for (int i = 0; i < size; i += READ_CHUNK_SIZE) {
|
||||
int available = CLAMP(res - i, 0, READ_CHUNK_SIZE);
|
||||
void* chunk = available ? malloc(available) : 0;
|
||||
if (available)
|
||||
memcpy(chunk, extracted + i, available);
|
||||
m_cache.Take(chunk, extractOffset + i, available, std::min(size - i, READ_CHUNK_SIZE));
|
||||
}
|
||||
free(extracted);
|
||||
}
|
||||
|
||||
int duration = NOW() - s;
|
||||
if (duration > 10)
|
||||
Console.WriteLn(Color_Gray, L"gunzip: chunk #%5d-%2d : %1.2f MB - %d ms",
|
||||
(int)(offset / 4 / 1024 / 1024),
|
||||
(int)(offset % (4 * 1024 * 1024) / READ_CHUNK_SIZE),
|
||||
(float)size / 1024 / 1024,
|
||||
duration);
|
||||
|
||||
return copied;
|
||||
}
|
||||
|
||||
void GzippedFileReader::Close() {
|
||||
m_filename.Empty();
|
||||
if (m_pIndex) {
|
||||
free_index((Access*)m_pIndex);
|
||||
m_pIndex = 0;
|
||||
}
|
||||
|
||||
InitZstates(); // results in delete because no index
|
||||
m_cache.Clear();
|
||||
|
||||
if (m_src) {
|
||||
fclose(m_src);
|
||||
m_src = 0;
|
||||
}
|
||||
|
||||
AsyncPrefetchClose();
|
||||
}
|
||||
|
||||
|
||||
// Implementation of CSO compressed ISO reading, based on:
|
||||
// https://github.com/unknownbrackets/maxcso/blob/master/README_CSO.md
|
||||
struct CsoHeader {
|
||||
u8 magic[4];
|
||||
u32 header_size;
|
||||
u64 total_bytes;
|
||||
u32 frame_size;
|
||||
u8 ver;
|
||||
u8 align;
|
||||
u8 reserved[2];
|
||||
};
|
||||
|
||||
static const u32 CSO_READ_BUFFER_SIZE = 256 * 1024;
|
||||
|
||||
class CsoFileReader : public AsyncFileReader
|
||||
{
|
||||
DeclareNoncopyableObject(CsoFileReader);
|
||||
public:
|
||||
CsoFileReader(void) :
|
||||
m_readBuffer(0),
|
||||
m_zlibBuffer(0),
|
||||
m_index(0),
|
||||
m_totalSize(0),
|
||||
m_src(0) {
|
||||
m_blocksize = 2048;
|
||||
};
|
||||
|
||||
virtual ~CsoFileReader(void) { Close(); };
|
||||
|
||||
static bool CanHandle(const wxString& fileName);
|
||||
virtual bool Open(const wxString& fileName);
|
||||
|
||||
virtual int ReadSync(void* pBuffer, uint sector, uint count);
|
||||
|
||||
virtual void BeginRead(void* pBuffer, uint sector, uint count);
|
||||
virtual int FinishRead(void);
|
||||
virtual void CancelRead(void);
|
||||
|
||||
virtual void Close(void);
|
||||
|
||||
virtual uint GetBlockCount(void) const {
|
||||
return (m_totalSize - m_dataoffset) / m_blocksize;
|
||||
};
|
||||
|
||||
virtual void SetBlockSize(uint bytes) { m_blocksize = bytes; }
|
||||
virtual void SetDataOffset(int bytes) { m_dataoffset = bytes; }
|
||||
|
||||
private:
|
||||
static bool ValidateHeader(const CsoHeader& hdr);
|
||||
bool ReadFileHeader();
|
||||
bool InitializeBuffers();
|
||||
int ReadFromFrame(u8 *dest, u64 pos, u64 maxBytes);
|
||||
bool DecompressFrame(u32 frame, u32 readBufferSize);
|
||||
|
||||
u32 m_frameSize;
|
||||
u8 m_frameShift;
|
||||
u8 m_indexShift;
|
||||
u8* m_readBuffer;
|
||||
u8 *m_zlibBuffer;
|
||||
u32 m_zlibBufferFrame;
|
||||
u32 *m_index;
|
||||
u64 m_totalSize;
|
||||
FILE* m_src;
|
||||
int mBytesRead; // Temp sync read result when simulating async read
|
||||
};
|
||||
|
||||
bool CsoFileReader::CanHandle(const wxString& fileName) {
|
||||
bool supported = false;
|
||||
if (wxFileName::FileExists(fileName) && fileName.Lower().EndsWith(L".cso")) {
|
||||
FILE* fp = PX_fopen_rb(fileName);
|
||||
CsoHeader hdr;
|
||||
if (fp && fread(&hdr, 1, sizeof(hdr), fp) == sizeof(hdr)) {
|
||||
supported = ValidateHeader(hdr);
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
return supported;
|
||||
}
|
||||
|
||||
bool CsoFileReader::ValidateHeader(const CsoHeader& hdr) {
|
||||
if (hdr.magic[0] != 'C' || hdr.magic[1] != 'I' || hdr.magic[2] != 'S' || hdr.magic[3] != 'O') {
|
||||
// Invalid magic, definitely a bad file.
|
||||
return false;
|
||||
}
|
||||
if (hdr.ver > 1) {
|
||||
Console.Error(L"Only CSOv1 files are supported.");
|
||||
return false;
|
||||
}
|
||||
if ((hdr.frame_size & (hdr.frame_size - 1)) != 0) {
|
||||
Console.Error(L"CSO frame size must be a power of two.");
|
||||
return false;
|
||||
}
|
||||
if (hdr.frame_size < 2048) {
|
||||
Console.Error(L"CSO frame size must be at least one sector.");
|
||||
return false;
|
||||
}
|
||||
|
||||
// All checks passed, this is a good CSO header.
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CsoFileReader::Open(const wxString& fileName) {
|
||||
Close();
|
||||
m_filename = fileName;
|
||||
m_src = PX_fopen_rb(m_filename);
|
||||
|
||||
bool success = false;
|
||||
if (m_src && ReadFileHeader() && InitializeBuffers()) {
|
||||
success = true;
|
||||
}
|
||||
|
||||
if (!success) {
|
||||
Close();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CsoFileReader::ReadFileHeader() {
|
||||
CsoHeader hdr = {};
|
||||
|
||||
PX_fseeko(m_src, m_dataoffset, SEEK_SET);
|
||||
if (fread(&hdr, 1, sizeof(hdr), m_src) != sizeof(hdr)) {
|
||||
Console.Error(L"Failed to read CSO file header.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!ValidateHeader(hdr)) {
|
||||
Console.Error(L"CSO has invalid header.");
|
||||
return false;
|
||||
}
|
||||
|
||||
m_frameSize = hdr.frame_size;
|
||||
// Determine the translation from bytes to frame.
|
||||
m_frameShift = 0;
|
||||
for (u32 i = m_frameSize; i > 1; i >>= 1) {
|
||||
++m_frameShift;
|
||||
}
|
||||
|
||||
// This is the index alignment (index values need shifting by this amount.)
|
||||
m_indexShift = hdr.align;
|
||||
m_totalSize = hdr.total_bytes;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CsoFileReader::InitializeBuffers() {
|
||||
// Round up, since part of a frame requires a full frame.
|
||||
u32 numFrames = (u32)((m_totalSize + m_frameSize - 1) / m_frameSize);
|
||||
|
||||
// We might read a bit of alignment too, so be prepared.
|
||||
if (m_frameSize + (1 << m_indexShift) < CSO_READ_BUFFER_SIZE) {
|
||||
m_readBuffer = new u8[CSO_READ_BUFFER_SIZE];
|
||||
} else {
|
||||
m_readBuffer = new u8[m_frameSize + (1 << m_indexShift)];
|
||||
}
|
||||
|
||||
// This is a buffer for the most recently decompressed frame.
|
||||
m_zlibBuffer = new u8[m_frameSize + (1 << m_indexShift)];
|
||||
m_zlibBufferFrame = numFrames;
|
||||
|
||||
const u32 indexSize = numFrames + 1;
|
||||
m_index = new u32[indexSize];
|
||||
if (fread(m_index, sizeof(u32), indexSize, m_src) != indexSize) {
|
||||
Console.Error(L"Unable to read index data from CSO.");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CsoFileReader::Close() {
|
||||
m_filename.Empty();
|
||||
|
||||
if (m_src) {
|
||||
fclose(m_src);
|
||||
m_src = 0;
|
||||
}
|
||||
|
||||
if (m_readBuffer) {
|
||||
delete[] m_readBuffer;
|
||||
m_readBuffer = 0;
|
||||
}
|
||||
if (m_zlibBuffer) {
|
||||
delete[] m_zlibBuffer;
|
||||
m_zlibBuffer = 0;
|
||||
}
|
||||
if (m_index) {
|
||||
delete[] m_index;
|
||||
m_index = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int CsoFileReader::ReadSync(void* pBuffer, uint sector, uint count) {
|
||||
u8* dest = (u8*)pBuffer;
|
||||
// We do it this way in case m_blocksize is not well aligned to our frame size.
|
||||
u64 pos = (u64)sector * (u64)m_blocksize;
|
||||
int remaining = count * m_blocksize;
|
||||
int bytes = 0;
|
||||
|
||||
while (remaining > 0) {
|
||||
int readBytes = ReadFromFrame(dest + bytes, pos + bytes, remaining);
|
||||
if (readBytes == 0) {
|
||||
// We hit EOF.
|
||||
break;
|
||||
}
|
||||
bytes += readBytes;
|
||||
remaining -= readBytes;
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
|
||||
int CsoFileReader::ReadFromFrame(u8 *dest, u64 pos, u64 maxBytes) {
|
||||
if (pos >= m_totalSize) {
|
||||
// Can't read anything passed the end.
|
||||
return 0;
|
||||
}
|
||||
|
||||
const u32 frame = (u32)(pos >> m_frameShift);
|
||||
const u32 offset = (u32)(pos - (frame << m_frameShift));
|
||||
// This is how many bytes we will actually be reading from this frame.
|
||||
const u32 bytes = (u32)(std::min(m_blocksize, static_cast<uint>(m_frameSize - offset)));
|
||||
|
||||
// Grab the index data for the frame we're about to read.
|
||||
const bool compressed = (m_index[frame + 0] & 0x80000000) == 0;
|
||||
const u32 index0 = m_index[frame + 0] & 0x7FFFFFFF;
|
||||
const u32 index1 = m_index[frame + 1] & 0x7FFFFFFF;
|
||||
|
||||
// Calculate where the compressed payload is (if compressed.)
|
||||
const u64 frameRawPos = (u64)index0 << m_indexShift;
|
||||
const u64 frameRawSize = (index1 - index0) << m_indexShift;
|
||||
|
||||
if (!compressed) {
|
||||
// Just read directly, easy.
|
||||
if (PX_fseeko(m_src, m_dataoffset + frameRawPos + offset, SEEK_SET) != 0) {
|
||||
Console.Error("Unable to seek to uncompressed CSO data.");
|
||||
return 0;
|
||||
}
|
||||
return fread(dest, 1, bytes, m_src);
|
||||
} else {
|
||||
// We don't need to decompress if we already did this same frame last time.
|
||||
if (m_zlibBufferFrame != frame) {
|
||||
if (PX_fseeko(m_src, m_dataoffset + frameRawPos, SEEK_SET) != 0) {
|
||||
Console.Error("Unable to seek to compressed CSO data.");
|
||||
return 0;
|
||||
}
|
||||
// This might be less bytes than frameRawSize in case of padding on the last frame.
|
||||
// This is because the index positions must be aligned.
|
||||
const u32 readRawBytes = fread(m_readBuffer, 1, frameRawSize, m_src);
|
||||
if (!DecompressFrame(frame, readRawBytes)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Now we just copy the offset data from the cache.
|
||||
memcpy(dest, m_zlibBuffer + offset, bytes);
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
bool CsoFileReader::DecompressFrame(u32 frame, u32 readBufferSize) {
|
||||
z_stream z;
|
||||
z.zalloc = Z_NULL;
|
||||
z.zfree = Z_NULL;
|
||||
z.opaque = Z_NULL;
|
||||
if (inflateInit2(&z, -15) != Z_OK) {
|
||||
Console.Error("Unable to initialize zlib for CSO decompression.");
|
||||
return false;
|
||||
}
|
||||
|
||||
z.next_in = m_readBuffer;
|
||||
z.avail_in = readBufferSize;
|
||||
z.next_out = m_zlibBuffer;
|
||||
z.avail_out = m_frameSize;
|
||||
|
||||
int status = inflate(&z, Z_FINISH);
|
||||
if (status != Z_STREAM_END || z.total_out != m_frameSize) {
|
||||
inflateEnd(&z);
|
||||
Console.Error("Unable to decompress CSO frame using zlib.");
|
||||
return false;
|
||||
}
|
||||
inflateEnd(&z);
|
||||
|
||||
// Our buffer now contains this frame.
|
||||
m_zlibBufferFrame = frame;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CsoFileReader::BeginRead(void* pBuffer, uint sector, uint count) {
|
||||
// TODO: No async support yet, implement as sync.
|
||||
mBytesRead = ReadSync(pBuffer, sector, count);
|
||||
}
|
||||
|
||||
int CsoFileReader::FinishRead() {
|
||||
int res = mBytesRead;
|
||||
mBytesRead = -1;
|
||||
return res;
|
||||
}
|
||||
|
||||
void CsoFileReader::CancelRead() {
|
||||
// TODO: No async read support yet.
|
||||
}
|
||||
|
||||
#include "CompressedFileReader.h"
|
||||
#include "CsoFileReader.h"
|
||||
#include "GzippedFileReader.h"
|
||||
|
||||
// CompressedFileReader factory.
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
// Factory - creates an AsyncFileReader derived instance which can read a compressed file
|
||||
class CompressedFileReader {
|
||||
public:
|
||||
// Checks if any of the available compressed file handlers can open this
|
||||
static bool DetectCompressed(AsyncFileReader* pReader);
|
||||
|
||||
// fileName is only used to choose the compressed reader.
|
||||
// If no matching handler is found then an arbitrary handlers will be returned.
|
||||
// The returned instance still needs ->Open(filename) before usage.
|
||||
// Open(filename) may still fail.
|
||||
static AsyncFileReader* GetNewReader(const wxString& fileName);
|
||||
|
||||
private:
|
||||
virtual ~CompressedFileReader() = 0;
|
||||
};
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/////////// Some complementary utilities for zlib_indexed.c //////////
|
||||
|
||||
// This is ugly, but it's hard to find something which will work/compile for both
|
||||
// windows and *nix and work with non-english file names.
|
||||
// Maybe some day we'll convert all file related ops to wxWidgets, which means also the
|
||||
// instances at zlib_indexed.h (which use plain stdio FILE*)
|
||||
#ifdef WIN32
|
||||
# define PX_wfilename(name_wxstr) (WX_STR(name_wxstr))
|
||||
# define PX_fopen_rb(name_wxstr) (_wfopen(PX_wfilename(name_wxstr), L"rb"))
|
||||
#else
|
||||
# define PX_wfilename(name_wxstr) (name_wxstr.mbc_str())
|
||||
# define PX_fopen_rb(name_wxstr) (fopen(PX_wfilename(name_wxstr), "rb"))
|
||||
#endif
|
||||
|
||||
/////////// End of complementary utilities for zlib_indexed.c //////////
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "PrecompiledHeader.h"
|
||||
#include "AsyncFileReader.h"
|
||||
#include "CompressedFileReaderUtils.h"
|
||||
#include "CsoFileReader.h"
|
||||
#include "Pcsx2Types.h"
|
||||
#include "zlib_indexed.h"
|
||||
|
||||
// Implementation of CSO compressed ISO reading, based on:
|
||||
// https://github.com/unknownbrackets/maxcso/blob/master/README_CSO.md
|
||||
struct CsoHeader {
|
||||
u8 magic[4];
|
||||
u32 header_size;
|
||||
u64 total_bytes;
|
||||
u32 frame_size;
|
||||
u8 ver;
|
||||
u8 align;
|
||||
u8 reserved[2];
|
||||
};
|
||||
|
||||
static const u32 CSO_READ_BUFFER_SIZE = 256 * 1024;
|
||||
|
||||
bool CsoFileReader::CanHandle(const wxString& fileName) {
|
||||
bool supported = false;
|
||||
if (wxFileName::FileExists(fileName) && fileName.Lower().EndsWith(L".cso")) {
|
||||
FILE* fp = PX_fopen_rb(fileName);
|
||||
CsoHeader hdr;
|
||||
if (fp && fread(&hdr, 1, sizeof(hdr), fp) == sizeof(hdr)) {
|
||||
supported = ValidateHeader(hdr);
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
return supported;
|
||||
}
|
||||
|
||||
bool CsoFileReader::ValidateHeader(const CsoHeader& hdr) {
|
||||
if (hdr.magic[0] != 'C' || hdr.magic[1] != 'I' || hdr.magic[2] != 'S' || hdr.magic[3] != 'O') {
|
||||
// Invalid magic, definitely a bad file.
|
||||
return false;
|
||||
}
|
||||
if (hdr.ver > 1) {
|
||||
Console.Error(L"Only CSOv1 files are supported.");
|
||||
return false;
|
||||
}
|
||||
if ((hdr.frame_size & (hdr.frame_size - 1)) != 0) {
|
||||
Console.Error(L"CSO frame size must be a power of two.");
|
||||
return false;
|
||||
}
|
||||
if (hdr.frame_size < 2048) {
|
||||
Console.Error(L"CSO frame size must be at least one sector.");
|
||||
return false;
|
||||
}
|
||||
|
||||
// All checks passed, this is a good CSO header.
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CsoFileReader::Open(const wxString& fileName) {
|
||||
Close();
|
||||
m_filename = fileName;
|
||||
m_src = PX_fopen_rb(m_filename);
|
||||
|
||||
bool success = false;
|
||||
if (m_src && ReadFileHeader() && InitializeBuffers()) {
|
||||
success = true;
|
||||
}
|
||||
|
||||
if (!success) {
|
||||
Close();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CsoFileReader::ReadFileHeader() {
|
||||
CsoHeader hdr = {};
|
||||
|
||||
PX_fseeko(m_src, m_dataoffset, SEEK_SET);
|
||||
if (fread(&hdr, 1, sizeof(hdr), m_src) != sizeof(hdr)) {
|
||||
Console.Error(L"Failed to read CSO file header.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!ValidateHeader(hdr)) {
|
||||
Console.Error(L"CSO has invalid header.");
|
||||
return false;
|
||||
}
|
||||
|
||||
m_frameSize = hdr.frame_size;
|
||||
// Determine the translation from bytes to frame.
|
||||
m_frameShift = 0;
|
||||
for (u32 i = m_frameSize; i > 1; i >>= 1) {
|
||||
++m_frameShift;
|
||||
}
|
||||
|
||||
// This is the index alignment (index values need shifting by this amount.)
|
||||
m_indexShift = hdr.align;
|
||||
m_totalSize = hdr.total_bytes;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CsoFileReader::InitializeBuffers() {
|
||||
// Round up, since part of a frame requires a full frame.
|
||||
u32 numFrames = (u32)((m_totalSize + m_frameSize - 1) / m_frameSize);
|
||||
|
||||
// We might read a bit of alignment too, so be prepared.
|
||||
if (m_frameSize + (1 << m_indexShift) < CSO_READ_BUFFER_SIZE) {
|
||||
m_readBuffer = new u8[CSO_READ_BUFFER_SIZE];
|
||||
} else {
|
||||
m_readBuffer = new u8[m_frameSize + (1 << m_indexShift)];
|
||||
}
|
||||
|
||||
// This is a buffer for the most recently decompressed frame.
|
||||
m_zlibBuffer = new u8[m_frameSize + (1 << m_indexShift)];
|
||||
m_zlibBufferFrame = numFrames;
|
||||
|
||||
const u32 indexSize = numFrames + 1;
|
||||
m_index = new u32[indexSize];
|
||||
if (fread(m_index, sizeof(u32), indexSize, m_src) != indexSize) {
|
||||
Console.Error(L"Unable to read index data from CSO.");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CsoFileReader::Close() {
|
||||
m_filename.Empty();
|
||||
|
||||
if (m_src) {
|
||||
fclose(m_src);
|
||||
m_src = 0;
|
||||
}
|
||||
|
||||
if (m_readBuffer) {
|
||||
delete[] m_readBuffer;
|
||||
m_readBuffer = 0;
|
||||
}
|
||||
if (m_zlibBuffer) {
|
||||
delete[] m_zlibBuffer;
|
||||
m_zlibBuffer = 0;
|
||||
}
|
||||
if (m_index) {
|
||||
delete[] m_index;
|
||||
m_index = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int CsoFileReader::ReadSync(void* pBuffer, uint sector, uint count) {
|
||||
if (!m_src) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8* dest = (u8*)pBuffer;
|
||||
// We do it this way in case m_blocksize is not well aligned to our frame size.
|
||||
u64 pos = (u64)sector * (u64)m_blocksize;
|
||||
int remaining = count * m_blocksize;
|
||||
int bytes = 0;
|
||||
|
||||
while (remaining > 0) {
|
||||
int readBytes = ReadFromFrame(dest + bytes, pos + bytes, remaining);
|
||||
if (readBytes == 0) {
|
||||
// We hit EOF.
|
||||
break;
|
||||
}
|
||||
bytes += readBytes;
|
||||
remaining -= readBytes;
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
|
||||
int CsoFileReader::ReadFromFrame(u8 *dest, u64 pos, u64 maxBytes) {
|
||||
if (pos >= m_totalSize) {
|
||||
// Can't read anything passed the end.
|
||||
return 0;
|
||||
}
|
||||
|
||||
const u32 frame = (u32)(pos >> m_frameShift);
|
||||
const u32 offset = (u32)(pos - (frame << m_frameShift));
|
||||
// This is how many bytes we will actually be reading from this frame.
|
||||
const u32 bytes = (u32)(std::min(m_blocksize, static_cast<uint>(m_frameSize - offset)));
|
||||
|
||||
// Grab the index data for the frame we're about to read.
|
||||
const bool compressed = (m_index[frame + 0] & 0x80000000) == 0;
|
||||
const u32 index0 = m_index[frame + 0] & 0x7FFFFFFF;
|
||||
const u32 index1 = m_index[frame + 1] & 0x7FFFFFFF;
|
||||
|
||||
// Calculate where the compressed payload is (if compressed.)
|
||||
const u64 frameRawPos = (u64)index0 << m_indexShift;
|
||||
const u64 frameRawSize = (index1 - index0) << m_indexShift;
|
||||
|
||||
if (!compressed) {
|
||||
// Just read directly, easy.
|
||||
if (PX_fseeko(m_src, m_dataoffset + frameRawPos + offset, SEEK_SET) != 0) {
|
||||
Console.Error("Unable to seek to uncompressed CSO data.");
|
||||
return 0;
|
||||
}
|
||||
return fread(dest, 1, bytes, m_src);
|
||||
} else {
|
||||
// We don't need to decompress if we already did this same frame last time.
|
||||
if (m_zlibBufferFrame != frame) {
|
||||
if (PX_fseeko(m_src, m_dataoffset + frameRawPos, SEEK_SET) != 0) {
|
||||
Console.Error("Unable to seek to compressed CSO data.");
|
||||
return 0;
|
||||
}
|
||||
// This might be less bytes than frameRawSize in case of padding on the last frame.
|
||||
// This is because the index positions must be aligned.
|
||||
const u32 readRawBytes = fread(m_readBuffer, 1, frameRawSize, m_src);
|
||||
if (!DecompressFrame(frame, readRawBytes)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Now we just copy the offset data from the cache.
|
||||
memcpy(dest, m_zlibBuffer + offset, bytes);
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
bool CsoFileReader::DecompressFrame(u32 frame, u32 readBufferSize) {
|
||||
z_stream z;
|
||||
z.zalloc = Z_NULL;
|
||||
z.zfree = Z_NULL;
|
||||
z.opaque = Z_NULL;
|
||||
if (inflateInit2(&z, -15) != Z_OK) {
|
||||
Console.Error("Unable to initialize zlib for CSO decompression.");
|
||||
return false;
|
||||
}
|
||||
|
||||
z.next_in = m_readBuffer;
|
||||
z.avail_in = readBufferSize;
|
||||
z.next_out = m_zlibBuffer;
|
||||
z.avail_out = m_frameSize;
|
||||
|
||||
int status = inflate(&z, Z_FINISH);
|
||||
if (status != Z_STREAM_END || z.total_out != m_frameSize) {
|
||||
inflateEnd(&z);
|
||||
Console.Error("Unable to decompress CSO frame using zlib.");
|
||||
return false;
|
||||
}
|
||||
inflateEnd(&z);
|
||||
|
||||
// Our buffer now contains this frame.
|
||||
m_zlibBufferFrame = frame;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CsoFileReader::BeginRead(void* pBuffer, uint sector, uint count) {
|
||||
// TODO: No async support yet, implement as sync.
|
||||
mBytesRead = ReadSync(pBuffer, sector, count);
|
||||
}
|
||||
|
||||
int CsoFileReader::FinishRead() {
|
||||
int res = mBytesRead;
|
||||
mBytesRead = -1;
|
||||
return res;
|
||||
}
|
||||
|
||||
void CsoFileReader::CancelRead() {
|
||||
// TODO: No async read support yet.
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "AsyncFileReader.h"
|
||||
|
||||
struct CsoHeader;
|
||||
|
||||
class CsoFileReader : public AsyncFileReader
|
||||
{
|
||||
DeclareNoncopyableObject(CsoFileReader);
|
||||
public:
|
||||
CsoFileReader(void) :
|
||||
m_readBuffer(0),
|
||||
m_zlibBuffer(0),
|
||||
m_index(0),
|
||||
m_totalSize(0),
|
||||
m_src(0) {
|
||||
m_blocksize = 2048;
|
||||
};
|
||||
|
||||
virtual ~CsoFileReader(void) { Close(); };
|
||||
|
||||
static bool CanHandle(const wxString& fileName);
|
||||
virtual bool Open(const wxString& fileName);
|
||||
|
||||
virtual int ReadSync(void* pBuffer, uint sector, uint count);
|
||||
|
||||
virtual void BeginRead(void* pBuffer, uint sector, uint count);
|
||||
virtual int FinishRead(void);
|
||||
virtual void CancelRead(void);
|
||||
|
||||
virtual void Close(void);
|
||||
|
||||
virtual uint GetBlockCount(void) const {
|
||||
return (m_totalSize - m_dataoffset) / m_blocksize;
|
||||
};
|
||||
|
||||
virtual void SetBlockSize(uint bytes) { m_blocksize = bytes; }
|
||||
virtual void SetDataOffset(int bytes) { m_dataoffset = bytes; }
|
||||
|
||||
private:
|
||||
static bool ValidateHeader(const CsoHeader& hdr);
|
||||
bool ReadFileHeader();
|
||||
bool InitializeBuffers();
|
||||
int ReadFromFrame(u8 *dest, u64 pos, u64 maxBytes);
|
||||
bool DecompressFrame(u32 frame, u32 readBufferSize);
|
||||
|
||||
u32 m_frameSize;
|
||||
u8 m_frameShift;
|
||||
u8 m_indexShift;
|
||||
u8* m_readBuffer;
|
||||
u8 *m_zlibBuffer;
|
||||
u32 m_zlibBufferFrame;
|
||||
u32 *m_index;
|
||||
u64 m_totalSize;
|
||||
// The actual source cso file handle.
|
||||
FILE* m_src;
|
||||
// The result of a read is stored here between BeginRead() and FinishRead().
|
||||
int mBytesRead;
|
||||
};
|
||||
|
|
@ -0,0 +1,474 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "PrecompiledHeader.h"
|
||||
#include <fstream>
|
||||
#include <wx/stdpaths.h>
|
||||
#include "AppConfig.h"
|
||||
#include "ChunksCache.h"
|
||||
#include "CompressedFileReaderUtils.h"
|
||||
#include "GzippedFileReader.h"
|
||||
#include "zlib_indexed.h"
|
||||
|
||||
#define CLAMP(val, minval, maxval) (std::min(maxval, std::max(minval, val)))
|
||||
|
||||
static s64 fsize(const wxString& filename) {
|
||||
if (!wxFileName::FileExists(filename))
|
||||
return -1;
|
||||
|
||||
std::ifstream f(PX_wfilename(filename), std::ifstream::binary);
|
||||
f.seekg(0, f.end);
|
||||
s64 size = f.tellg();
|
||||
f.close();
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
#define GZIP_ID "PCSX2.index.gzip.v1|"
|
||||
#define GZIP_ID_LEN (sizeof(GZIP_ID) - 1) /* sizeof includes the \0 terminator */
|
||||
|
||||
// File format is:
|
||||
// - [GZIP_ID_LEN] GZIP_ID (no \0)
|
||||
// - [sizeof(Access)] index (should be allocated, contains various sizes)
|
||||
// - [rest] the indexed data points (should be allocated, index->list should then point to it)
|
||||
static Access* ReadIndexFromFile(const wxString& filename) {
|
||||
s64 size = fsize(filename);
|
||||
if (size <= 0) {
|
||||
Console.Error(L"Error: Can't open index file: '%s'", WX_STR(filename));
|
||||
return 0;
|
||||
}
|
||||
std::ifstream infile(PX_wfilename(filename), std::ifstream::binary);
|
||||
|
||||
char fileId[GZIP_ID_LEN + 1] = { 0 };
|
||||
infile.read(fileId, GZIP_ID_LEN);
|
||||
if (wxString::From8BitData(GZIP_ID) != wxString::From8BitData(fileId)) {
|
||||
Console.Error(L"Error: Incompatible gzip index, please delete it manually: '%s'", WX_STR(filename));
|
||||
infile.close();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Access* index = (Access*)malloc(sizeof(Access));
|
||||
infile.read((char*)index, sizeof(Access));
|
||||
|
||||
s64 datasize = size - GZIP_ID_LEN - sizeof(Access);
|
||||
if (datasize != index->have * sizeof(Point)) {
|
||||
Console.Error(L"Error: unexpected size of gzip index, please delete it manually: '%s'.", WX_STR(filename));
|
||||
infile.close();
|
||||
free(index);
|
||||
return 0;
|
||||
}
|
||||
|
||||
char* buffer = (char*)malloc(datasize);
|
||||
infile.read(buffer, datasize);
|
||||
infile.close();
|
||||
index->list = (Point*)buffer; // adjust list pointer
|
||||
return index;
|
||||
}
|
||||
|
||||
static void WriteIndexToFile(Access* index, const wxString filename) {
|
||||
if (wxFileName::FileExists(filename)) {
|
||||
Console.Warning(L"WARNING: Won't write index - file name exists (please delete it manually): '%s'", WX_STR(filename));
|
||||
return;
|
||||
}
|
||||
|
||||
std::ofstream outfile(PX_wfilename(filename), std::ofstream::binary);
|
||||
outfile.write(GZIP_ID, GZIP_ID_LEN);
|
||||
|
||||
Point* tmp = index->list;
|
||||
index->list = 0; // current pointer is useless on disk, normalize it as 0.
|
||||
outfile.write((char*)index, sizeof(Access));
|
||||
index->list = tmp;
|
||||
|
||||
outfile.write((char*)index->list, sizeof(Point) * index->have);
|
||||
outfile.close();
|
||||
|
||||
// Verify
|
||||
if (fsize(filename) != (s64)GZIP_ID_LEN + sizeof(Access) + sizeof(Point) * index->have) {
|
||||
Console.Warning(L"Warning: Can't write index file to disk: '%s'", WX_STR(filename));
|
||||
} else {
|
||||
Console.WriteLn(Color_Green, L"OK: Gzip quick access index file saved to disk: '%s'", WX_STR(filename));
|
||||
}
|
||||
}
|
||||
|
||||
static wxString INDEX_TEMPLATE_KEY(L"$(f)");
|
||||
// template:
|
||||
// must contain one and only one instance of '$(f)' (without the quotes)
|
||||
// if if !canEndWithKey -> must not end with $(f)
|
||||
// if starts with $(f) then it expands to the full path + file name.
|
||||
// if doesn't start with $(f) then it's expanded to file name only (with extension)
|
||||
// if doesn't start with $(f) and ends up relative,
|
||||
// then it's relative to base (not to cwd)
|
||||
// No checks are performed if the result file name can be created.
|
||||
// If this proves useful, we can move it into Path:: . Right now there's no need.
|
||||
static wxString ApplyTemplate(const wxString &name, const wxDirName &base,
|
||||
const wxString &fileTemplate, const wxString &filename,
|
||||
bool canEndWithKey)
|
||||
{
|
||||
wxString tem(fileTemplate);
|
||||
wxString key = INDEX_TEMPLATE_KEY;
|
||||
tem = tem.Trim(true).Trim(false); // both sides
|
||||
|
||||
int first = tem.find(key);
|
||||
if (first < 0 // not found
|
||||
|| first != tem.rfind(key) // more than one instance
|
||||
|| !canEndWithKey && first == tem.length() - key.length())
|
||||
{
|
||||
Console.Error(L"Invalid %s template '%s'.\n"
|
||||
L"Template must contain exactly one '%s' and must not end with it. Abotring.",
|
||||
WX_STR(name), WX_STR(tem), WX_STR(key));
|
||||
return L"";
|
||||
}
|
||||
|
||||
wxString fname(filename);
|
||||
if (first > 0)
|
||||
fname = Path::GetFilename(fname); // without path
|
||||
|
||||
tem.Replace(key, fname);
|
||||
if (first > 0)
|
||||
tem = Path::Combine(base, tem); // ignores appRoot if tem is absolute
|
||||
|
||||
return tem;
|
||||
}
|
||||
|
||||
/*
|
||||
static void TestTemplate(const wxDirName &base, const wxString &fname, bool canEndWithKey)
|
||||
{
|
||||
const char *ins[] = {
|
||||
"$(f).pindex.tmp", // same folder as the original file
|
||||
" $(f).pindex.tmp ", // same folder as the original file (trimmed silently)
|
||||
"cache/$(f).pindex", // relative to base
|
||||
"../$(f).pindex", // relative to base
|
||||
"%appdata%/pcsx2/cache/$(f).pindex", // c:/Users/<user>/AppData/Roaming/pcsx2/cache/ ...
|
||||
"c:\\pcsx2-cache/$(f).pindex", // absolute
|
||||
"~/.cache/$(f).pindex", // TODO: check if this works on *nix. It should...
|
||||
// (on windows ~ isn't recognized as special)
|
||||
"cache/$(f)/$(f).index", // invalid: appears twice
|
||||
"hello", // invalid: doesn't contain $(f)
|
||||
"hello$(f)", // invalid, can't end with $(f)
|
||||
NULL
|
||||
};
|
||||
|
||||
for (int i = 0; ins[i]; i++) {
|
||||
wxString tem(wxString::From8BitData(ins[i]));
|
||||
Console.WriteLn(Color_Green, L"test: '%s' -> '%s'",
|
||||
WX_STR(tem),
|
||||
WX_STR(ApplyTemplate(L"test", base, tem, fname, canEndWithKey)));
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
static wxString iso2indexname(const wxString& isoname) {
|
||||
//testTemplate(isoname);
|
||||
wxDirName appRoot = // TODO: have only one of this in PCSX2. Right now have few...
|
||||
(wxDirName)(wxFileName(wxStandardPaths::Get().GetExecutablePath()).GetPath());
|
||||
//TestTemplate(appRoot, isoname, false);
|
||||
return ApplyTemplate(L"gzip index", appRoot, g_Conf->GzipIsoIndexTemplate, isoname, false);
|
||||
}
|
||||
|
||||
GzippedFileReader::GzippedFileReader(void) :
|
||||
m_pIndex(0),
|
||||
m_zstates(0),
|
||||
m_src(0),
|
||||
m_cache(CACHE_SIZE_MB) {
|
||||
m_blocksize = 2048;
|
||||
AsyncPrefetchReset();
|
||||
};
|
||||
|
||||
void GzippedFileReader::InitZstates() {
|
||||
if (m_zstates) {
|
||||
delete[] m_zstates;
|
||||
m_zstates = 0;
|
||||
}
|
||||
if (!m_pIndex)
|
||||
return;
|
||||
|
||||
// having another extra element helps avoiding logic for last (so 2+ instead of 1+)
|
||||
int size = 2 + m_pIndex->uncompressed_size / m_pIndex->span;
|
||||
m_zstates = new Czstate[size]();
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
void GzippedFileReader::AsyncPrefetchReset() {};
|
||||
void GzippedFileReader::AsyncPrefetchOpen() {};
|
||||
void GzippedFileReader::AsyncPrefetchClose() {};
|
||||
void GzippedFileReader::AsyncPrefetchChunk(PX_off_t dummy) {};
|
||||
void GzippedFileReader::AsyncPrefetchCancel() {};
|
||||
#else
|
||||
// AsyncPrefetch works as follows:
|
||||
// ater extracting a chunk from the compressed file, ask the OS to asynchronously
|
||||
// read the next chunk from the file, and then completely ignore the result and
|
||||
// cancel the async read before the next extract. the next extract then reads the
|
||||
// data from the disk buf if it's overlapping/contained within the chunk we've
|
||||
// asked the OS to prefetch, then the OS is likely to already have it cached.
|
||||
// This procedure is frequently able to overcome seek time due to fragmentation of the
|
||||
// compressed file on disk without any meaningful penalty.
|
||||
// This system is only enabled for win32 where we have this async read request.
|
||||
void GzippedFileReader::AsyncPrefetchReset() {
|
||||
hOverlappedFile = INVALID_HANDLE_VALUE;
|
||||
asyncInProgress = false;
|
||||
}
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchOpen() {
|
||||
hOverlappedFile = CreateFile(
|
||||
m_filename,
|
||||
GENERIC_READ,
|
||||
FILE_SHARE_READ,
|
||||
NULL,
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_OVERLAPPED,
|
||||
NULL);
|
||||
};
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchClose()
|
||||
{
|
||||
AsyncPrefetchCancel();
|
||||
|
||||
if (hOverlappedFile != INVALID_HANDLE_VALUE)
|
||||
CloseHandle(hOverlappedFile);
|
||||
|
||||
AsyncPrefetchReset();
|
||||
};
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchChunk(PX_off_t start)
|
||||
{
|
||||
if (hOverlappedFile == INVALID_HANDLE_VALUE || asyncInProgress) {
|
||||
Console.Warning(L"Unexpected file handle or progress state. Aborting prefetch.");
|
||||
return;
|
||||
}
|
||||
|
||||
LARGE_INTEGER offset;
|
||||
offset.QuadPart = start;
|
||||
|
||||
DWORD bytesToRead = READ_CHUNK_SIZE;
|
||||
|
||||
ZeroMemory(&asyncOperationContext, sizeof(asyncOperationContext));
|
||||
asyncOperationContext.hEvent = 0;
|
||||
asyncOperationContext.Offset = offset.LowPart;
|
||||
asyncOperationContext.OffsetHigh = offset.HighPart;
|
||||
|
||||
ReadFile(hOverlappedFile, mDummyAsyncPrefetchTarget, bytesToRead, NULL, &asyncOperationContext);
|
||||
asyncInProgress = true;
|
||||
};
|
||||
|
||||
void GzippedFileReader::AsyncPrefetchCancel()
|
||||
{
|
||||
if (!asyncInProgress)
|
||||
return;
|
||||
|
||||
if (!CancelIo(hOverlappedFile)) {
|
||||
Console.Warning("canceling gz prefetch failed. following prefetching will not work.");
|
||||
return;
|
||||
}
|
||||
|
||||
asyncInProgress = false;
|
||||
};
|
||||
#endif /* WIN32 */
|
||||
|
||||
// TODO: do better than just checking existance and extension
|
||||
bool GzippedFileReader::CanHandle(const wxString& fileName) {
|
||||
return wxFileName::FileExists(fileName) && fileName.Lower().EndsWith(L".gz");
|
||||
}
|
||||
|
||||
bool GzippedFileReader::OkIndex() {
|
||||
if (m_pIndex)
|
||||
return true;
|
||||
|
||||
// Try to read index from disk
|
||||
wxString indexfile = iso2indexname(m_filename);
|
||||
if (indexfile.length() == 0)
|
||||
return false; // iso2indexname(...) will print errors if it can't apply the template
|
||||
|
||||
if (wxFileName::FileExists(indexfile) && (m_pIndex = ReadIndexFromFile(indexfile))) {
|
||||
Console.WriteLn(Color_Green, L"OK: Gzip quick access index read from disk: '%s'", WX_STR(indexfile));
|
||||
if (m_pIndex->span != SPAN_DEFAULT) {
|
||||
Console.Warning(L"Note: This index has %1.1f MB intervals, while the current default for new indexes is %1.1f MB.",
|
||||
(float)m_pIndex->span / 1024 / 1024, (float)SPAN_DEFAULT / 1024 / 1024);
|
||||
Console.Warning(L"It will work fine, but if you want to generate a new index with default intervals, delete this index file.");
|
||||
Console.Warning(L"(smaller intervals mean bigger index file and quicker but more frequent decompressions)");
|
||||
}
|
||||
InitZstates();
|
||||
return true;
|
||||
}
|
||||
|
||||
// No valid index file. Generate an index
|
||||
Console.Warning(L"This may take a while (but only once). Scanning compressed file to generate a quick access index...");
|
||||
|
||||
Access *index;
|
||||
FILE* infile = PX_fopen_rb(m_filename);
|
||||
int len = build_index(infile, SPAN_DEFAULT, &index);
|
||||
printf("\n"); // build_index prints progress without \n's
|
||||
fclose(infile);
|
||||
|
||||
if (len >= 0) {
|
||||
m_pIndex = index;
|
||||
WriteIndexToFile((Access*)m_pIndex, indexfile);
|
||||
} else {
|
||||
Console.Error(L"ERROR (%d): index could not be generated for file '%s'", len, WX_STR(m_filename));
|
||||
InitZstates();
|
||||
return false;
|
||||
}
|
||||
|
||||
InitZstates();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GzippedFileReader::Open(const wxString& fileName) {
|
||||
Close();
|
||||
m_filename = fileName;
|
||||
if (!(m_src = PX_fopen_rb(m_filename)) || !CanHandle(fileName) || !OkIndex()) {
|
||||
Close();
|
||||
return false;
|
||||
};
|
||||
|
||||
AsyncPrefetchOpen();
|
||||
return true;
|
||||
};
|
||||
|
||||
void GzippedFileReader::BeginRead(void* pBuffer, uint sector, uint count) {
|
||||
// No a-sync support yet, implement as sync
|
||||
mBytesRead = ReadSync(pBuffer, sector, count);
|
||||
return;
|
||||
};
|
||||
|
||||
int GzippedFileReader::FinishRead(void) {
|
||||
int res = mBytesRead;
|
||||
mBytesRead = -1;
|
||||
return res;
|
||||
};
|
||||
|
||||
#define PTT clock_t
|
||||
#define NOW() (clock() / (CLOCKS_PER_SEC / 1000))
|
||||
|
||||
int GzippedFileReader::ReadSync(void* pBuffer, uint sector, uint count) {
|
||||
PX_off_t offset = (s64)sector * m_blocksize + m_dataoffset;
|
||||
int bytesToRead = count * m_blocksize;
|
||||
int res = _ReadSync(pBuffer, offset, bytesToRead);
|
||||
if (res < 0)
|
||||
Console.Error(L"Error: iso-gzip read unsuccessful.");
|
||||
return res;
|
||||
}
|
||||
|
||||
// If we have a valid and adequate zstate for this span, use it, else, use the index
|
||||
PX_off_t GzippedFileReader::GetOptimalExtractionStart(PX_off_t offset) {
|
||||
int span = m_pIndex->span;
|
||||
Czstate& cstate = m_zstates[offset / span];
|
||||
PX_off_t stateOffset = cstate.state.isValid ? cstate.state.out_offset : 0;
|
||||
if (stateOffset && stateOffset <= offset)
|
||||
return stateOffset; // state is faster than indexed
|
||||
|
||||
// If span is not exact multiples of READ_CHUNK_SIZE (because it was configured badly),
|
||||
// we fallback to always READ_CHUNK_SIZE boundaries
|
||||
if (span % READ_CHUNK_SIZE)
|
||||
return offset / READ_CHUNK_SIZE * READ_CHUNK_SIZE;
|
||||
|
||||
return span * (offset / span); // index direct access boundaries
|
||||
}
|
||||
|
||||
int GzippedFileReader::_ReadSync(void* pBuffer, PX_off_t offset, uint bytesToRead) {
|
||||
if (!OkIndex())
|
||||
return -1;
|
||||
|
||||
// Without all the caching, chunking and states, this would be enough:
|
||||
// return extract(m_src, m_pIndex, offset, (unsigned char*)pBuffer, bytesToRead);
|
||||
|
||||
// Split request to READ_CHUNK_SIZE chunks at READ_CHUNK_SIZE boundaries
|
||||
uint maxInChunk = READ_CHUNK_SIZE - offset % READ_CHUNK_SIZE;
|
||||
if (bytesToRead > maxInChunk) {
|
||||
int first = _ReadSync(pBuffer, offset, maxInChunk);
|
||||
if (first != maxInChunk)
|
||||
return first; // EOF or failure
|
||||
|
||||
int rest = _ReadSync((char*)pBuffer + maxInChunk, offset + maxInChunk, bytesToRead - maxInChunk);
|
||||
if (rest < 0)
|
||||
return rest;
|
||||
|
||||
return first + rest;
|
||||
}
|
||||
|
||||
// From here onwards it's guarenteed that the request is inside a single READ_CHUNK_SIZE boundaries
|
||||
|
||||
int res = m_cache.Read(pBuffer, offset, bytesToRead);
|
||||
if (res >= 0)
|
||||
return res;
|
||||
|
||||
// Not available from cache. Decompress from optimal starting
|
||||
// point in READ_CHUNK_SIZE chunks and cache each chunk.
|
||||
PTT s = NOW();
|
||||
PX_off_t extractOffset = GetOptimalExtractionStart(offset); // guaranteed in READ_CHUNK_SIZE boundaries
|
||||
int size = offset + maxInChunk - extractOffset;
|
||||
unsigned char* extracted = (unsigned char*)malloc(size);
|
||||
|
||||
int span = m_pIndex->span;
|
||||
int spanix = extractOffset / span;
|
||||
AsyncPrefetchCancel();
|
||||
res = extract(m_src, m_pIndex, extractOffset, extracted, size, &(m_zstates[spanix].state));
|
||||
if (res < 0) {
|
||||
free(extracted);
|
||||
return res;
|
||||
}
|
||||
AsyncPrefetchChunk(getInOffset(&(m_zstates[spanix].state)));
|
||||
|
||||
int copied = ChunksCache::CopyAvailable(extracted, extractOffset, res, pBuffer, offset, bytesToRead);
|
||||
|
||||
if (m_zstates[spanix].state.isValid && (extractOffset + res) / span != offset / span) {
|
||||
// The state no longer matches this span.
|
||||
// move the state to the appropriate span because it will be faster than using the index
|
||||
int targetix = (extractOffset + res) / span;
|
||||
m_zstates[targetix].Kill();
|
||||
m_zstates[targetix] = m_zstates[spanix]; // We have elements for the entire file, and another one.
|
||||
m_zstates[spanix].state.isValid = 0; // Not killing because we need the state.
|
||||
}
|
||||
|
||||
if (size <= READ_CHUNK_SIZE)
|
||||
m_cache.Take(extracted, extractOffset, res, size);
|
||||
else { // split into cacheable chunks
|
||||
for (int i = 0; i < size; i += READ_CHUNK_SIZE) {
|
||||
int available = CLAMP(res - i, 0, READ_CHUNK_SIZE);
|
||||
void* chunk = available ? malloc(available) : 0;
|
||||
if (available)
|
||||
memcpy(chunk, extracted + i, available);
|
||||
m_cache.Take(chunk, extractOffset + i, available, std::min(size - i, READ_CHUNK_SIZE));
|
||||
}
|
||||
free(extracted);
|
||||
}
|
||||
|
||||
int duration = NOW() - s;
|
||||
if (duration > 10)
|
||||
Console.WriteLn(Color_Gray, L"gunzip: chunk #%5d-%2d : %1.2f MB - %d ms",
|
||||
(int)(offset / 4 / 1024 / 1024),
|
||||
(int)(offset % (4 * 1024 * 1024) / READ_CHUNK_SIZE),
|
||||
(float)size / 1024 / 1024,
|
||||
duration);
|
||||
|
||||
return copied;
|
||||
}
|
||||
|
||||
void GzippedFileReader::Close() {
|
||||
m_filename.Empty();
|
||||
if (m_pIndex) {
|
||||
free_index((Access*)m_pIndex);
|
||||
m_pIndex = 0;
|
||||
}
|
||||
|
||||
InitZstates(); // results in delete because no index
|
||||
m_cache.Clear();
|
||||
|
||||
if (m_src) {
|
||||
fclose(m_src);
|
||||
m_src = 0;
|
||||
}
|
||||
|
||||
AsyncPrefetchClose();
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
/* PCSX2 - PS2 Emulator for PCs
|
||||
* Copyright (C) 2002-2014 PCSX2 Dev Team
|
||||
*
|
||||
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
||||
* of the GNU Lesser General Public License as published by the Free Software Found-
|
||||
* ation, either version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
||||
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
* PURPOSE. See the GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with PCSX2.
|
||||
* If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
typedef struct zstate Zstate;
|
||||
|
||||
#include "AsyncFileReader.h"
|
||||
#include "ChunksCache.h"
|
||||
#include "zlib_indexed.h"
|
||||
|
||||
#define SPAN_DEFAULT (1048576L * 4) /* distance between direct access points when creating a new index */
|
||||
#define READ_CHUNK_SIZE (256 * 1024) /* zlib extraction chunks size (at 0-based boundaries) */
|
||||
#define CACHE_SIZE_MB 200 /* cache size for extracted data. must be at least READ_CHUNK_SIZE (in MB)*/
|
||||
|
||||
class GzippedFileReader : public AsyncFileReader
|
||||
{
|
||||
DeclareNoncopyableObject(GzippedFileReader);
|
||||
public:
|
||||
GzippedFileReader(void);
|
||||
|
||||
virtual ~GzippedFileReader(void) { Close(); };
|
||||
|
||||
static bool CanHandle(const wxString& fileName);
|
||||
virtual bool Open(const wxString& fileName);
|
||||
|
||||
virtual int ReadSync(void* pBuffer, uint sector, uint count);
|
||||
|
||||
virtual void BeginRead(void* pBuffer, uint sector, uint count);
|
||||
virtual int FinishRead(void);
|
||||
virtual void CancelRead(void) {};
|
||||
|
||||
virtual void Close(void);
|
||||
|
||||
virtual uint GetBlockCount(void) const {
|
||||
// type and formula copied from FlatFileReader
|
||||
// FIXME? : Shouldn't it be uint and (size - m_dataoffset) / m_blocksize ?
|
||||
return (int)((m_pIndex ? m_pIndex->uncompressed_size : 0) / m_blocksize);
|
||||
};
|
||||
|
||||
virtual void SetBlockSize(uint bytes) { m_blocksize = bytes; }
|
||||
virtual void SetDataOffset(int bytes) { m_dataoffset = bytes; }
|
||||
private:
|
||||
class Czstate {
|
||||
public:
|
||||
Czstate() { state.isValid = 0; };
|
||||
~Czstate() { Kill(); };
|
||||
void Kill() {
|
||||
if (state.isValid)
|
||||
inflateEnd(&state.strm);
|
||||
state.isValid = 0;
|
||||
}
|
||||
Zstate state;
|
||||
};
|
||||
|
||||
bool OkIndex(); // Verifies that we have an index, or try to create one
|
||||
PX_off_t GetOptimalExtractionStart(PX_off_t offset);
|
||||
int _ReadSync(void* pBuffer, PX_off_t offset, uint bytesToRead);
|
||||
void InitZstates();
|
||||
|
||||
int mBytesRead; // Temp sync read result when simulating async read
|
||||
Access* m_pIndex; // Quick access index
|
||||
Czstate* m_zstates;
|
||||
FILE* m_src;
|
||||
|
||||
ChunksCache m_cache;
|
||||
|
||||
#ifdef WIN32
|
||||
// Used by async prefetch
|
||||
HANDLE hOverlappedFile;
|
||||
OVERLAPPED asyncOperationContext;
|
||||
bool asyncInProgress;
|
||||
byte mDummyAsyncPrefetchTarget[READ_CHUNK_SIZE];
|
||||
#endif
|
||||
|
||||
void AsyncPrefetchReset();
|
||||
void AsyncPrefetchOpen();
|
||||
void AsyncPrefetchClose();
|
||||
void AsyncPrefetchChunk(PX_off_t dummy);
|
||||
void AsyncPrefetchCancel();
|
||||
};
|
||||
|
|
@ -18,6 +18,7 @@
|
|||
#include "CDVD.h"
|
||||
#include "wx/wfstream.h"
|
||||
#include "AsyncFileReader.h"
|
||||
#include "CompressedFileReader.h"
|
||||
|
||||
enum isoType
|
||||
{
|
||||
|
|
|
|||
|
|
@ -336,7 +336,7 @@ typedef struct zstate {
|
|||
int isValid;
|
||||
} Zstate;
|
||||
|
||||
PX_off_t getInOffset(zstate *state) {
|
||||
static inline PX_off_t getInOffset(zstate *state) {
|
||||
return state->in_offset;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -236,7 +236,10 @@ set(pcsx2CDVDSources
|
|||
CDVD/CDVDisoReader.cpp
|
||||
CDVD/InputIsoFile.cpp
|
||||
CDVD/OutputIsoFile.cpp
|
||||
CDVD/ChunksCache.cpp
|
||||
CDVD/CompressedFileReader.cpp
|
||||
CDVD/CsoFileReader.cpp
|
||||
CDVD/GzippedFileReader.cpp
|
||||
CDVD/IsoFS/IsoFile.cpp
|
||||
CDVD/IsoFS/IsoFSCDVD.cpp
|
||||
CDVD/IsoFS/IsoFS.cpp
|
||||
|
|
|
|||
|
|
@ -423,6 +423,9 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\CDVD\BlockdumpFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\ChunksCache.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\CsoFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\GzippedFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\OutputIsoFile.cpp" />
|
||||
<ClCompile Include="..\..\DebugTools\Breakpoints.cpp" />
|
||||
<ClCompile Include="..\..\DebugTools\DebugInterface.cpp" />
|
||||
|
|
@ -710,6 +713,11 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\AsyncFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\ChunksCache.h" />
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReaderUtils.h" />
|
||||
<ClInclude Include="..\..\CDVD\CsoFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\GzippedFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\zlib_indexed.h" />
|
||||
<ClInclude Include="..\..\DebugTools\Breakpoints.h" />
|
||||
<ClInclude Include="..\..\DebugTools\DebugInterface.h" />
|
||||
|
|
|
|||
|
|
@ -859,6 +859,15 @@
|
|||
<ClCompile Include="..\..\DebugTools\MipsStackWalk.cpp">
|
||||
<Filter>System\Ps2\Debug</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\CsoFileReader.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\GzippedFileReader.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\ChunksCache.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\Patch.h">
|
||||
|
|
@ -1275,6 +1284,21 @@
|
|||
<ClInclude Include="..\..\DebugTools\MipsStackWalk.h">
|
||||
<Filter>System\Ps2\Debug</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CsoFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\GzippedFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\ChunksCache.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReaderUtils.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ResourceCompile Include="..\..\..\3rdparty\wxWidgets\include\wx\msw\wx.rc">
|
||||
|
|
|
|||
|
|
@ -407,6 +407,9 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\CDVD\BlockdumpFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\ChunksCache.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\CsoFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\GzippedFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\OutputIsoFile.cpp" />
|
||||
<ClCompile Include="..\..\DebugTools\Breakpoints.cpp" />
|
||||
<ClCompile Include="..\..\DebugTools\DebugInterface.cpp" />
|
||||
|
|
@ -696,6 +699,11 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\AsyncFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\ChunksCache.h" />
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReaderUtils.h" />
|
||||
<ClInclude Include="..\..\CDVD\CsoFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\GzippedFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\zlib_indexed.h" />
|
||||
<ClInclude Include="..\..\DebugTools\Breakpoints.h" />
|
||||
<ClInclude Include="..\..\DebugTools\DebugInterface.h" />
|
||||
|
|
|
|||
|
|
@ -856,6 +856,15 @@
|
|||
<ClCompile Include="..\..\DebugTools\MipsStackWalk.cpp">
|
||||
<Filter>System\Ps2\Debug</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\CsoFileReader.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\GzippedFileReader.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\ChunksCache.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\Patch.h">
|
||||
|
|
@ -1275,6 +1284,21 @@
|
|||
<ClInclude Include="..\..\DebugTools\MipsStackWalk.h">
|
||||
<Filter>System\Ps2\Debug</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CsoFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\GzippedFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\ChunksCache.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReaderUtils.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ResourceCompile Include="..\..\..\3rdparty\wxWidgets\include\wx\msw\wx.rc">
|
||||
|
|
|
|||
|
|
@ -406,7 +406,10 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\CDVD\BlockdumpFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\ChunksCache.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\CompressedFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\CsoFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\GzippedFileReader.cpp" />
|
||||
<ClCompile Include="..\..\CDVD\OutputIsoFile.cpp" />
|
||||
<ClCompile Include="..\..\DebugTools\Breakpoints.cpp" />
|
||||
<ClCompile Include="..\..\DebugTools\DebugInterface.cpp" />
|
||||
|
|
@ -696,6 +699,11 @@
|
|||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\AsyncFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\ChunksCache.h" />
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReaderUtils.h" />
|
||||
<ClInclude Include="..\..\CDVD\CsoFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\GzippedFileReader.h" />
|
||||
<ClInclude Include="..\..\CDVD\zlib_indexed.h" />
|
||||
<ClInclude Include="..\..\DebugTools\Breakpoints.h" />
|
||||
<ClInclude Include="..\..\DebugTools\DebugInterface.h" />
|
||||
|
|
|
|||
|
|
@ -856,6 +856,15 @@
|
|||
<ClCompile Include="..\..\DebugTools\MipsStackWalk.cpp">
|
||||
<Filter>System\Ps2\Debug</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\CsoFileReader.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\GzippedFileReader.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\..\CDVD\ChunksCache.cpp">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\Patch.h">
|
||||
|
|
@ -1275,6 +1284,21 @@
|
|||
<ClInclude Include="..\..\DebugTools\MipsStackWalk.h">
|
||||
<Filter>System\Ps2\Debug</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CsoFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\GzippedFileReader.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\ChunksCache.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="..\..\CDVD\CompressedFileReaderUtils.h">
|
||||
<Filter>System\ISO</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ResourceCompile Include="..\..\..\3rdparty\wxWidgets\include\wx\msw\wx.rc">
|
||||
|
|
|
|||
Loading…
Reference in New Issue