OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

- transition to new FileReader interface complete, but untested.

Browse source
This commit is contained in:
Christoph Oelckers 2018-03-11 12:33:46 +01:00
commit b14ee50d0d
31 changed files with 1253 additions and 1708 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/resourcefiles/ancientzip.cpp
View file

@ -70,7 +70,7 @@
if (bs < be) \
c = ReadBuf[bs++]; \
else { \
be = In->Read(&ReadBuf, sizeof(ReadBuf)); \
be = (decltype(be))In->Read(&ReadBuf, sizeof(ReadBuf)); \
c = ReadBuf[0]; \
bs = 1; \
} \
@ -259,7 +259,7 @@ int FZipExploder::DecodeSF(TArray<HuffNode> &decoder, int numvals)
}
int FZipExploder::Explode(unsigned char *out, unsigned int outsize,
FileReader *in, unsigned int insize,
FileRdr &in, unsigned int insize,
int flags)
{
int c, i, minMatchLen = 3, len, dist;
@ -268,7 +268,7 @@ int FZipExploder::Explode(unsigned char *out, unsigned int outsize,
Hold = 0;
Bits = 0;
In = in;
In = &in;
InLeft = insize;
bs = be = 0;
@ -337,9 +337,9 @@ int FZipExploder::Explode(unsigned char *out, unsigned int outsize,
#define FREE_CODE HSIZE /* 0x2000 (code is unused or was cleared) */
#define HAS_CHILD (HSIZE << 1) /* 0x4000 (code has a child--do not clear) */
int ShrinkLoop(unsigned char *out, unsigned int outsize,
FileReader *In, unsigned int InLeft)
int ShrinkLoop(unsigned char *out, unsigned int outsize, FileRdr &_In, unsigned int InLeft)
{
FileRdr *In = &_In;
unsigned char ReadBuf[256];
unsigned short Parent[HSIZE];
unsigned char Value[HSIZE], Stack[HSIZE];

6
src/resourcefiles/ancientzip.h
View file

@ -4,7 +4,7 @@
class FZipExploder
{
unsigned int Hold, Bits;
FileReader *In;
FileRdr *In;
unsigned int InLeft;
/****************************************************************
@ -38,7 +38,7 @@ class FZipExploder
int DecodeSFValue(const TArray<HuffNode> &currentTree);
int DecodeSF(TArray<HuffNode> &decoder, int numvals);
public:
int Explode(unsigned char *out, unsigned int outsize, FileReader *in, unsigned int insize, int flags);
int Explode(unsigned char *out, unsigned int outsize, FileRdr &in, unsigned int insize, int flags);
};
class CExplosionError : CRecoverableError
@ -47,4 +47,4 @@ public:
CExplosionError(const char *message) : CRecoverableError(message) {}
};
int ShrinkLoop(unsigned char *out, unsigned int outsize, FileReader *in, unsigned int insize);
int ShrinkLoop(unsigned char *out, unsigned int outsize, FileRdr &in, unsigned int insize);

42
src/resourcefiles/file_7z.cpp
View file

@ -58,19 +58,19 @@ extern ISzAlloc g_Alloc;
struct CZDFileInStream
{
ISeekInStream s;
FileReader *File;
FileRdr &File;
CZDFileInStream(FileReader *_file)
CZDFileInStream(FileRdr &_file)
: File(_file)
{
s.Read = Read;
s.Seek = Seek;
File = _file;
}
static SRes Read(const ISeekInStream *pp, void *buf, size_t *size)
{
CZDFileInStream *p = (CZDFileInStream *)pp;
long numread = p->File->Read(buf, (long)*size);
auto numread = p->File.Read(buf, (long)*size);
if (numread < 0)
{
*size = 0;
@ -83,26 +83,26 @@ struct CZDFileInStream
static SRes Seek(const ISeekInStream *pp, Int64 *pos, ESzSeek origin)
{
CZDFileInStream *p = (CZDFileInStream *)pp;
int move_method;
FileRdr::ESeek move_method;
int res;
if (origin == SZ_SEEK_SET)
{
move_method = SEEK_SET;
move_method = FileRdr::SeekSet;
}
else if (origin == SZ_SEEK_CUR)
{
move_method = SEEK_CUR;
move_method = FileRdr::SeekCur;
}
else if (origin == SZ_SEEK_END)
{
move_method = SEEK_END;
move_method = FileRdr::SeekEnd;
}
else
{
return 1;
}
res = p->File->Seek((long)*pos, move_method);
*pos = p->File->Tell();
res = (int)p->File.Seek((long)*pos, move_method);
*pos = p->File.Tell();
return res;
}
};
@ -117,13 +117,13 @@ struct C7zArchive
Byte *OutBuffer;
size_t OutBufferSize;
C7zArchive(FileReader *file) : ArchiveStream(file)
C7zArchive(FileRdr &file) : ArchiveStream(file)
{
if (g_CrcTable[1] == 0)
{
CrcGenerateTable();
}
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
LookToRead2_CreateVTable(&LookStream, false);
LookStream.realStream = &ArchiveStream.s;
LookToRead2_Init(&LookStream);
@ -192,7 +192,7 @@ class F7ZFile : public FResourceFile
C7zArchive *Archive;
public:
F7ZFile(const char * filename, FileReader *filer);
F7ZFile(const char * filename, FileRdr &filer);
bool Open(bool quiet);
virtual ~F7ZFile();
virtual FResourceLump *GetLump(int no) { return ((unsigned)no < NumLumps)? &Lumps[no] : NULL; }
@ -206,7 +206,7 @@ public:
//
//==========================================================================
F7ZFile::F7ZFile(const char * filename, FileReader *filer)
F7ZFile::F7ZFile(const char * filename, FileRdr &filer)
: FResourceFile(filename, filer)
{
Lumps = NULL;
@ -295,7 +295,7 @@ bool F7ZFile::Open(bool quiet)
lump_p->LumpNameSetup(name);
lump_p->LumpSize = static_cast<int>(SzArEx_GetFileSize(archPtr, i));
lump_p->Owner = this;
lump_p->Flags = LUMPF_ZIPFILE;
lump_p->Flags = LUMPF_ZIPFILE|LUMPF_COMPRESSED;
lump_p->Position = i;
lump_p->CheckEmbedded();
lump_p++;
@ -361,21 +361,21 @@ int F7ZLump::FillCache()
//
//==========================================================================
FResourceFile *Check7Z(const char *filename, FileReader *file, bool quiet)
FResourceFile *Check7Z(const char *filename, FileRdr &file, bool quiet)
{
char head[k7zSignatureSize];
if (file->GetLength() >= k7zSignatureSize)
if (file.GetLength() >= k7zSignatureSize)
{
file->Seek(0, SEEK_SET);
file->Read(&head, k7zSignatureSize);
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
file.Read(&head, k7zSignatureSize);
file.Seek(0, FileRdr::SeekSet);
if (!memcmp(head, k7zSignature, k7zSignatureSize))
{
FResourceFile *rf = new F7ZFile(filename, file);
if (rf->Open(quiet)) return rf;
rf->Reader = NULL; // to avoid destruction of reader
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
}
}

26
src/resourcefiles/file_directory.cpp
View file

@ -55,7 +55,7 @@
struct FDirectoryLump : public FResourceLump
{
virtual FileReader *NewReader();
virtual FileRdr NewReader();
virtual int FillCache();
FString mFullPath;
@ -90,7 +90,7 @@ public:
//==========================================================================
FDirectory::FDirectory(const char * directory)
: FResourceFile(NULL, NULL)
: FResourceFile(NULL, FileRdr())
{
FString dirname;
@ -287,16 +287,11 @@ void FDirectory::AddEntry(const char *fullpath, int size)
//
//==========================================================================
FileReader *FDirectoryLump::NewReader()
FileRdr FDirectoryLump::NewReader()
{
try
{
return new FileReader(mFullPath);
}
catch (CRecoverableError &)
{
return NULL;
}
FileRdr fr;
fr.OpenFile(mFullPath);
return fr;
}
//==========================================================================
@ -307,15 +302,14 @@ FileReader *FDirectoryLump::NewReader()
int FDirectoryLump::FillCache()
{
FileRdr fr;
Cache = new char[LumpSize];
FileReader *reader = NewReader();
if (reader == NULL)
if (!fr.OpenFile(mFullPath))
{
memset(Cache, 0, LumpSize);
return 0;
}
reader->Read(Cache, LumpSize);
delete reader;
fr.Read(Cache, LumpSize);
RefCount = 1;
return 1;
}
@ -326,7 +320,7 @@ int FDirectoryLump::FillCache()
//
//==========================================================================
FResourceFile *CheckDir(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckDir(const char *filename, bool quiet)
{
FResourceFile *rf = new FDirectory(filename);
if (rf->Open(quiet)) return rf;

20
src/resourcefiles/file_grp.cpp
View file

@ -73,7 +73,7 @@ struct GrpLump
class FGrpFile : public FUncompressedFile
{
public:
FGrpFile(const char * filename, FileReader *file);
FGrpFile(const char * filename, FileRdr &file);
bool Open(bool quiet);
};
@ -84,7 +84,7 @@ public:
//
//==========================================================================
FGrpFile::FGrpFile(const char *filename, FileReader *file)
FGrpFile::FGrpFile(const char *filename, FileRdr &file)
: FUncompressedFile(filename, file)
{
Lumps = NULL;
@ -100,11 +100,11 @@ bool FGrpFile::Open(bool quiet)
{
GrpInfo header;
Reader->Read(&header, sizeof(header));
Reader.Read(&header, sizeof(header));
NumLumps = LittleLong(header.NumLumps);
GrpLump *fileinfo = new GrpLump[NumLumps];
Reader->Read (fileinfo, NumLumps * sizeof(GrpLump));
Reader.Read (fileinfo, NumLumps * sizeof(GrpLump));
Lumps = new FUncompressedLump[NumLumps];
@ -134,21 +134,21 @@ bool FGrpFile::Open(bool quiet)
//
//==========================================================================
FResourceFile *CheckGRP(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckGRP(const char *filename, FileRdr &file, bool quiet)
{
char head[12];
if (file->GetLength() >= 12)
if (file.GetLength() >= 12)
{
file->Seek(0, SEEK_SET);
file->Read(&head, 12);
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
file.Read(&head, 12);
file.Seek(0, FileRdr::SeekSet);
if (!memcmp(head, "KenSilverman", 12))
{
FResourceFile *rf = new FGrpFile(filename, file);
if (rf->Open(quiet)) return rf;
rf->Reader = NULL; // to avoid destruction of reader
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
}
}

10
src/resourcefiles/file_lump.cpp
View file

@ -46,7 +46,7 @@
class FLumpFile : public FUncompressedFile
{
public:
FLumpFile(const char * filename, FileReader *file);
FLumpFile(const char * filename, FileRdr &file);
bool Open(bool quiet);
};
@ -57,7 +57,8 @@ public:
//
//==========================================================================
FLumpFile::FLumpFile(const char *filename, FileReader *file) : FUncompressedFile(filename, file)
FLumpFile::FLumpFile(const char *filename, FileRdr &file)
: FUncompressedFile(filename, file)
{
}
@ -76,7 +77,7 @@ bool FLumpFile::Open(bool quiet)
Lumps->Name[8] = 0;
Lumps->Owner = this;
Lumps->Position = 0;
Lumps->LumpSize = Reader->GetLength();
Lumps->LumpSize = (int)Reader.GetLength();
Lumps->Namespace = ns_global;
Lumps->Flags = 0;
Lumps->FullName = NULL;
@ -94,11 +95,12 @@ bool FLumpFile::Open(bool quiet)
//
//==========================================================================
FResourceFile *CheckLump(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckLump(const char *filename, FileRdr &file, bool quiet)
{
// always succeeds
FResourceFile *rf = new FLumpFile(filename, file);
if (rf->Open(quiet)) return rf;
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
return NULL;
}

23
src/resourcefiles/file_pak.cpp
View file

@ -66,7 +66,7 @@ struct dpackheader_t
class FPakFile : public FUncompressedFile
{
public:
FPakFile(const char * filename, FileReader *file);
FPakFile(const char * filename, FileRdr &file);
bool Open(bool quiet);
};
@ -79,7 +79,8 @@ public:
//
//==========================================================================
FPakFile::FPakFile(const char *filename, FileReader *file) : FUncompressedFile(filename, file)
FPakFile::FPakFile(const char *filename, FileRdr &file)
: FUncompressedFile(filename, file)
{
Lumps = NULL;
}
@ -94,13 +95,13 @@ bool FPakFile::Open(bool quiet)
{
dpackheader_t header;
Reader->Read(&header, sizeof(header));
Reader.Read(&header, sizeof(header));
NumLumps = LittleLong(header.dirlen) / sizeof(dpackfile_t);
header.dirofs = LittleLong(header.dirofs);
dpackfile_t *fileinfo = new dpackfile_t[NumLumps];
Reader->Seek (header.dirofs, SEEK_SET);
Reader->Read (fileinfo, NumLumps * sizeof(dpackfile_t));
Reader.Seek (header.dirofs, FileRdr::SeekSet);
Reader.Read (fileinfo, NumLumps * sizeof(dpackfile_t));
Lumps = new FUncompressedLump[NumLumps];
@ -126,21 +127,21 @@ bool FPakFile::Open(bool quiet)
//
//==========================================================================
FResourceFile *CheckPak(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckPak(const char *filename, FileRdr &file, bool quiet)
{
char head[4];
if (file->GetLength() >= 12)
if (file.GetLength() >= 12)
{
file->Seek(0, SEEK_SET);
file->Read(&head, 4);
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
file.Read(&head, 4);
file.Seek(0, FileRdr::SeekSet);
if (!memcmp(head, "PACK", 4))
{
FResourceFile *rf = new FPakFile(filename, file);
if (rf->Open(quiet)) return rf;
rf->Reader = NULL; // to avoid destruction of reader
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
}
}

26
src/resourcefiles/file_rff.cpp
View file

@ -75,7 +75,7 @@ struct RFFLump
struct FRFFLump : public FUncompressedLump
{
virtual FileReader *GetReader();
virtual FileRdr *GetReader();
virtual int FillCache();
uint32_t IndexNum;
@ -111,7 +111,7 @@ class FRFFFile : public FResourceFile
FRFFLump *Lumps;
public:
FRFFFile(const char * filename, FileReader *file);
FRFFFile(const char * filename, FileRdr &file);
virtual ~FRFFFile();
virtual bool Open(bool quiet);
virtual FResourceLump *GetLump(int no) { return ((unsigned)no < NumLumps)? &Lumps[no] : NULL; }
@ -124,7 +124,7 @@ public:
//
//==========================================================================
FRFFFile::FRFFFile(const char *filename, FileReader *file)
FRFFFile::FRFFFile(const char *filename, FileRdr &file)
: FResourceFile(filename, file)
{
Lumps = NULL;
@ -141,13 +141,13 @@ bool FRFFFile::Open(bool quiet)
RFFLump *lumps;
RFFInfo header;
Reader->Read(&header, sizeof(header));
Reader.Read(&header, sizeof(header));
NumLumps = LittleLong(header.NumLumps);
header.DirOfs = LittleLong(header.DirOfs);
lumps = new RFFLump[header.NumLumps];
Reader->Seek (header.DirOfs, SEEK_SET);
Reader->Read (lumps, header.NumLumps * sizeof(RFFLump));
Reader.Seek (header.DirOfs, FileRdr::SeekSet);
Reader.Read (lumps, header.NumLumps * sizeof(RFFLump));
BloodCrypt (lumps, header.DirOfs, header.NumLumps * sizeof(RFFLump));
Lumps = new FRFFLump[NumLumps];
@ -203,7 +203,7 @@ FRFFFile::~FRFFFile()
//
//==========================================================================
FileReader *FRFFLump::GetReader()
FileRdr *FRFFLump::GetReader()
{
// Don't return the reader if this lump is encrypted
// In that case always force caching of the lump
@ -247,21 +247,21 @@ int FRFFLump::FillCache()
//
//==========================================================================
FResourceFile *CheckRFF(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckRFF(const char *filename, FileRdr &file, bool quiet)
{
char head[4];
if (file->GetLength() >= 16)
if (file.GetLength() >= 16)
{
file->Seek(0, SEEK_SET);
file->Read(&head, 4);
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
file.Read(&head, 4);
file.Seek(0, FileRdr::SeekSet);
if (!memcmp(head, "RFF\x1a", 4))
{
FResourceFile *rf = new FRFFFile(filename, file);
if (rf->Open(quiet)) return rf;
rf->Reader = NULL; // to avoid destruction of reader
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
}
}

232
src/resourcefiles/file_wad.cpp
View file

@ -40,191 +40,7 @@
#include "w_wad.h"
#include "gi.h"
#include "i_system.h"
// Console Doom LZSS wrapper.
class FileReaderLZSS : public FileReaderBase
{
private:
enum { BUFF_SIZE = 4096, WINDOW_SIZE = 4096, INTERNAL_BUFFER_SIZE = 128 };
FileReader &File;
bool SawEOF;
uint8_t InBuff[BUFF_SIZE];
enum StreamState
{
STREAM_EMPTY,
STREAM_BITS,
STREAM_FLUSH,
STREAM_FINAL
};
struct
{
StreamState State;
uint8_t *In;
unsigned int AvailIn;
unsigned int InternalOut;
uint8_t CFlags, Bits;
uint8_t Window[WINDOW_SIZE+INTERNAL_BUFFER_SIZE];
const uint8_t *WindowData;
uint8_t *InternalBuffer;
} Stream;
void FillBuffer()
{
if(Stream.AvailIn)
memmove(InBuff, Stream.In, Stream.AvailIn);
long numread = File.Read(InBuff+Stream.AvailIn, BUFF_SIZE-Stream.AvailIn);
if (numread < BUFF_SIZE)
{
SawEOF = true;
}
Stream.In = InBuff;
Stream.AvailIn = numread+Stream.AvailIn;
}
// Reads a flag byte.
void PrepareBlocks()
{
assert(Stream.InternalBuffer == Stream.WindowData);
Stream.CFlags = *Stream.In++;
--Stream.AvailIn;
Stream.Bits = 0xFF;
Stream.State = STREAM_BITS;
}
// Reads the next chunk in the block. Returns true if successful and
// returns false if it ran out of input data.
bool UncompressBlock()
{
if(Stream.CFlags & 1)
{
// Check to see if we have enough input
if(Stream.AvailIn < 2)
return false;
Stream.AvailIn -= 2;
uint16_t pos = BigShort(*(uint16_t*)Stream.In);
uint8_t len = (pos & 0xF)+1;
pos >>= 4;
Stream.In += 2;
if(len == 1)
{
// We've reached the end of the stream.
Stream.State = STREAM_FINAL;
return true;
}
const uint8_t* copyStart = Stream.InternalBuffer-pos-1;
// Complete overlap: Single byte repeated
if(pos == 0)
memset(Stream.InternalBuffer, *copyStart, len);
// No overlap: One copy
else if(pos >= len)
memcpy(Stream.InternalBuffer, copyStart, len);
else
{
// Partial overlap: Copy in 2 or 3 chunks.
do
{
unsigned int copy = MIN<unsigned int>(len, pos+1);
memcpy(Stream.InternalBuffer, copyStart, copy);
Stream.InternalBuffer += copy;
Stream.InternalOut += copy;
len -= copy;
pos += copy; // Increase our position since we can copy twice as much the next round.
}
while(len);
}
Stream.InternalOut += len;
Stream.InternalBuffer += len;
}
else
{
// Uncompressed byte.
*Stream.InternalBuffer++ = *Stream.In++;
--Stream.AvailIn;
++Stream.InternalOut;
}
Stream.CFlags >>= 1;
Stream.Bits >>= 1;
// If we're done with this block, flush the output
if(Stream.Bits == 0)
Stream.State = STREAM_FLUSH;
return true;
}
public:
FileReaderLZSS(FileReader &file) : File(file), SawEOF(false)
{
Stream.State = STREAM_EMPTY;
Stream.WindowData = Stream.InternalBuffer = Stream.Window+WINDOW_SIZE;
Stream.InternalOut = 0;
Stream.AvailIn = 0;
FillBuffer();
}
~FileReaderLZSS()
{
}
long Read(void *buffer, long len)
{
uint8_t *Out = (uint8_t*)buffer;
long AvailOut = len;
do
{
while(Stream.AvailIn)
{
if(Stream.State == STREAM_EMPTY)
PrepareBlocks();
else if(Stream.State == STREAM_BITS && !UncompressBlock())
break;
else
break;
}
unsigned int copy = MIN<unsigned int>(Stream.InternalOut, AvailOut);
if(copy > 0)
{
memcpy(Out, Stream.WindowData, copy);
Out += copy;
AvailOut -= copy;
// Slide our window
memmove(Stream.Window, Stream.Window+copy, WINDOW_SIZE+INTERNAL_BUFFER_SIZE-copy);
Stream.InternalBuffer -= copy;
Stream.InternalOut -= copy;
}
if(Stream.State == STREAM_FINAL)
break;
if(Stream.InternalOut == 0 && Stream.State == STREAM_FLUSH)
Stream.State = STREAM_EMPTY;
if(Stream.AvailIn < 2)
FillBuffer();
}
while(AvailOut && Stream.State != STREAM_FINAL);
assert(AvailOut == 0);
return (long)(Out - (uint8_t*)buffer);
}
};
#include "w_zip.h"
//==========================================================================
//
@ -239,12 +55,12 @@ public:
int Position;
int GetFileOffset() { return Position; }
FileReader *GetReader()
FileRdr *GetReader()
{
if(!Compressed)
{
Owner->Reader->Seek(Position, SEEK_SET);
return Owner->Reader;
Owner->Reader.Seek(Position, FileRdr::SeekSet);
return &Owner->Reader;
}
return NULL;
}
@ -252,7 +68,7 @@ public:
{
if(!Compressed)
{
const char * buffer = Owner->Reader->GetBuffer();
const char * buffer = Owner->Reader.GetBuffer();
if (buffer != NULL)
{
@ -263,16 +79,19 @@ public:
}
}
Owner->Reader->Seek(Position, SEEK_SET);
Owner->Reader.Seek(Position, FileRdr::SeekSet);
Cache = new char[LumpSize];
if(Compressed)
{
FileReaderLZSS lzss(*Owner->Reader);
lzss.Read(Cache, LumpSize);
FileRdr lzss;
if (lzss.OpenDecompressor(Owner->Reader, LumpSize, METHOD_LZSS, false))
{
lzss.Read(Cache, LumpSize);
}
}
else
Owner->Reader->Read(Cache, LumpSize);
Owner->Reader.Read(Cache, LumpSize);
RefCount = 1;
return 1;
@ -294,7 +113,7 @@ class FWadFile : public FResourceFile
void SkinHack ();
public:
FWadFile(const char * filename, FileReader *file);
FWadFile(const char * filename, FileRdr &file);
~FWadFile();
void FindStrifeTeaserVoices ();
FResourceLump *GetLump(int lump) { return &Lumps[lump]; }
@ -310,7 +129,8 @@ public:
//
//==========================================================================
FWadFile::FWadFile(const char *filename, FileReader *file) : FResourceFile(filename, file)
FWadFile::FWadFile(const char *filename, FileRdr &file)
: FResourceFile(filename, file)
{
Lumps = NULL;
}
@ -331,9 +151,9 @@ bool FWadFile::Open(bool quiet)
wadinfo_t header;
uint32_t InfoTableOfs;
bool isBigEndian = false; // Little endian is assumed until proven otherwise
const long wadSize = Reader->GetLength();
auto wadSize = Reader.GetLength();
Reader->Read(&header, sizeof(header));
Reader.Read(&header, sizeof(header));
NumLumps = LittleLong(header.NumLumps);
InfoTableOfs = LittleLong(header.InfoTableOfs);
@ -353,8 +173,8 @@ bool FWadFile::Open(bool quiet)
}
wadlump_t *fileinfo = new wadlump_t[NumLumps];
Reader->Seek (InfoTableOfs, SEEK_SET);
Reader->Read (fileinfo, NumLumps * sizeof(wadlump_t));
Reader.Seek (InfoTableOfs, FileRdr::SeekSet);
Reader.Read (fileinfo, NumLumps * sizeof(wadlump_t));
Lumps = new FWadFileLump[NumLumps];
@ -369,7 +189,7 @@ bool FWadFile::Open(bool quiet)
Lumps[i].Position = isBigEndian ? BigLong(fileinfo[i].FilePos) : LittleLong(fileinfo[i].FilePos);
Lumps[i].LumpSize = isBigEndian ? BigLong(fileinfo[i].Size) : LittleLong(fileinfo[i].Size);
Lumps[i].Namespace = ns_global;
Lumps[i].Flags = 0;
Lumps[i].Flags = Lumps[i].Compressed? LUMPF_COMPRESSED : 0;
Lumps[i].FullName = NULL;
}
@ -655,21 +475,21 @@ void FWadFile::FindStrifeTeaserVoices ()
//
//==========================================================================
FResourceFile *CheckWad(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckWad(const char *filename, FileRdr &file, bool quiet)
{
char head[4];
if (file->GetLength() >= 12)
if (file.GetLength() >= 12)
{
file->Seek(0, SEEK_SET);
file->Read(&head, 4);
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
file.Read(&head, 4);
file.Seek(0, FileRdr::SeekSet);
if (!memcmp(head, "IWAD", 4) || !memcmp(head, "PWAD", 4))
{
FResourceFile *rf = new FWadFile(filename, file);
if (rf->Open(quiet)) return rf;
rf->Reader = NULL; // to avoid destruction of reader
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
}
}

82
src/resourcefiles/file_zip.cpp
View file

@ -51,7 +51,7 @@
//
//==========================================================================
static bool UncompressZipLump(char *Cache, FileReader *Reader, int Method, int LumpSize, int CompressedSize, int GPFlags)
static bool UncompressZipLump(char *Cache, FileRdr &Reader, int Method, int LumpSize, int CompressedSize, int GPFlags)
{
try
{
@ -59,31 +59,23 @@ static bool UncompressZipLump(char *Cache, FileReader *Reader, int Method, int L
{
case METHOD_STORED:
{
Reader->Read(Cache, LumpSize);
Reader.Read(Cache, LumpSize);
break;
}
case METHOD_DEFLATE:
{
FileReaderZ frz(*Reader, true);
frz.Read(Cache, LumpSize);
break;
}
case METHOD_BZIP2:
{
FileReaderBZ2 frz(*Reader);
frz.Read(Cache, LumpSize);
break;
}
case METHOD_LZMA:
{
FileReaderLZMA frz(*Reader, LumpSize, true);
frz.Read(Cache, LumpSize);
FileRdr frz;
if (frz.OpenDecompressor(Reader, LumpSize, Method, false))
{
frz.Read(Cache, LumpSize);
}
break;
}
// Fixme: These should also use a stream
case METHOD_IMPLODE:
{
FZipExploder exploder;
@ -112,8 +104,9 @@ static bool UncompressZipLump(char *Cache, FileReader *Reader, int Method, int L
bool FCompressedBuffer::Decompress(char *destbuffer)
{
MemoryReader mr(mBuffer, mCompressedSize);
return UncompressZipLump(destbuffer, &mr, mMethod, mSize, mCompressedSize, mZipFlags);
FileRdr mr;
mr.OpenMemory(mBuffer, mCompressedSize);
return UncompressZipLump(destbuffer, mr, mMethod, mSize, mCompressedSize, mZipFlags);
}
//-----------------------------------------------------------------------
@ -123,7 +116,7 @@ bool FCompressedBuffer::Decompress(char *destbuffer)
//
//-----------------------------------------------------------------------
static uint32_t Zip_FindCentralDir(FileReader * fin)
static uint32_t Zip_FindCentralDir(FileRdr &fin)
{
unsigned char buf[BUFREADCOMMENT + 4];
uint32_t FileSize;
@ -131,9 +124,9 @@ static uint32_t Zip_FindCentralDir(FileReader * fin)
uint32_t uMaxBack; // maximum size of global comment
uint32_t uPosFound=0;
fin->Seek(0, SEEK_END);
fin.Seek(0, FileRdr::SeekEnd);
FileSize = fin->Tell();
FileSize = (uint32_t)fin.Tell();
uMaxBack = MIN<uint32_t>(0xffff, FileSize);
uBackRead = 4;
@ -149,9 +142,9 @@ static uint32_t Zip_FindCentralDir(FileReader * fin)
uReadSize = MIN<uint32_t>((BUFREADCOMMENT + 4), (FileSize - uReadPos));
if (fin->Seek(uReadPos, SEEK_SET) != 0) break;
if (fin.Seek(uReadPos, FileRdr::SeekSet) != 0) break;
if (fin->Read(buf, (int32_t)uReadSize) != (int32_t)uReadSize) break;
if (fin.Read(buf, (int32_t)uReadSize) != (int32_t)uReadSize) break;
for (i = (int)uReadSize - 3; (i--) > 0;)
{
@ -174,7 +167,7 @@ static uint32_t Zip_FindCentralDir(FileReader * fin)
//
//==========================================================================
FZipFile::FZipFile(const char * filename, FileReader *file)
FZipFile::FZipFile(const char * filename, FileRdr &file)
: FResourceFile(filename, file)
{
Lumps = NULL;
@ -195,8 +188,8 @@ bool FZipFile::Open(bool quiet)
}
// Read the central directory info.
Reader->Seek(centraldir, SEEK_SET);
Reader->Read(&info, sizeof(FZipEndOfCentralDirectory));
Reader.Seek(centraldir, FileRdr::SeekSet);
Reader.Read(&info, sizeof(FZipEndOfCentralDirectory));
// No multi-disk zips!
if (info.NumEntries != info.NumEntriesOnAllDisks ||
@ -212,8 +205,8 @@ bool FZipFile::Open(bool quiet)
// Load the entire central directory. Too bad that this contains variable length entries...
int dirsize = LittleLong(info.DirectorySize);
void *directory = malloc(dirsize);
Reader->Seek(LittleLong(info.DirectoryOffset), SEEK_SET);
Reader->Read(directory, dirsize);
Reader.Seek(LittleLong(info.DirectoryOffset), FileRdr::SeekSet);
Reader.Read(directory, dirsize);
char *dirptr = (char*)directory;
FZipLump *lump_p = Lumps;
@ -349,6 +342,7 @@ bool FZipFile::Open(bool quiet)
// The start of the Reader will be determined the first time it is accessed.
lump_p->Flags = LUMPF_ZIPFILE | LUMPFZIP_NEEDFILESTART;
lump_p->Method = uint8_t(zip_fh->Method);
if (lump_p->Method != METHOD_STORED) lump_p->Flags |= LUMPF_COMPRESSED;
lump_p->GPFlags = zip_fh->Flags;
lump_p->CRC32 = zip_fh->CRC32;
lump_p->CompressedSize = LittleLong(zip_fh->CompressedSize);
@ -394,8 +388,8 @@ FCompressedBuffer FZipLump::GetRawData()
{
FCompressedBuffer cbuf = { (unsigned)LumpSize, (unsigned)CompressedSize, Method, GPFlags, CRC32, new char[CompressedSize] };
if (Flags & LUMPFZIP_NEEDFILESTART) SetLumpAddress();
Owner->Reader->Seek(Position, SEEK_SET);
Owner->Reader->Read(cbuf.mBuffer, CompressedSize);
Owner->Reader.Seek(Position, FileRdr::SeekSet);
Owner->Reader.Read(cbuf.mBuffer, CompressedSize);
return cbuf;
}
@ -413,10 +407,8 @@ void FZipLump::SetLumpAddress()
FZipLocalFileHeader localHeader;
int skiplen;
FileReader *file = Owner->Reader;
file->Seek(Position, SEEK_SET);
file->Read(&localHeader, sizeof(localHeader));
Owner->Reader.Seek(Position, FileRdr::SeekSet);
Owner->Reader.Read(&localHeader, sizeof(localHeader));
skiplen = LittleShort(localHeader.NameLength) + LittleShort(localHeader.ExtraLength);
Position += sizeof(localHeader) + skiplen;
Flags &= ~LUMPFZIP_NEEDFILESTART;
@ -428,15 +420,15 @@ void FZipLump::SetLumpAddress()
//
//==========================================================================
FileReader *FZipLump::GetReader()
FileRdr *FZipLump::GetReader()
{
// Don't return the reader if this lump is encrypted
// In that case always force caching of the lump
if (Method == METHOD_STORED)
{
if (Flags & LUMPFZIP_NEEDFILESTART) SetLumpAddress();
Owner->Reader->Seek(Position, SEEK_SET);
return Owner->Reader;
Owner->Reader.Seek(Position, FileRdr::SeekSet);
return &Owner->Reader;
}
else return NULL;
}
@ -452,7 +444,7 @@ int FZipLump::FillCache()
if (Flags & LUMPFZIP_NEEDFILESTART) SetLumpAddress();
const char *buffer;
if (Method == METHOD_STORED && (buffer = Owner->Reader->GetBuffer()) != NULL)
if (Method == METHOD_STORED && (buffer = Owner->Reader.GetBuffer()) != NULL)
{
// This is an in-memory file so the cache can point directly to the file's data.
Cache = const_cast<char*>(buffer) + Position;
@ -460,7 +452,7 @@ int FZipLump::FillCache()
return -1;
}
Owner->Reader->Seek(Position, SEEK_SET);
Owner->Reader.Seek(Position, FileRdr::SeekSet);
Cache = new char[LumpSize];
UncompressZipLump(Cache, Owner->Reader, Method, LumpSize, CompressedSize, GPFlags);
RefCount = 1;
@ -486,21 +478,21 @@ int FZipLump::GetFileOffset()
//
//==========================================================================
FResourceFile *CheckZip(const char *filename, FileReader *file, bool quiet)
FResourceFile *CheckZip(const char *filename, FileRdr &file, bool quiet)
{
char head[4];
if (file->GetLength() >= (long)sizeof(FZipLocalFileHeader))
if (file.GetLength() >= (long)sizeof(FZipLocalFileHeader))
{
file->Seek(0, SEEK_SET);
file->Read(&head, 4);
file->Seek(0, SEEK_SET);
file.Seek(0, FileRdr::SeekSet);
file.Read(&head, 4);
file.Seek(0, FileRdr::SeekSet);
if (!memcmp(head, "PK\x3\x4", 4))
{
FResourceFile *rf = new FZipFile(filename, file);
if (rf->Open(quiet)) return rf;
rf->Reader = NULL; // to avoid destruction of reader
file = std::move(rf->Reader); // to avoid destruction of reader
delete rf;
}
}

4
src/resourcefiles/file_zip.h
View file

@ -22,7 +22,7 @@ struct FZipLump : public FResourceLump
int Position;
unsigned CRC32;
virtual FileReader *GetReader();
virtual FileRdr *GetReader();
virtual int FillCache();
private:
@ -43,7 +43,7 @@ class FZipFile : public FResourceFile
FZipLump *Lumps;
public:
FZipFile(const char * filename, FileReader *file);
FZipFile(const char * filename, FileRdr &file);
virtual ~FZipFile();
bool Open(bool quiet);
virtual FResourceLump *GetLump(int no) { return ((unsigned)no < NumLumps)? &Lumps[no] : NULL; }

90
src/resourcefiles/resourcefile.cpp
View file

@ -45,7 +45,7 @@
//==========================================================================
//
// FileReader that reads from a lump's cache
// File reader that reads from a lump's cache
//
//==========================================================================
@ -212,11 +212,11 @@ FCompressedBuffer FResourceLump::GetRawData()
//==========================================================================
//
// Returns the owner's FileReader if it can be used to access this lump
// Returns the owner's FileRdr if it can be used to access this lump
//
//==========================================================================
FileReader *FResourceLump::GetReader()
FileRdr *FResourceLump::GetReader()
{
return NULL;
}
@ -227,9 +227,9 @@ FileReader *FResourceLump::GetReader()
//
//==========================================================================
FileReader *FResourceLump::NewReader()
FileRdr FResourceLump::NewReader()
{
return new FLumpReader(this);
return FileRdr(new FLumpReader(this));
}
//==========================================================================
@ -276,46 +276,45 @@ int FResourceLump::ReleaseCache()
//
//==========================================================================
typedef FResourceFile * (*CheckFunc)(const char *filename, FileReader *file, bool quiet);
typedef FResourceFile * (*CheckFunc)(const char *filename, FileRdr &file, bool quiet);
FResourceFile *CheckWad(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckGRP(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckRFF(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckPak(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckZip(const char *filename, FileReader *file, bool quiet);
FResourceFile *Check7Z(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckLump(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckDir(const char *filename, FileReader *file, bool quiet);
FResourceFile *CheckWad(const char *filename, FileRdr &file, bool quiet);
FResourceFile *CheckGRP(const char *filename, FileRdr &file, bool quiet);
FResourceFile *CheckRFF(const char *filename, FileRdr &file, bool quiet);
FResourceFile *CheckPak(const char *filename, FileRdr &file, bool quiet);
FResourceFile *CheckZip(const char *filename, FileRdr &file, bool quiet);
FResourceFile *Check7Z(const char *filename, FileRdr &file, bool quiet);
FResourceFile *CheckLump(const char *filename,FileRdr &file, bool quiet);
FResourceFile *CheckDir(const char *filename, bool quiet);
static CheckFunc funcs[] = { CheckWad, CheckZip, Check7Z, CheckPak, CheckGRP, CheckRFF, CheckLump };
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, FileReader *file, bool quiet, bool containeronly)
FResourceFile *FResourceFile::DoOpenResourceFile(const char *filename, FileRdr &file, bool quiet, bool containeronly)
{
bool mustclose = false;
if (file == NULL)
{
try
{
file = new FileReader(filename);
mustclose = true;
}
catch (CRecoverableError &)
{
return NULL;
}
}
for(size_t i = 0; i < countof(funcs) - containeronly; i++)
{
FResourceFile *resfile = funcs[i](filename, file, quiet);
if (resfile != NULL) return resfile;
}
if (mustclose) delete file;
return NULL;
}
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, FileRdr &file, bool quiet, bool containeronly)
{
return DoOpenResourceFile(filename, file, quiet, containeronly);
}
FResourceFile *FResourceFile::OpenResourceFile(const char *filename, bool quiet, bool containeronly)
{
FileRdr file;
if (!file.OpenFile(filename)) return nullptr;
return DoOpenResourceFile(filename, file, quiet, containeronly);
}
FResourceFile *FResourceFile::OpenDirectory(const char *filename, bool quiet)
{
return CheckDir(filename, NULL, quiet);
return CheckDir(filename, quiet);
}
//==========================================================================
@ -324,18 +323,17 @@ FResourceFile *FResourceFile::OpenDirectory(const char *filename, bool quiet)
//
//==========================================================================
FResourceFile::FResourceFile(const char *filename, FileReader *r)
FResourceFile::FResourceFile(const char *filename, FileRdr &r)
{
if (filename != NULL) Filename = copystring(filename);
else Filename = NULL;
Reader = r;
Reader = std::move(r);
}
FResourceFile::~FResourceFile()
{
if (Filename != NULL) delete [] Filename;
delete Reader;
}
int lumpcmp(const void * a, const void * b)
@ -607,10 +605,10 @@ FResourceLump *FResourceFile::FindLump(const char *name)
//
//==========================================================================
FileReader *FUncompressedLump::GetReader()
FileRdr *FUncompressedLump::GetReader()
{
Owner->Reader->Seek(Position, SEEK_SET);
return Owner->Reader;
Owner->Reader.Seek(Position, FileRdr::SeekSet);
return &Owner->Reader;
}
//==========================================================================
@ -621,7 +619,7 @@ FileReader *FUncompressedLump::GetReader()
int FUncompressedLump::FillCache()
{
const char * buffer = Owner->Reader->GetBuffer();
const char * buffer = Owner->Reader.GetBuffer();
if (buffer != NULL)
{
@ -631,9 +629,9 @@ int FUncompressedLump::FillCache()
return -1;
}
Owner->Reader->Seek(Position, SEEK_SET);
Owner->Reader.Seek(Position, FileRdr::SeekSet);
Cache = new char[LumpSize];
Owner->Reader->Read(Cache, LumpSize);
Owner->Reader.Read(Cache, LumpSize);
RefCount = 1;
return 1;
}
@ -644,7 +642,7 @@ int FUncompressedLump::FillCache()
//
//==========================================================================
FUncompressedFile::FUncompressedFile(const char *filename, FileReader *r)
FUncompressedFile::FUncompressedFile(const char *filename, FileRdr &r)
: FResourceFile(filename, r)
{
Lumps = NULL;
@ -669,11 +667,11 @@ FExternalLump::FExternalLump(const char *_filename, int filesize)
if (filesize == -1)
{
FileReader f;
FileRdr f;
if (f.Open(_filename))
if (f.OpenFile(_filename))
{
LumpSize = f.GetLength();
LumpSize = (int)f.GetLength();
}
else
{
@ -702,9 +700,9 @@ FExternalLump::~FExternalLump()
int FExternalLump::FillCache()
{
Cache = new char[LumpSize];
FileReader f;
FileRdr f;
if (f.Open(filename))
if (f.OpenFile(filename))
{
f.Read(Cache, LumpSize);
}
@ -728,7 +726,7 @@ bool FMemoryFile::Open(bool quiet)
Lumps->FullName = fname;
Lumps->Owner = this;
Lumps->Position = 0;
Lumps->LumpSize = Reader->GetLength();
Lumps->LumpSize = (int)Reader.GetLength();
Lumps->Namespace = ns_global;
Lumps->Flags = 0;
Lumps->FullName = NULL;

24
src/resourcefiles/resourcefile.h
View file

@ -62,8 +62,8 @@ struct FResourceLump
}
virtual ~FResourceLump();
virtual FileReader *GetReader();
virtual FileReader *NewReader();
virtual FileRdr *GetReader();
virtual FileRdr NewReader();
virtual int GetFileOffset() { return -1; }
virtual int GetIndexNum() const { return 0; }
void LumpNameSetup(FString iname);
@ -81,12 +81,12 @@ protected:
class FResourceFile
{
public:
FileReader *Reader;
FileRdr Reader;
const char *Filename;
protected:
uint32_t NumLumps;
FResourceFile(const char *filename, FileReader *r);
FResourceFile(const char *filename, FileRdr &r);
// for archives that can contain directories
void PostProcessArchive(void *lumps, size_t lumpsize);
@ -98,12 +98,14 @@ private:
int FilterLumpsByGameType(int gametype, void *lumps, size_t lumpsize, uint32_t max);
bool FindPrefixRange(FString filter, void *lumps, size_t lumpsize, uint32_t max, uint32_t &start, uint32_t &end);
void JunkLeftoverFilters(void *lumps, size_t lumpsize, uint32_t max);
static FResourceFile *DoOpenResourceFile(const char *filename, FileRdr &file, bool quiet, bool containeronly);
public:
static FResourceFile *OpenResourceFile(const char *filename, FileReader *file, bool quiet = false, bool containeronly = false);
static FResourceFile *OpenResourceFile(const char *filename, FileRdr &file, bool quiet = false, bool containeronly = false);
static FResourceFile *OpenResourceFile(const char *filename, bool quiet = false, bool containeronly = false);
static FResourceFile *OpenDirectory(const char *filename, bool quiet = false);
virtual ~FResourceFile();
FileReader *GetReader() const { return Reader; }
FileRdr *GetReader() { return &Reader; }
uint32_t LumpCount() const { return NumLumps; }
uint32_t GetFirstLump() const { return FirstLump; }
void SetFirstLump(uint32_t f) { FirstLump = f; }
@ -118,7 +120,7 @@ struct FUncompressedLump : public FResourceLump
{
int Position;
virtual FileReader *GetReader();
virtual FileRdr *GetReader();
virtual int FillCache();
virtual int GetFileOffset() { return Position; }
@ -132,7 +134,7 @@ protected:
FUncompressedLump * Lumps;
FUncompressedFile(const char *filename, FileReader *r);
FUncompressedFile(const char *filename, FileRdr &r);
virtual ~FUncompressedFile();
virtual FResourceLump *GetLump(int no) { return ((unsigned)no < NumLumps)? &Lumps[no] : NULL; }
@ -152,12 +154,10 @@ struct FExternalLump : public FResourceLump
struct FMemoryFile : public FUncompressedFile
{
MemoryArrayReader mr;
FMemoryFile(const char *_filename, const void *sdata, int length)
: FUncompressedFile(_filename, nullptr), mr((const char *)sdata, length)
: FUncompressedFile(_filename, FileRdr())
{
Reader = &mr;
Reader.OpenMemoryArray(sdata, length);
}
bool Open(bool quiet);