1479 lines
46 KiB
C++
1479 lines
46 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Filesystem abstraction for CSaveRestore - allows for storing temp save files
|
|
// either in memory or on disk.
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifdef _WIN32
|
|
#include "winerror.h"
|
|
#endif
|
|
#include "filesystem_engine.h"
|
|
#include "saverestore_filesystem.h"
|
|
#include "host_saverestore.h"
|
|
#include "host.h"
|
|
#include "sys.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#include "tier1/lzss.h"
|
|
#include "tier1/convar.h"
|
|
#include "ixboxsystem.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
extern ConVar save_spew;
|
|
extern IXboxSystem *g_pXboxSystem;
|
|
|
|
#define SaveMsg if ( !save_spew.GetBool() ) ; else Msg
|
|
|
|
void SaveInMemoryCallback( IConVar *var, const char *pOldString, float flOldValue );
|
|
|
|
#ifdef _X360
|
|
ConVar save_in_memory( "save_in_memory", "1", 1, "Set to 1 to save to memory instead of disk (Xbox 360)", SaveInMemoryCallback );
|
|
#else
|
|
ConVar save_in_memory( "save_in_memory", "0", 0, "Set to 1 to save to memory instead of disk (Xbox 360)", SaveInMemoryCallback );
|
|
#endif // _X360
|
|
|
|
#define INVALID_INDEX (GetDirectory().InvalidIndex())
|
|
enum { READ_ONLY, WRITE_ONLY };
|
|
|
|
static float g_fPrevSaveInMemoryValue;
|
|
|
|
static bool SaveFileLessFunc( const CUtlSymbol &lhs, const CUtlSymbol &rhs )
|
|
{
|
|
return lhs < rhs;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Simulates the save directory in RAM.
|
|
//----------------------------------------------------------------------------
|
|
class CSaveDirectory
|
|
{
|
|
public:
|
|
CSaveDirectory()
|
|
{
|
|
m_Files.SetLessFunc( SaveFileLessFunc );
|
|
file_t dummy;
|
|
dummy.name = m_SymbolTable.AddString( "dummy" );
|
|
m_Files.Insert( dummy.name, dummy );
|
|
}
|
|
|
|
~CSaveDirectory()
|
|
{
|
|
int i = m_Files.FirstInorder();
|
|
while ( m_Files.IsValidIndex( i ) )
|
|
{
|
|
int idx = i;
|
|
i = m_Files.NextInorder( i );
|
|
|
|
delete m_Files[idx].pBuffer;
|
|
delete m_Files[idx].pCompressedBuffer;
|
|
m_Files.RemoveAt( idx );
|
|
}
|
|
}
|
|
|
|
struct file_t
|
|
{
|
|
file_t()
|
|
{
|
|
pBuffer = NULL;
|
|
pCompressedBuffer = NULL;
|
|
nSize = 0;
|
|
nCompressedSize = NULL;
|
|
}
|
|
|
|
|
|
int eType;
|
|
CUtlSymbol name;
|
|
unsigned int nSize;
|
|
unsigned int nCompressedSize;
|
|
CUtlBuffer *pBuffer;
|
|
CUtlBuffer *pCompressedBuffer;
|
|
};
|
|
|
|
CUtlSymbolTable m_SymbolTable;
|
|
CUtlMap<CUtlSymbol, file_t> m_Files;
|
|
};
|
|
|
|
typedef CSaveDirectory::file_t SaveFile_t;
|
|
|
|
//----------------------------------------------------------------------------
|
|
// CSaveRestoreFileSystem: Manipulates files in the CSaveDirectory
|
|
//----------------------------------------------------------------------------
|
|
class CSaveRestoreFileSystem : public ISaveRestoreFileSystem
|
|
{
|
|
public:
|
|
CSaveRestoreFileSystem()
|
|
{
|
|
m_pSaveDirectory = new CSaveDirectory();
|
|
m_iContainerOpens = 0;
|
|
}
|
|
|
|
~CSaveRestoreFileSystem()
|
|
{
|
|
delete m_pSaveDirectory;
|
|
}
|
|
|
|
bool FileExists( const char *pFileName, const char *pPathID = NULL );
|
|
void RenameFile( char const *pOldPath, char const *pNewPath, const char *pathID = NULL );
|
|
void RemoveFile( char const* pRelativePath, const char *pathID = NULL );
|
|
|
|
FileHandle_t Open( const char *pFileName, const char *pOptions, const char *pathID = NULL );
|
|
void Close( FileHandle_t );
|
|
int Read( void *pOutput, int size, FileHandle_t file );
|
|
int Write( void const* pInput, int size, FileHandle_t file );
|
|
void Seek( FileHandle_t file, int pos, FileSystemSeek_t method );
|
|
unsigned int Tell( FileHandle_t file );
|
|
unsigned int Size( FileHandle_t file );
|
|
unsigned int Size( const char *pFileName, const char *pPathID = NULL );
|
|
|
|
void AsyncFinishAllWrites( void );
|
|
void AsyncRelease( FSAsyncControl_t hControl );
|
|
FSAsyncStatus_t AsyncWrite( const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t *pControl = NULL );
|
|
FSAsyncStatus_t AsyncFinish( FSAsyncControl_t hControl, bool wait = false );
|
|
FSAsyncStatus_t AsyncAppend( const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, FSAsyncControl_t *pControl = NULL );
|
|
FSAsyncStatus_t AsyncAppendFile( const char *pDestFileName, const char *pSrcFileName, FSAsyncControl_t *pControl = NULL );
|
|
|
|
void DirectoryCopy( const char *pPath, const char *pDestFileName, bool bIsXSave );
|
|
void DirectorCopyToMemory( const char *pPath, const char *pDestFileName );
|
|
bool DirectoryExtract( FileHandle_t pFile, int fileCount, bool bIsXSave );
|
|
int DirectoryCount( const char *pPath );
|
|
void DirectoryClear( const char *pPath, bool bIsXSave );
|
|
|
|
void WriteSaveDirectoryToDisk( void );
|
|
void LoadSaveDirectoryFromDisk( const char *pPath );
|
|
void DumpSaveDirectory( void );
|
|
|
|
void Compress( SaveFile_t *pFile );
|
|
void Uncompress( SaveFile_t *pFile );
|
|
|
|
void AuditFiles( void );
|
|
bool LoadFileFromDisk( const char *pFilename );
|
|
|
|
private:
|
|
CSaveDirectory *m_pSaveDirectory;
|
|
CUtlMap<CUtlSymbol, SaveFile_t> &GetDirectory( void ) { return m_pSaveDirectory->m_Files; }
|
|
SaveFile_t &GetFile( const int idx ) { return m_pSaveDirectory->m_Files[idx]; }
|
|
SaveFile_t &GetFile( const FileHandle_t hFile ) { return GetFile( (unsigned int)hFile ); }
|
|
|
|
FileHandle_t GetFileHandle( const char *pFileName );
|
|
int GetFileIndex( const char *pFileName );
|
|
|
|
bool HandleIsValid( FileHandle_t hFile );
|
|
|
|
unsigned int CompressedSize( const char *pFileName );
|
|
|
|
CUtlSymbol AddString( const char *str )
|
|
{
|
|
char szString[ MAX_PATH ];
|
|
Q_strncpy( szString, str, sizeof( szString ) );
|
|
return m_pSaveDirectory->m_SymbolTable.AddString( Q_strlower( szString ) );
|
|
}
|
|
const char *GetString( CUtlSymbol &id ) { return m_pSaveDirectory->m_SymbolTable.String( id ); }
|
|
|
|
|
|
int m_iContainerOpens;
|
|
};
|
|
|
|
//#define TEST_LZSS_WINDOW_SIZES
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Compress the file data
|
|
//----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::Compress( SaveFile_t *pFile )
|
|
{
|
|
pFile->pCompressedBuffer->Purge();
|
|
|
|
#ifdef TEST_LZSS_WINDOW_SIZES
|
|
// Compress the data here
|
|
CLZSS compressor_test;
|
|
CLZSS newcompressor_test( 2048 );
|
|
pFile->nCompressedSize = 0;
|
|
float start = Plat_FloatTime();
|
|
for(int i=0;i<10;i++)
|
|
{
|
|
uint32 sz;
|
|
unsigned char *pCompressedBuffer = compressor_test.Compress(
|
|
(unsigned char *) pFile->pBuffer->Base(), pFile->nSize, &sz );
|
|
delete[] pCompressedBuffer;
|
|
}
|
|
Warning(" old compressor_test %f", Plat_FloatTime() - start );
|
|
start = Plat_FloatTime();
|
|
for(int i=0;i<10;i++)
|
|
{
|
|
uint32 sz;
|
|
unsigned char *pCompressedBuffer = newcompressor_test.Compress(
|
|
(unsigned char *) pFile->pBuffer->Base(), pFile->nSize, &sz );
|
|
delete[] pCompressedBuffer;
|
|
}
|
|
Warning(" new compressor_test %f", Plat_FloatTime() - start );
|
|
if ( 1)
|
|
{
|
|
uint32 sz;
|
|
uint32 sz1;
|
|
unsigned char *pNewCompressedBuffer = newcompressor_test.Compress(
|
|
(unsigned char *) pFile->pBuffer->Base(), pFile->nSize, &sz );
|
|
unsigned char *pOldCompressedBuffer = compressor_test.Compress(
|
|
(unsigned char *) pFile->pBuffer->Base(), pFile->nSize, &sz1 );
|
|
if ( ! pNewCompressedBuffer )
|
|
Warning("new no comp");
|
|
if ( ! pOldCompressedBuffer )
|
|
Warning("old no comp");
|
|
if ( pNewCompressedBuffer && pOldCompressedBuffer )
|
|
{
|
|
if ( sz != sz1 )
|
|
Warning(" new size = %d old = %d", sz, sz1 );
|
|
if ( memcmp( pNewCompressedBuffer, pOldCompressedBuffer, sz ) )
|
|
Warning("data mismatch");
|
|
}
|
|
delete[] pOldCompressedBuffer;
|
|
delete[] pNewCompressedBuffer;
|
|
}
|
|
#endif
|
|
|
|
CLZSS compressor( 2048 );
|
|
|
|
unsigned char *pCompressedBuffer = compressor.Compress( (unsigned char *) pFile->pBuffer->Base(), pFile->nSize, &pFile->nCompressedSize );
|
|
if ( pCompressedBuffer == NULL )
|
|
{
|
|
// Just copy the buffer uncompressed
|
|
pFile->pCompressedBuffer->Put( pFile->pBuffer->Base(), pFile->nSize );
|
|
pFile->nCompressedSize = pFile->nSize;
|
|
}
|
|
else
|
|
{
|
|
// Take the compressed buffer as our own
|
|
pFile->pCompressedBuffer->AssumeMemory( pCompressedBuffer, pFile->nCompressedSize, pFile->nCompressedSize ); // ?
|
|
}
|
|
// end compression
|
|
|
|
pFile->pCompressedBuffer->SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
|
|
pFile->pCompressedBuffer->SeekPut( CUtlBuffer::SEEK_HEAD, pFile->nCompressedSize );
|
|
|
|
// Don't want the uncompressed memory hanging around
|
|
pFile->pBuffer->Purge();
|
|
|
|
unsigned int srcBytes = pFile->nSize;
|
|
|
|
pFile->nSize = 0;
|
|
|
|
unsigned int destBytes = pFile->nCompressedSize;
|
|
|
|
float percent = 0.f;
|
|
if ( srcBytes )
|
|
percent = 100.0f * (1.0f - (float)destBytes/(float)srcBytes);
|
|
|
|
SaveMsg( "SIM: SaveDir: (%s) Compressed %d bytes to %d bytes. (%.0f%%)\n", GetString( pFile->name ), srcBytes, destBytes, percent );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Uncompress the file data
|
|
//----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::Uncompress( SaveFile_t *pFile )
|
|
{
|
|
pFile->pBuffer->Purge();
|
|
|
|
// Uncompress the data here
|
|
CLZSS compressor;
|
|
unsigned int nUncompressedSize = compressor.GetActualSize( (unsigned char *) pFile->pCompressedBuffer->Base() );
|
|
if ( nUncompressedSize != 0 )
|
|
{
|
|
unsigned char *pUncompressBuffer = (unsigned char *) malloc( nUncompressedSize );
|
|
nUncompressedSize = compressor.Uncompress( (unsigned char *) pFile->pCompressedBuffer->Base(), pUncompressBuffer );
|
|
pFile->pBuffer->AssumeMemory( pUncompressBuffer, nUncompressedSize, nUncompressedSize ); // ?
|
|
}
|
|
else
|
|
{
|
|
// Put it directly into our target
|
|
pFile->pBuffer->Put( (unsigned char *) pFile->pCompressedBuffer->Base(), pFile->nCompressedSize );
|
|
}
|
|
// end decompression
|
|
|
|
pFile->nSize = pFile->pBuffer->TellMaxPut();
|
|
pFile->pBuffer->SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
|
|
pFile->pBuffer->SeekPut( CUtlBuffer::SEEK_HEAD, pFile->nSize );
|
|
|
|
unsigned int srcBytes = pFile->nCompressedSize;
|
|
unsigned int destBytes = pFile->nSize;
|
|
|
|
SaveMsg( "SIM: SaveDir: (%s) Uncompressed %d bytes to %d bytes.\n", GetString( pFile->name ), srcBytes, destBytes );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Access the save files
|
|
//----------------------------------------------------------------------------
|
|
int CSaveRestoreFileSystem::GetFileIndex( const char *filename )
|
|
{
|
|
CUtlSymbol id = AddString( Q_UnqualifiedFileName( filename ) );
|
|
return GetDirectory().Find( id );
|
|
}
|
|
|
|
FileHandle_t CSaveRestoreFileSystem::GetFileHandle( const char *filename )
|
|
{
|
|
int idx = GetFileIndex( filename );
|
|
if ( idx == INVALID_INDEX )
|
|
{
|
|
idx = 0;
|
|
}
|
|
return (void*)idx;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns whether the named memory block exists
|
|
//-----------------------------------------------------------------------------
|
|
bool CSaveRestoreFileSystem::FileExists( const char *pFileName, const char *pPathID )
|
|
{
|
|
return ( GetFileHandle( pFileName ) != NULL );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Validates a file handle
|
|
//-----------------------------------------------------------------------------
|
|
bool CSaveRestoreFileSystem::HandleIsValid( FileHandle_t hFile )
|
|
{
|
|
return hFile && GetDirectory().IsValidIndex( (unsigned int)hFile );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renames a block of memory
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::RenameFile( char const *pOldPath, char const *pNewPath, const char *pathID )
|
|
{
|
|
int idx = GetFileIndex( pOldPath );
|
|
if ( idx != INVALID_INDEX )
|
|
{
|
|
CUtlSymbol newID = AddString( Q_UnqualifiedFileName( pNewPath ) );
|
|
GetFile( idx ).name = newID;
|
|
GetDirectory().Reinsert( newID, idx );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Removes a memory block from CSaveDirectory and frees it.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::RemoveFile( char const* pRelativePath, const char *pathID )
|
|
{
|
|
int idx = GetFileIndex( pRelativePath );
|
|
if ( idx != INVALID_INDEX )
|
|
{
|
|
delete GetFile( idx ).pBuffer;
|
|
delete GetFile( idx ).pCompressedBuffer;
|
|
GetDirectory().RemoveAt( idx );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Access an existing memory block if it exists, else allocate one.
|
|
//-----------------------------------------------------------------------------
|
|
FileHandle_t CSaveRestoreFileSystem::Open( const char *pFullName, const char *pOptions, const char *pathID )
|
|
{
|
|
SaveFile_t *pFile = NULL;
|
|
CUtlSymbol id = AddString( Q_UnqualifiedFileName( pFullName ) );
|
|
int idx = GetDirectory().Find( id );
|
|
if ( idx == INVALID_INDEX )
|
|
{
|
|
// Don't create a read-only file
|
|
if ( Q_stricmp( pOptions, "rb" ) )
|
|
{
|
|
// Create new file
|
|
SaveFile_t newFile;
|
|
newFile.name = id;
|
|
newFile.pBuffer = new CUtlBuffer();
|
|
newFile.pCompressedBuffer = new CUtlBuffer();
|
|
idx = GetDirectory().Insert( id, newFile );
|
|
}
|
|
else
|
|
{
|
|
return (void*)0;
|
|
}
|
|
}
|
|
|
|
pFile = &GetFile( idx );
|
|
|
|
if ( !Q_stricmp( pOptions, "rb" ) )
|
|
{
|
|
Uncompress( pFile );
|
|
pFile->eType = READ_ONLY;
|
|
}
|
|
else if ( !Q_stricmp( pOptions, "wb" ) )
|
|
{
|
|
pFile->pBuffer->Clear();
|
|
pFile->eType = WRITE_ONLY;
|
|
}
|
|
else if ( !Q_stricmp( pOptions, "a" ) )
|
|
{
|
|
Uncompress( pFile );
|
|
pFile->eType = WRITE_ONLY;
|
|
}
|
|
else if ( !Q_stricmp( pOptions, "ab+" ) )
|
|
{
|
|
Uncompress( pFile );
|
|
pFile->eType = WRITE_ONLY;
|
|
pFile->pBuffer->SeekPut( CUtlBuffer::SEEK_TAIL, 0 );
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
Warning( "CSaveRestoreFileSystem: Attempted to open %s with unsupported option %s\n", pFullName, pOptions );
|
|
return (void*)0;
|
|
}
|
|
|
|
return (void*)idx;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: No need to close files in memory. Could perform post processing here.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::Close( FileHandle_t hFile )
|
|
{
|
|
// Compress the file
|
|
if ( HandleIsValid( hFile ) )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
|
|
// Files opened for read don't need to be recompressed
|
|
if ( file.eType == READ_ONLY )
|
|
{
|
|
SaveMsg("SIM: Closed file: %s\n", GetString( file.name ) );
|
|
file.pBuffer->Purge();
|
|
file.nSize = 0;
|
|
}
|
|
else
|
|
{
|
|
Compress( &file );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reads data from memory.
|
|
//-----------------------------------------------------------------------------
|
|
int CSaveRestoreFileSystem::Read( void *pOutput, int size, FileHandle_t hFile )
|
|
{
|
|
int readSize = 0;
|
|
if ( HandleIsValid( hFile ) )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
|
|
if( file.eType == READ_ONLY )
|
|
{
|
|
readSize = file.pBuffer->GetUpTo( pOutput, size );
|
|
}
|
|
else
|
|
{
|
|
Warning( "Read: Attempted to read from a write-only file" );
|
|
readSize = 0;
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
return readSize;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Writes data to memory.
|
|
//-----------------------------------------------------------------------------
|
|
int CSaveRestoreFileSystem::Write( void const* pInput, int size, FileHandle_t hFile )
|
|
{
|
|
int writeSize = 0;
|
|
if ( HandleIsValid( hFile ) )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
|
|
if( file.eType == WRITE_ONLY )
|
|
{
|
|
file.pBuffer->Put( pInput, size );
|
|
file.nSize = file.pBuffer->TellMaxPut();
|
|
writeSize = size;
|
|
}
|
|
else
|
|
{
|
|
Warning( "Write: Attempted to write to a read-only file" );
|
|
writeSize = 0;
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
return writeSize;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Seek in memory. Seeks the UtlBuffer put or get pos depending
|
|
// on whether the file was opened for read or write.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::Seek( FileHandle_t hFile, int pos, FileSystemSeek_t method )
|
|
{
|
|
if ( HandleIsValid( hFile ) )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
if ( file.eType == READ_ONLY )
|
|
{
|
|
file.pBuffer->SeekGet( (CUtlBuffer::SeekType_t)method, pos );
|
|
}
|
|
else if ( file.eType == WRITE_ONLY )
|
|
{
|
|
file.pBuffer->SeekPut( (CUtlBuffer::SeekType_t)method, pos );
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return position in memory. Returns UtlBuffer put or get pos depending
|
|
// on whether the file was opened for read or write.
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CSaveRestoreFileSystem::Tell( FileHandle_t hFile )
|
|
{
|
|
unsigned int pos = 0;
|
|
if ( HandleIsValid( hFile ) )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
if ( file.eType == READ_ONLY )
|
|
{
|
|
pos = file.pBuffer->TellGet();
|
|
}
|
|
else if ( file.eType == WRITE_ONLY )
|
|
{
|
|
pos = file.pBuffer->TellPut();
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return uncompressed memory size
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CSaveRestoreFileSystem::Size( FileHandle_t hFile )
|
|
{
|
|
if ( HandleIsValid( hFile ) )
|
|
{
|
|
return GetFile( hFile ).nSize;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return uncompressed size of data in memory
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CSaveRestoreFileSystem::Size( const char *pFileName, const char *pPathID )
|
|
{
|
|
return Size( GetFileHandle( pFileName ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return compressed size of data in memory
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CSaveRestoreFileSystem::CompressedSize( const char *pFileName )
|
|
{
|
|
FileHandle_t hFile = GetFileHandle( pFileName );
|
|
if ( hFile )
|
|
{
|
|
return GetFile( hFile ).nCompressedSize;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Writes data to memory. Function is NOT async.
|
|
//-----------------------------------------------------------------------------
|
|
FSAsyncStatus_t CSaveRestoreFileSystem::AsyncWrite( const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t *pControl )
|
|
{
|
|
FSAsyncStatus_t retval = FSASYNC_ERR_FAILURE;
|
|
|
|
FileHandle_t hFile = Open( pFileName, "wb" );
|
|
if ( hFile )
|
|
{
|
|
SaveFile_t &file = GetFile( (unsigned int)hFile );
|
|
|
|
if( file.eType == WRITE_ONLY )
|
|
{
|
|
file.pBuffer->Put( pSrc, nSrcBytes );
|
|
file.nSize = file.pBuffer->TellMaxPut();
|
|
Compress( &file );
|
|
retval = FSASYNC_OK;
|
|
}
|
|
else
|
|
{
|
|
Warning( "AsyncWrite: Attempted to write to a read-only file" );
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
|
|
if ( bFreeMemory )
|
|
free( const_cast< void * >( pSrc ) );
|
|
|
|
return retval;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Appends data to a memory block. Function is NOT async.
|
|
//-----------------------------------------------------------------------------
|
|
FSAsyncStatus_t CSaveRestoreFileSystem::AsyncAppend(const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, FSAsyncControl_t *pControl )
|
|
{
|
|
FSAsyncStatus_t retval = FSASYNC_ERR_FAILURE;
|
|
|
|
FileHandle_t hFile = Open( pFileName, "a" );
|
|
if ( hFile )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
if( file.eType == WRITE_ONLY )
|
|
{
|
|
file.pBuffer->Put( pSrc, nSrcBytes );
|
|
file.nSize = file.pBuffer->TellMaxPut();
|
|
Compress( &file );
|
|
retval = FSASYNC_OK;
|
|
}
|
|
else
|
|
{
|
|
Warning( "AsyncAppend: Attempted to write to a read-only file" );
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
|
|
if ( bFreeMemory )
|
|
free( const_cast< void * >( pSrc ) );
|
|
|
|
return retval;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Appends a memory block to another memory block. Function is NOT async.
|
|
//-----------------------------------------------------------------------------
|
|
FSAsyncStatus_t CSaveRestoreFileSystem::AsyncAppendFile(const char *pDestFileName, const char *pSrcFileName, FSAsyncControl_t *pControl )
|
|
{
|
|
FileHandle_t hFile = Open( pSrcFileName, "rb" );
|
|
if ( hFile )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
return AsyncAppend( pDestFileName, file.pBuffer->Base(), file.nSize, false );
|
|
}
|
|
return FSASYNC_ERR_FILEOPEN;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: All operations in memory are synchronous
|
|
//-----------------------------------------------------------------------------
|
|
FSAsyncStatus_t CSaveRestoreFileSystem::AsyncFinish( FSAsyncControl_t hControl, bool wait )
|
|
{
|
|
// do nothing
|
|
return FSASYNC_OK;
|
|
}
|
|
void CSaveRestoreFileSystem::AsyncRelease( FSAsyncControl_t hControl )
|
|
{
|
|
// do nothing
|
|
}
|
|
void CSaveRestoreFileSystem::AsyncFinishAllWrites( void )
|
|
{
|
|
// Do nothing
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Package up all intermediate files to a save game as per usual, but keep them in memory instead of commiting them to disk
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::DirectorCopyToMemory( const char *pPath, const char *pDestFileName )
|
|
{
|
|
// Write the save file
|
|
FileHandle_t hSaveFile = Open( pDestFileName, "ab+", pPath );
|
|
if ( !hSaveFile )
|
|
return;
|
|
|
|
SaveFile_t &saveFile = GetFile( hSaveFile );
|
|
|
|
// At this point, we're going to be sneaky and spoof the uncompressed buffer back into the compressed one
|
|
// We need to do this because the file goes out to disk as a mixture of an uncompressed header and tags, and compressed
|
|
// intermediate files, so this emulates that in memory
|
|
saveFile.pCompressedBuffer->Purge();
|
|
saveFile.nCompressedSize = 0;
|
|
saveFile.pCompressedBuffer->Put( saveFile.pBuffer->Base(), saveFile.nSize );
|
|
|
|
unsigned int nNumFilesPacked = 0;
|
|
for ( int i = GetDirectory().FirstInorder(); GetDirectory().IsValidIndex( i ); i = GetDirectory().NextInorder( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
const char *pName = GetString( file.name );
|
|
char szFileName[MAX_PATH];
|
|
if ( Q_stristr( pName, ".hl" ) )
|
|
{
|
|
int fileSize = CompressedSize( pName );
|
|
if ( fileSize )
|
|
{
|
|
Assert( Q_strlen( pName ) <= MAX_PATH );
|
|
|
|
memset( szFileName, 0, sizeof( szFileName ) );
|
|
Q_strncpy( szFileName, pName, sizeof( szFileName ) );
|
|
saveFile.pCompressedBuffer->Put( szFileName, sizeof( szFileName ) );
|
|
saveFile.pCompressedBuffer->Put( &fileSize, sizeof(fileSize) );
|
|
saveFile.pCompressedBuffer->Put( file.pCompressedBuffer->Base(), file.nCompressedSize );
|
|
|
|
SaveMsg("SIM: Packed: %s [Size: %.02f KB]\n", GetString( file.name ), (float)file.nCompressedSize / 1024.0f );
|
|
nNumFilesPacked++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the final, complete size of the file
|
|
saveFile.nCompressedSize = saveFile.pCompressedBuffer->TellMaxPut();
|
|
SaveMsg("SIM: (%s) Total Files Packed: %d [Size: %.02f KB]\n", GetString( saveFile.name ), nNumFilesPacked, (float) saveFile.nCompressedSize / 1024.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Copies the compressed contents of the CSaveDirectory into the save file on disk.
|
|
// Note: This expects standard saverestore behavior, and does NOT
|
|
// currently use pPath to filter the filename search.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::DirectoryCopy( const char *pPath, const char *pDestFileName, bool bIsXSave )
|
|
{
|
|
if ( !Q_stristr( pPath, "*.hl?" ) )
|
|
{
|
|
// Function depends on known behavior
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
// If we don't have a valid storage device, save this to memory instead
|
|
if ( saverestore->StorageDeviceValid() == false )
|
|
{
|
|
DirectorCopyToMemory( pPath, pDestFileName );
|
|
return;
|
|
}
|
|
|
|
// Write the save file
|
|
FileHandle_t hSaveFile = Open( pDestFileName, "rb", pPath );
|
|
if ( !hSaveFile )
|
|
return;
|
|
|
|
SaveFile_t &saveFile = GetFile( hSaveFile );
|
|
|
|
// Find out how large this is going to be
|
|
unsigned int nWriteSize = saveFile.nSize;
|
|
for ( int i = GetDirectory().FirstInorder(); GetDirectory().IsValidIndex( i ); i = GetDirectory().NextInorder( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
const char *pName = GetString( file.name );
|
|
if ( Q_stristr( pName, ".hl" ) )
|
|
{
|
|
// Account for the lump header size
|
|
nWriteSize += MAX_PATH + sizeof(int) + file.nCompressedSize;
|
|
}
|
|
}
|
|
|
|
// Fail to write
|
|
#if defined( _X360 )
|
|
if ( nWriteSize > XBX_SAVEGAME_BYTES )
|
|
{
|
|
// FIXME: This error is now lost in the ether!
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
g_pFileSystem->AsyncWriteFile( pDestFileName, saveFile.pBuffer, saveFile.nSize, true, false );
|
|
|
|
// AsyncWriteFile() takes control of the utlbuffer, so don't let RemoveFile() delete it.
|
|
saveFile.pBuffer = NULL;
|
|
RemoveFile( pDestFileName );
|
|
|
|
// write the list of files to the save file
|
|
for ( int i = GetDirectory().FirstInorder(); GetDirectory().IsValidIndex( i ); i = GetDirectory().NextInorder( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
const char *pName = GetString( file.name );
|
|
if ( Q_stristr( pName, ".hl" ) )
|
|
{
|
|
int fileSize = CompressedSize( pName );
|
|
if ( fileSize )
|
|
{
|
|
Assert( Q_strlen( pName ) <= MAX_PATH );
|
|
|
|
g_pFileSystem->AsyncAppend( pDestFileName, memcpy( new char[MAX_PATH], pName, MAX_PATH), MAX_PATH, true );
|
|
g_pFileSystem->AsyncAppend( pDestFileName, new int(fileSize), sizeof(int), true );
|
|
|
|
// This behaves like AsyncAppendFile (due to 5th param) but gets src file from memory instead of off disk.
|
|
g_pFileSystem->AsyncWriteFile( pDestFileName, file.pCompressedBuffer, file.nCompressedSize, false, true );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Extracts all the files contained within pFile.
|
|
// Does not Uncompress the extracted data.
|
|
//-----------------------------------------------------------------------------
|
|
bool CSaveRestoreFileSystem::DirectoryExtract( FileHandle_t pFile, int fileCount, bool bIsXSave )
|
|
{
|
|
int fileSize;
|
|
FileHandle_t pCopy;
|
|
char fileName[ MAX_PATH ];
|
|
|
|
// Read compressed files from disk into the virtual directory
|
|
for ( int i = 0; i < fileCount; i++ )
|
|
{
|
|
Read( fileName, MAX_PATH, pFile );
|
|
Read( &fileSize, sizeof(int), pFile );
|
|
if ( !fileSize )
|
|
return false;
|
|
|
|
pCopy = Open( fileName, "wb" );
|
|
if ( !pCopy )
|
|
return false;
|
|
|
|
SaveFile_t &destFile = GetFile( pCopy );
|
|
destFile.pCompressedBuffer->EnsureCapacity( fileSize );
|
|
|
|
// Must read in the correct amount of data
|
|
if ( Read( destFile.pCompressedBuffer->PeekPut(), fileSize, pFile ) != fileSize )
|
|
return false;
|
|
|
|
destFile.pCompressedBuffer->SeekPut( CUtlBuffer::SEEK_HEAD, fileSize );
|
|
destFile.nCompressedSize = fileSize;
|
|
|
|
SaveMsg("SIM: Extracted: %s [Size: %d KB]\n", GetString( destFile.name ), destFile.nCompressedSize / 1024 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pFilename -
|
|
//-----------------------------------------------------------------------------
|
|
bool CSaveRestoreFileSystem::LoadFileFromDisk( const char *pFilename )
|
|
{
|
|
// Open a new file for writing in memory
|
|
FileHandle_t hMemoryFile = Open( pFilename, "wb" );
|
|
if ( !hMemoryFile )
|
|
return false;
|
|
|
|
// Open the file off the disk
|
|
FileHandle_t hDiskFile = g_pFileSystem->OpenEx( pFilename, "rb", ( IsX360() ) ? FSOPEN_NEVERINPACK : 0 );
|
|
if ( !hDiskFile )
|
|
return false;
|
|
|
|
// Read it in off of the disk to memory
|
|
SaveFile_t &memoryFile = GetFile( hMemoryFile );
|
|
if ( g_pFileSystem->ReadToBuffer( hDiskFile, *memoryFile.pCompressedBuffer ) == false )
|
|
return false;
|
|
|
|
// Hold the compressed size
|
|
memoryFile.nCompressedSize = memoryFile.pCompressedBuffer->TellMaxPut();
|
|
|
|
// Close the disk file
|
|
g_pFileSystem->Close( hDiskFile );
|
|
|
|
SaveMsg("SIM: Loaded %s into memory\n", pFilename );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the number of save files in the specified filter
|
|
// Note: This expects standard saverestore behavior, and does NOT
|
|
// currently use pPath to filter file search.
|
|
//-----------------------------------------------------------------------------
|
|
int CSaveRestoreFileSystem::DirectoryCount( const char *pPath )
|
|
{
|
|
if ( !Q_stristr( pPath, "*.hl?" ) )
|
|
{
|
|
// Function depends on known behavior
|
|
Assert( 0 );
|
|
return 0;
|
|
}
|
|
|
|
int count = 0;
|
|
for ( int i = GetDirectory().FirstInorder(); GetDirectory().IsValidIndex( i ); i = GetDirectory().NextInorder( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
if ( Q_stristr( GetString( file.name ), ".hl" ) )
|
|
{
|
|
++count;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Clears the save directory of temporary save files (*.hl)
|
|
// Note: This expects standard saverestore behavior, and does NOT
|
|
// currently use pPath to filter file search.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::DirectoryClear( const char *pPath, bool bIsXSave )
|
|
{
|
|
if ( !Q_stristr( pPath, "*.hl?" ) )
|
|
{
|
|
// Function depends on known behavior
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
int i = GetDirectory().FirstInorder();
|
|
while ( GetDirectory().IsValidIndex( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
i = GetDirectory().NextInorder( i );
|
|
if ( Q_stristr( GetString( file.name ), ".hl" ) )
|
|
{
|
|
SaveMsg("SIM: Cleared: %s\n", GetString( file.name ) );
|
|
|
|
// Delete the temporary save file
|
|
RemoveFile( GetString( file.name ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Transfer all save files from memory to disk.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::WriteSaveDirectoryToDisk( void )
|
|
{
|
|
char szPath[ MAX_PATH ];
|
|
|
|
int i = GetDirectory().FirstInorder();
|
|
while ( GetDirectory().IsValidIndex( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
i = GetDirectory().NextInorder( i );
|
|
const char *pName = GetString( file.name );
|
|
if ( Q_stristr( pName, ".hl" ) )
|
|
{
|
|
// Write the temporary save file to disk
|
|
Open( pName, "rb" );
|
|
Q_snprintf( szPath, sizeof( szPath ), "%s%s", saverestore->GetSaveDir(), pName );
|
|
g_pFileSystem->WriteFile( szPath, "GAME", *file.pBuffer );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Transfer all save files from disk to memory.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::LoadSaveDirectoryFromDisk( const char *pPath )
|
|
{
|
|
char const *findfn;
|
|
char szPath[ MAX_PATH ];
|
|
|
|
findfn = Sys_FindFirstEx( pPath, "DEFAULT_WRITE_PATH", NULL, 0 );
|
|
|
|
while ( findfn != NULL )
|
|
{
|
|
Q_snprintf( szPath, sizeof( szPath ), "%s%s", saverestore->GetSaveDir(), findfn );
|
|
|
|
// Add the temporary save file
|
|
FileHandle_t hFile = Open( findfn, "wb" );
|
|
if ( hFile )
|
|
{
|
|
SaveFile_t &file = GetFile( hFile );
|
|
g_pFileSystem->ReadFile( szPath, "GAME", *file.pBuffer );
|
|
file.nSize = file.pBuffer->TellMaxPut();
|
|
Close( hFile );
|
|
}
|
|
|
|
// Any more save files
|
|
findfn = Sys_FindNext( NULL, 0 );
|
|
}
|
|
Sys_FindClose();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::AuditFiles( void )
|
|
{
|
|
unsigned int nTotalFiles = 0;
|
|
unsigned int nTotalCompressed = 0;
|
|
unsigned int nTotalUncompressed = 0;
|
|
|
|
int i = GetDirectory().FirstInorder();
|
|
while ( GetDirectory().IsValidIndex( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
i = GetDirectory().NextInorder( i );
|
|
|
|
nTotalFiles++;
|
|
nTotalCompressed += file.nCompressedSize;
|
|
nTotalUncompressed += file.nSize;
|
|
Msg("SIM: File: %s [c: %.02f KB / u: %.02f KB]\n", GetString( file.name ), (float)file.nCompressedSize/1024.0f, (float)file.nSize/1024.0f );
|
|
}
|
|
|
|
Msg("SIM: ------------------------------------------------------------");
|
|
Msg("SIM: Total files: %d [c: %.02f KB / c: %.02f KB] : Total Size: %.02f KB\n", nTotalFiles, (float)nTotalCompressed/1024.0f, (float)nTotalUncompressed/1024.0f, (float)(nTotalCompressed+nTotalUncompressed)/1024.0f );
|
|
}
|
|
|
|
CON_COMMAND( audit_save_in_memory, "Audit the memory usage and files in the save-to-memory system" )
|
|
{
|
|
if ( !IsX360() )
|
|
return;
|
|
|
|
g_pSaveRestoreFileSystem->AuditFiles();
|
|
}
|
|
|
|
CON_COMMAND( dump_x360_saves, "Dump X360 save games to disk" )
|
|
{
|
|
if ( !IsX360() )
|
|
{
|
|
Warning("dump_x360 only available on X360 platform!\n");
|
|
return;
|
|
}
|
|
|
|
if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )
|
|
{
|
|
Warning( "No storage device attached!\n" );
|
|
return;
|
|
}
|
|
|
|
char szInName[MAX_PATH]; // Read path from the container
|
|
char szOutName[MAX_PATH]; // Output path to the disk
|
|
char szFileNameBase[MAX_PATH]; // Name of the file minus directories or extensions
|
|
FileFindHandle_t findHandle;
|
|
|
|
char szSearchPath[MAX_PATH];
|
|
Q_snprintf( szSearchPath, sizeof( szSearchPath ), "%s:\\*.*", GetCurrentMod() );
|
|
|
|
const char *pFileName = g_pFileSystem->FindFirst( szSearchPath, &findHandle );
|
|
while (pFileName)
|
|
{
|
|
// Create the proper read path
|
|
Q_snprintf( szInName, sizeof( szInName ), "%s:\\%s", GetCurrentMod(), pFileName );
|
|
// Read the file and blat it out
|
|
CUtlBuffer buf( 0, 0, 0 );
|
|
if ( g_pFileSystem->ReadFile( szInName, NULL, buf ) )
|
|
{
|
|
// Strip us down to just our filename
|
|
Q_FileBase( pFileName, szFileNameBase, sizeof ( szFileNameBase ) );
|
|
Q_snprintf( szOutName, sizeof( szOutName ), "save/%s.sav", szFileNameBase );
|
|
g_pFileSystem->WriteFile( szOutName, NULL, buf );
|
|
|
|
Msg("Copied file: %s to %s\n", szInName, szOutName );
|
|
}
|
|
|
|
// Clean up
|
|
buf.Clear();
|
|
|
|
// Any more save files
|
|
pFileName = g_pFileSystem->FindNext( findHandle );
|
|
}
|
|
|
|
g_pFileSystem->FindClose( findHandle );
|
|
}
|
|
|
|
CON_COMMAND( dump_x360_cfg, "Dump X360 config files to disk" )
|
|
{
|
|
if ( !IsX360() )
|
|
{
|
|
Warning("dump_x360 only available on X360 platform!\n");
|
|
return;
|
|
}
|
|
|
|
if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )
|
|
{
|
|
Warning( "No storage device attached!\n" );
|
|
return;
|
|
}
|
|
|
|
char szInName[MAX_PATH]; // Read path from the container
|
|
char szOutName[MAX_PATH]; // Output path to the disk
|
|
char szFileNameBase[MAX_PATH]; // Name of the file minus directories or extensions
|
|
FileFindHandle_t findHandle;
|
|
|
|
char szSearchPath[MAX_PATH];
|
|
Q_snprintf( szSearchPath, sizeof( szSearchPath ), "cfg:\\*.*" );
|
|
|
|
const char *pFileName = g_pFileSystem->FindFirst( szSearchPath, &findHandle );
|
|
while (pFileName)
|
|
{
|
|
// Create the proper read path
|
|
Q_snprintf( szInName, sizeof( szInName ), "cfg:\\%s", pFileName );
|
|
// Read the file and blat it out
|
|
CUtlBuffer buf( 0, 0, 0 );
|
|
if ( g_pFileSystem->ReadFile( szInName, NULL, buf ) )
|
|
{
|
|
// Strip us down to just our filename
|
|
Q_FileBase( pFileName, szFileNameBase, sizeof ( szFileNameBase ) );
|
|
Q_snprintf( szOutName, sizeof( szOutName ), "%s.cfg", szFileNameBase );
|
|
g_pFileSystem->WriteFile( szOutName, NULL, buf );
|
|
|
|
Msg("Copied file: %s to %s\n", szInName, szOutName );
|
|
}
|
|
|
|
// Clean up
|
|
buf.Clear();
|
|
|
|
// Any more save files
|
|
pFileName = g_pFileSystem->FindNext( findHandle );
|
|
}
|
|
|
|
g_pFileSystem->FindClose( findHandle );
|
|
}
|
|
|
|
#define FILECOPYBUFSIZE (1024 * 1024)
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Copy one file to another file
|
|
//-----------------------------------------------------------------------------
|
|
static bool FileCopy( FileHandle_t pOutput, FileHandle_t pInput, int fileSize )
|
|
{
|
|
// allocate a reasonably large file copy buffer, since otherwise write performance under steam suffers
|
|
char *buf = (char *)malloc(FILECOPYBUFSIZE);
|
|
int size;
|
|
int readSize;
|
|
bool success = true;
|
|
|
|
while ( fileSize > 0 )
|
|
{
|
|
if ( fileSize > FILECOPYBUFSIZE )
|
|
size = FILECOPYBUFSIZE;
|
|
else
|
|
size = fileSize;
|
|
if ( ( readSize = g_pSaveRestoreFileSystem->Read( buf, size, pInput ) ) < size )
|
|
{
|
|
Warning( "Unexpected end of file expanding save game\n" );
|
|
fileSize = 0;
|
|
success = false;
|
|
break;
|
|
}
|
|
g_pSaveRestoreFileSystem->Write( buf, readSize, pOutput );
|
|
|
|
fileSize -= size;
|
|
}
|
|
|
|
free(buf);
|
|
return success;
|
|
}
|
|
|
|
struct filelistelem_t
|
|
{
|
|
char szFileName[MAX_PATH];
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Implementation to execute traditional save to disk behavior
|
|
//-----------------------------------------------------------------------------
|
|
class CSaveRestoreFileSystemPassthrough : public ISaveRestoreFileSystem
|
|
{
|
|
public:
|
|
CSaveRestoreFileSystemPassthrough() : m_iContainerOpens( 0 ) {}
|
|
|
|
bool FileExists( const char *pFileName, const char *pPathID )
|
|
{
|
|
return g_pFileSystem->FileExists( pFileName, pPathID );
|
|
}
|
|
|
|
void RemoveFile( char const* pRelativePath, const char *pathID )
|
|
{
|
|
g_pFileSystem->RemoveFile( pRelativePath, pathID );
|
|
}
|
|
|
|
void RenameFile( char const *pOldPath, char const *pNewPath, const char *pathID )
|
|
{
|
|
g_pFileSystem->RenameFile( pOldPath, pNewPath, pathID );
|
|
}
|
|
|
|
void AsyncFinishAllWrites( void )
|
|
{
|
|
g_pFileSystem->AsyncFinishAllWrites();
|
|
}
|
|
|
|
FileHandle_t Open( const char *pFullName, const char *pOptions, const char *pathID )
|
|
{
|
|
return g_pFileSystem->OpenEx( pFullName, pOptions, FSOPEN_NEVERINPACK, pathID );
|
|
}
|
|
|
|
void Close( FileHandle_t hSaveFile )
|
|
{
|
|
g_pFileSystem->Close( hSaveFile );
|
|
}
|
|
|
|
int Read( void *pOutput, int size, FileHandle_t hFile )
|
|
{
|
|
return g_pFileSystem->Read( pOutput, size, hFile );
|
|
}
|
|
|
|
int Write( void const* pInput, int size, FileHandle_t hFile )
|
|
{
|
|
return g_pFileSystem->Write( pInput, size, hFile );
|
|
}
|
|
|
|
FSAsyncStatus_t AsyncWrite( const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, bool bAppend, FSAsyncControl_t *pControl )
|
|
{
|
|
SaveMsg( "AsyncWrite (%s/%d)...\n", pFileName, nSrcBytes );
|
|
return g_pFileSystem->AsyncWrite( pFileName, pSrc, nSrcBytes, bFreeMemory, bAppend, pControl );
|
|
}
|
|
|
|
void Seek( FileHandle_t hFile, int pos, FileSystemSeek_t method )
|
|
{
|
|
g_pFileSystem->Seek( hFile, pos, method );
|
|
}
|
|
|
|
unsigned int Tell( FileHandle_t hFile )
|
|
{
|
|
return g_pFileSystem->Tell( hFile );
|
|
}
|
|
|
|
unsigned int Size( FileHandle_t hFile )
|
|
{
|
|
return g_pFileSystem->Size( hFile );
|
|
}
|
|
|
|
unsigned int Size( const char *pFileName, const char *pPathID )
|
|
{
|
|
return g_pFileSystem->Size( pFileName, pPathID );
|
|
}
|
|
|
|
FSAsyncStatus_t AsyncFinish( FSAsyncControl_t hControl, bool wait )
|
|
{
|
|
return g_pFileSystem->AsyncFinish( hControl, wait );
|
|
}
|
|
|
|
void AsyncRelease( FSAsyncControl_t hControl )
|
|
{
|
|
g_pFileSystem->AsyncRelease( hControl );
|
|
}
|
|
|
|
FSAsyncStatus_t AsyncAppend(const char *pFileName, const void *pSrc, int nSrcBytes, bool bFreeMemory, FSAsyncControl_t *pControl )
|
|
{
|
|
return g_pFileSystem->AsyncAppend( pFileName, pSrc, nSrcBytes, bFreeMemory, pControl );
|
|
}
|
|
|
|
FSAsyncStatus_t AsyncAppendFile(const char *pDestFileName, const char *pSrcFileName, FSAsyncControl_t *pControl )
|
|
{
|
|
return g_pFileSystem->AsyncAppendFile( pDestFileName, pSrcFileName, pControl );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Copies the contents of the save directory into a single file
|
|
//-----------------------------------------------------------------------------
|
|
void DirectoryCopy( const char *pPath, const char *pDestFileName, bool bIsXSave )
|
|
{
|
|
SaveMsg( "DirectoryCopy....\n");
|
|
|
|
CUtlVector<filelistelem_t> list;
|
|
|
|
// force the writes to finish before trying to get the size/existence of a file
|
|
// @TODO: don't need this if retain sizes for files written earlier in process
|
|
SaveMsg( "DirectoryCopy: AsyncFinishAllWrites\n");
|
|
g_pFileSystem->AsyncFinishAllWrites();
|
|
|
|
// build the directory list
|
|
char basefindfn[ MAX_PATH ];
|
|
const char *findfn = Sys_FindFirstEx(pPath, "DEFAULT_WRITE_PATH", basefindfn, sizeof( basefindfn ) );
|
|
while ( findfn )
|
|
{
|
|
int index = list.AddToTail();
|
|
memset( list[index].szFileName, 0, sizeof(list[index].szFileName) );
|
|
Q_strncpy( list[index].szFileName, findfn, sizeof(list[index].szFileName) );
|
|
|
|
findfn = Sys_FindNext( basefindfn, sizeof( basefindfn ) );
|
|
}
|
|
Sys_FindClose();
|
|
|
|
// write the list of files to the save file
|
|
char szName[MAX_PATH];
|
|
for ( int i = 0; i < list.Count(); i++ )
|
|
{
|
|
if ( !bIsXSave )
|
|
{
|
|
Q_snprintf( szName, sizeof( szName ), "%s%s", saverestore->GetSaveDir(), list[i].szFileName );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( szName, sizeof( szName ), "%s:\\%s", GetCurrentMod(), list[i].szFileName );
|
|
}
|
|
|
|
Q_FixSlashes( szName );
|
|
|
|
int fileSize = g_pFileSystem->Size( szName );
|
|
if ( fileSize )
|
|
{
|
|
Assert( sizeof(list[i].szFileName) == MAX_PATH );
|
|
|
|
SaveMsg( "DirectoryCopy: AsyncAppend %s, %s\n", szName, pDestFileName );
|
|
g_pFileSystem->AsyncAppend( pDestFileName, memcpy( new char[MAX_PATH], list[i].szFileName, MAX_PATH), MAX_PATH, true ); // Filename can only be as long as a map name + extension
|
|
g_pFileSystem->AsyncAppend( pDestFileName, new int(fileSize), sizeof(int), true );
|
|
g_pFileSystem->AsyncAppendFile( pDestFileName, szName );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Extracts all the files contained within pFile
|
|
//-----------------------------------------------------------------------------
|
|
bool DirectoryExtract( FileHandle_t pFile, int fileCount, bool bIsXSave )
|
|
{
|
|
int fileSize;
|
|
FileHandle_t pCopy;
|
|
char szName[ MAX_PATH ], fileName[ MAX_PATH ];
|
|
bool success = true;
|
|
|
|
for ( int i = 0; i < fileCount && success; i++ )
|
|
{
|
|
// Filename can only be as long as a map name + extension
|
|
if ( g_pSaveRestoreFileSystem->Read( fileName, MAX_PATH, pFile ) != MAX_PATH )
|
|
return false;
|
|
|
|
if ( g_pSaveRestoreFileSystem->Read( &fileSize, sizeof(int), pFile ) != sizeof(int) )
|
|
return false;
|
|
|
|
if ( !fileSize )
|
|
return false;
|
|
|
|
if ( !bIsXSave )
|
|
{
|
|
Q_snprintf( szName, sizeof( szName ), "%s%s", saverestore->GetSaveDir(), fileName );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( szName, sizeof( szName ), "%s:\\%s", GetCurrentMod(), fileName );
|
|
}
|
|
|
|
Q_FixSlashes( szName );
|
|
pCopy = g_pSaveRestoreFileSystem->Open( szName, "wb", "MOD" );
|
|
if ( !pCopy )
|
|
return false;
|
|
success = FileCopy( pCopy, pFile, fileSize );
|
|
g_pSaveRestoreFileSystem->Close( pCopy );
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the number of files in the specified filter
|
|
//-----------------------------------------------------------------------------
|
|
int DirectoryCount( const char *pPath )
|
|
{
|
|
int count = 0;
|
|
const char *findfn = Sys_FindFirstEx( pPath, "DEFAULT_WRITE_PATH", NULL, 0 );
|
|
|
|
while ( findfn != NULL )
|
|
{
|
|
count++;
|
|
findfn = Sys_FindNext(NULL, 0 );
|
|
}
|
|
Sys_FindClose();
|
|
|
|
return count;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Clears the save directory of all temporary files (*.hl)
|
|
//-----------------------------------------------------------------------------
|
|
void DirectoryClear( const char *pPath, bool bIsXSave )
|
|
{
|
|
char const *findfn;
|
|
char szPath[ MAX_PATH ];
|
|
|
|
findfn = Sys_FindFirstEx( pPath, "DEFAULT_WRITE_PATH", NULL, 0 );
|
|
while ( findfn != NULL )
|
|
{
|
|
if ( !bIsXSave )
|
|
{
|
|
Q_snprintf( szPath, sizeof( szPath ), "%s%s", saverestore->GetSaveDir(), findfn );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( szPath, sizeof( szPath ), "%s:\\%s", GetCurrentMod(), findfn );
|
|
}
|
|
|
|
// Delete the temporary save file
|
|
g_pFileSystem->RemoveFile( szPath, "MOD" );
|
|
|
|
// Any more save files
|
|
findfn = Sys_FindNext( NULL, 0 );
|
|
}
|
|
Sys_FindClose();
|
|
}
|
|
|
|
void AuditFiles( void )
|
|
{
|
|
Msg("Not using save-in-memory path!\n" );
|
|
}
|
|
|
|
bool LoadFileFromDisk( const char *pFilename )
|
|
{
|
|
Msg("Not using save-in-memory path!\n" );
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
int m_iContainerOpens;
|
|
};
|
|
|
|
static CSaveRestoreFileSystem s_SaveRestoreFileSystem;
|
|
static CSaveRestoreFileSystemPassthrough s_SaveRestoreFileSystemPassthrough;
|
|
|
|
#ifdef _X360
|
|
ISaveRestoreFileSystem *g_pSaveRestoreFileSystem = &s_SaveRestoreFileSystem;
|
|
#else
|
|
ISaveRestoreFileSystem *g_pSaveRestoreFileSystem = &s_SaveRestoreFileSystemPassthrough;
|
|
#endif // _X360
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when switching between saving in memory and saving to disk.
|
|
//-----------------------------------------------------------------------------
|
|
void SaveInMemoryCallback( IConVar *pConVar, const char *pOldString, float flOldValue )
|
|
{
|
|
if ( !IsX360() )
|
|
{
|
|
Warning( "save_in_memory is compatible with only the Xbox 360!\n" );
|
|
return;
|
|
}
|
|
|
|
ConVarRef var( pConVar );
|
|
if ( var.GetFloat() == flOldValue )
|
|
return;
|
|
|
|
// *.hl? files are transferred between disk and memory when this cvar changes
|
|
char szPath[ MAX_PATH ];
|
|
Q_snprintf( szPath, sizeof( szPath ), "%s%s", saverestore->GetSaveDir(), "*.hl?" );
|
|
if ( var.GetBool() )
|
|
{
|
|
g_pSaveRestoreFileSystem = &s_SaveRestoreFileSystem;
|
|
|
|
// Clear memory and load
|
|
s_SaveRestoreFileSystem.DirectoryClear( "*.hl?", IsX360() );
|
|
s_SaveRestoreFileSystem.LoadSaveDirectoryFromDisk( szPath );
|
|
|
|
// Clear disk
|
|
s_SaveRestoreFileSystemPassthrough.DirectoryClear( szPath, IsX360() );
|
|
}
|
|
else
|
|
{
|
|
g_pSaveRestoreFileSystem = &s_SaveRestoreFileSystemPassthrough;
|
|
|
|
// Clear disk and write
|
|
s_SaveRestoreFileSystemPassthrough.DirectoryClear( szPath, IsX360() );
|
|
s_SaveRestoreFileSystem.WriteSaveDirectoryToDisk();
|
|
|
|
// Clear memory
|
|
s_SaveRestoreFileSystem.DirectoryClear( "*.hl?", IsX360() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Dump a list of the save directory contents (in memory) to the console
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveRestoreFileSystem::DumpSaveDirectory( void )
|
|
{
|
|
unsigned int totalCompressedSize = 0;
|
|
unsigned int totalUncompressedSize = 0;
|
|
for ( int i = GetDirectory().FirstInorder(); GetDirectory().IsValidIndex( i ); i = GetDirectory().NextInorder( i ) )
|
|
{
|
|
SaveFile_t &file = GetFile( i );
|
|
Msg( "File %d: %s Size:%d\n", i, GetString( file.name ), file.nCompressedSize );
|
|
totalUncompressedSize += file.nSize;
|
|
totalCompressedSize += file.nCompressedSize;
|
|
}
|
|
float percent = 0.f;
|
|
if ( totalUncompressedSize )
|
|
percent = 100.f - (totalCompressedSize / totalUncompressedSize * 100.f);
|
|
Msg( "Total Size: %.2f Mb (%d bytes)\n", totalCompressedSize / (1024.f*1024.f), totalCompressedSize );
|
|
Msg( "Compression: %.2f Mb to %.2f Mb (%.0f%%)\n", totalUncompressedSize/(1024.f*1024.f), totalCompressedSize/(1024.f*1024.f), percent );
|
|
}
|
|
|
|
CON_COMMAND( dumpsavedir, "List the contents of the save directory in memory" )
|
|
{
|
|
s_SaveRestoreFileSystem.DumpSaveDirectory();
|
|
}
|
|
|