MemoryStream::MemoryStream(char *name, void* data, unsigned long size)
: data((char*)data)
{
this->size = size;
ExtractFileFromPath(filename, name);
strncpy(originalfile, name, _MAX_PATH);
}
bool FileStream::Create(const char *folder, const char* fname, SClass_ID ClassID)
{
char path[_MAX_PATH];
char filename[_MAX_PATH];
ExtractFileFromPath( filename, fname );
PathJoinExt(path, folder, filename, core->TypeExt(ClassID));
return Create(path);
}
int BIFImporter::OpenArchive(const char* path)
{
if (stream) {
delete( stream );
stream = NULL;
}
char filename[_MAX_PATH];
ExtractFileFromPath(filename, path);
char cachePath[_MAX_PATH];
PathJoin(cachePath, core->CachePath, filename, NULL);
stream = FileStream::OpenFile(cachePath);
char Signature[8];
if (!stream) {
FileStream* file = FileStream::OpenFile(path);
if (!file) {
return GEM_ERROR;
}
if (file->Read(Signature, 8) == GEM_ERROR) {
delete file;
return GEM_ERROR;
}
if (strncmp(Signature, "BIF V1.0", 8) == 0) {
stream = DecompressBIF(file, cachePath);
delete file;
} else if (strncmp(Signature, "BIFCV1.0", 8) == 0) {
stream = DecompressBIFC(file, cachePath);
delete file;
} else if (strncmp( Signature, "BIFFV1 ", 8 ) == 0) {
file->Seek(0, GEM_STREAM_START);
stream = file;
} else {
delete file;
return GEM_ERROR;
}
}
if (!stream)
return GEM_ERROR;
stream->Read( Signature, 8 );
if (strncmp( Signature, "BIFFV1 ", 8 ) != 0) {
return GEM_ERROR;
}
ReadBIF();
return GEM_OK;
}
CachedFileStream::CachedFileStream(const char* stream, bool autoFree)
{
ExtractFileFromPath( filename, stream );
PathJoin( originalfile, core->CachePath, filename, NULL );
str = _fopen( originalfile, "rb" );
if (str == NULL) { // File was not found in cache
if (core->GameOnCD) {
_FILE* src = _fopen( stream, "rb" );
#ifdef _DEBUG
core->CachedFileStreamPtrCount++;
#endif
_FILE* dest = _fopen( originalfile, "wb" );
#ifdef _DEBUG
core->CachedFileStreamPtrCount++;
#endif
void* buff = malloc( 1024 * 1000 );
do {
size_t len = _fread( buff, 1, 1024 * 1000, src );
size_t c = _fwrite( buff, 1, len, dest );
if (c != len) {
printf("CachedFileStream failed to write to cached file '%s' (from '%s')\n", originalfile, stream);
abort();
}
} while (!_feof( src ));
free( buff );
_fclose( src );
#ifdef _DEBUG
core->CachedFileStreamPtrCount--;
#endif
_fclose( dest );
#ifdef _DEBUG
core->CachedFileStreamPtrCount--;
#endif
} else { // Don't cache files already on hdd
strncpy(originalfile, stream, _MAX_PATH);
}
str = _fopen( originalfile, "rb" );
}
#ifdef _DEBUG
core->CachedFileStreamPtrCount++;
#endif
startpos = 0;
_fseek( str, 0, SEEK_END );
size = _ftell( str );
_fseek( str, 0, SEEK_SET );
Pos = 0;
this->autoFree = autoFree;
}
//Creating file outside of the cache
bool FileStream::Create(const char *path)
{
Close();
ExtractFileFromPath( filename, path );
strlcpy(originalfile, path, _MAX_PATH);
if (!str->OpenNew(originalfile)) {
return false;
}
opened = true;
created = true;
Pos = 0;
size = 0;
return true;
}
bool FileStream::Modify(const char* fname)
{
Close();
if (!str->OpenRW(fname)) {
return false;
}
#ifdef _DEBUG
FileStreamPtrCount++;
#endif
opened = true;
created = true;
FindLength();
ExtractFileFromPath( filename, fname );
strlcpy( originalfile, fname, _MAX_PATH);
Pos = 0;
return true;
}
bool FileStream::Open(const char* fname)
{
Close();
if (!file_exists(fname)) {
return false;
}
if (!str->OpenRO(fname)) {
return false;
}
#ifdef _DEBUG
core->FileStreamPtrCount++;
#endif
opened = true;
created = false;
FindLength();
ExtractFileFromPath( filename, fname );
strncpy( originalfile, fname, _MAX_PATH);
return true;
}
DataStream* ResourceManager::AddCacheFile(const char *filename)
{
if (!core->GameOnCD)
return FileStream::OpenFile(filename);
char fname[_MAX_PATH];
ExtractFileFromPath(fname, filename);
FileStream *dest = OpenCacheFile(fname);
// already in cache
if (dest)
return dest;
FileStream* src = FileStream::OpenFile(fname);
dest = CreateCacheFile(fname);
if (!src || !dest) {
printMessage("ResourceManager", "Failed to copy file '%s'\n", RED, fname);
abort();
}
size_t blockSize = 1024 * 1000;
char buff[1024 * 1000];
do {
if (blockSize > src->Remains())
blockSize = src->Remains();
size_t len = src->Read(buff, blockSize);
size_t c = dest->Write(buff, len);
if (c != len) {
printMessage("ResourceManager", "Failed to write to file '%s'\n", RED, fname);
abort();
}
} while (src->Remains());
delete src;
delete dest;
return OpenCacheFile(fname);
}
DataStream *ResourceManager::AddCompressedCacheFile(DataStream *stream, const char* filename, int length, bool overwrite)
{
if (!core->IsAvailable(PLUGIN_COMPRESSION_ZLIB)) {
printMessage("ResourceManager", "No compression manager available.\nCannot load compressed file.\n", RED);
return NULL;
}
char fname[_MAX_PATH];
ExtractFileFromPath(fname, filename);
FileStream *str = NULL;
if (!overwrite)
str = OpenCacheFile(fname);
if (!str) {
FileStream *out = CreateCacheFile(fname);
if (!out) {
printMessage("ResourceManager", "Failed to write to file '%s'.\n", RED, fname);
return NULL;
}
PluginHolder<Compressor> comp(PLUGIN_COMPRESSION_ZLIB);
if (comp->Decompress(out, stream, length) != GEM_OK) {
delete out;
return NULL;
}
delete out;
} else {
stream->Seek(length, GEM_CURRENT_POS);
}
delete str;
return OpenCacheFile(fname);
}
