This commit is contained in:
Daveo
parent
f8194ab3b1
commit
e9f123dec7
53
source/fileio/cdfile.cpp
Normal file
53
source/fileio/cdfile.cpp
Normal file
@ -0,0 +1,53 @@
|
||||
/***********************************/
|
||||
/*** PSX CD BigLump FileIO Stuff ***/
|
||||
/***********************************/
|
||||
|
||||
#include "system\global.h"
|
||||
#include "fileio\fileio.h"
|
||||
#include "fileio\cdfile.h"
|
||||
#include <libcd.h>
|
||||
#include "system\vid.h"
|
||||
#include "sound\cdxa.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
CCDFileIO::CCDFileIO(u32 FilePos,sBigLump *BigLumpPtr)
|
||||
{
|
||||
DbgMsg0("CD FILE SYSTEM\n");
|
||||
while (!CdInit());
|
||||
|
||||
#if !defined(__USER_CDBUILD__)
|
||||
CFileIO::FindAllFilePos();
|
||||
#endif
|
||||
BigLump=BigLumpPtr;
|
||||
FileStart=CFileIO::GetFilePos(FILEPOS_BIGLUMP);
|
||||
CXAStream::SetSector(CFileIO::GetFilePos(FILEPOS_TRACK1));
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CCDFileIO::Open()
|
||||
{
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CCDFileIO::Read(u32 Count,void *Dst)
|
||||
{
|
||||
u8 Com=CdlModeSpeed;
|
||||
int Error=0;
|
||||
// seek
|
||||
|
||||
while (!Error)
|
||||
{
|
||||
CdIntToPos(BigLump->Sector+FileStart,&CdPos);
|
||||
CdControlB(CdlSetloc, (u8*)&CdPos, 0); // Set CD Pos
|
||||
CdControlB(CdlSetmode, &Com, 0);
|
||||
Error=CdRead(Count, (u32*)Dst, CdlModeSpeed);
|
||||
}
|
||||
while (CdReadSync(1,0) > 0);
|
||||
BigLump->Sector+=Count;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CCDFileIO::Close()
|
||||
{
|
||||
}
|
||||
|
||||
30
source/fileio/cdfile.h
Normal file
30
source/fileio/cdfile.h
Normal file
@ -0,0 +1,30 @@
|
||||
/***************************/
|
||||
/*** PSX CD FileIO Stuff ***/
|
||||
/***************************/
|
||||
|
||||
#ifndef __CDFILE_H__
|
||||
#define __CDFILE_H__
|
||||
|
||||
#include "fileio\fileio.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
class CCDFileIO : public CLOFileIO
|
||||
{
|
||||
public:
|
||||
CCDFileIO(u32 FilePos,sBigLump *BigLumpPtr);
|
||||
virtual ~CCDFileIO(){};
|
||||
|
||||
void Open();
|
||||
void Read(u32 Length,void *Buffer);
|
||||
void Close();
|
||||
|
||||
private:
|
||||
sBigLump *BigLump;
|
||||
u32 FileStart;
|
||||
CdlLOC CdPos;
|
||||
static int HasInit;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
#endif
|
||||
|
||||
380
source/fileio/fileio.cpp
Normal file
380
source/fileio/fileio.cpp
Normal file
@ -0,0 +1,380 @@
|
||||
/***************************************/
|
||||
/*** PSX PC/CD Big Lump FileIO Stuff ***/
|
||||
/***************************************/
|
||||
|
||||
#include "system\global.h"
|
||||
#include "fileio\fileio.h"
|
||||
#if __FILE_SYSTEM__==PC
|
||||
#include "fileio\pcfile.h"
|
||||
#else
|
||||
#include "fileio\cdfile.h"
|
||||
#endif
|
||||
#include "utils\replace.h"
|
||||
#include "utils\utils.h"
|
||||
|
||||
char *LumpNames[]=
|
||||
{
|
||||
"BIGLUMP.BIN",
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
sBigLump CFileIO::BigLump;
|
||||
CLOFileIO *CFileIO::FileIO;
|
||||
int CFileIO::FilePosList[FILEPOS_MAX];
|
||||
|
||||
sFAT *CFileIO::MainFAT=0;
|
||||
|
||||
/*****************************************************************************/
|
||||
sDataBank CFileIO::DataBank[DATABANK_MAX]=
|
||||
{
|
||||
/*
|
||||
{SYSTEM_CACHE ,0},
|
||||
{FRONTEND_CACHE ,0},
|
||||
{LEVEL1_CACHE ,0},
|
||||
{LEVEL2_CACHE ,0},
|
||||
{LEVEL3_CACHE ,0},
|
||||
{LEVEL4_CACHE ,0},
|
||||
{LEVEL5_CACHE ,0},
|
||||
{LEVEL6_CACHE ,0},
|
||||
{LEVEL7_CACHE ,0},
|
||||
{LEVEL8_CACHE ,0},
|
||||
{BACKEND_CACHE ,0},
|
||||
*/
|
||||
};
|
||||
|
||||
DataBankEquate CFileIO::CurrentDataBank=DATABANK_MAX;
|
||||
|
||||
/*****************************************************************************/
|
||||
/*****************************************************************************/
|
||||
/*****************************************************************************/
|
||||
//sFAT *FAT;
|
||||
void CFileIO::Init()
|
||||
{
|
||||
DBG_MSG0("IO INIT!!!!\n");
|
||||
|
||||
#if __FILE_SYSTEM__==PC
|
||||
FileIO=new ("CFileIO::FileIOInit") CPCFileIO(LumpNames[DataLump],&BigLump);
|
||||
#else
|
||||
FileIO=new ("CFileIO::FileIOInit") CCDFileIO(0,&BigLump);
|
||||
#endif
|
||||
BigLump.Status=BLStatusReady;
|
||||
|
||||
int FATSize=FileEquate_MAX*sizeof(sFAT);
|
||||
// Read Main FAT (special case load)
|
||||
MainFAT=(sFAT *)MemAlloc( FATSize,"MainFAT");
|
||||
|
||||
DBG_MSG1("FATSIZE=%i\n",FATSize);
|
||||
FileIO->Open();
|
||||
|
||||
BigLump.Status = BLStatusOpen;
|
||||
BigLump.Sector=0;
|
||||
BigLump.Length=FATSize;
|
||||
BigLump.LengthLeft=BigLump.Length;
|
||||
BigLump.ReadSoFar=0;
|
||||
BigLump.LoadMode = FILEIO_MODE_NONE;
|
||||
BigLump.ChunkLeft=0;
|
||||
ReadFile(MainFAT,FATSize);
|
||||
CloseFile();
|
||||
|
||||
for (int Bank=0;Bank<DATABANK_MAX; Bank++) DataBank[Bank].Data=0;
|
||||
// loadDataBank(DATABANK_SYSTEM);
|
||||
// CurrentDataBank=DATABANK_MAX;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/*** Open ********************************************************************/
|
||||
/*****************************************************************************/
|
||||
void CFileIO::OpenFile( FileEquate file )
|
||||
{
|
||||
ASSERT(MainFAT);
|
||||
FileIO->Open();
|
||||
BigLump.Status = BLStatusOpen;
|
||||
BigLump.Sector = getFileSector( ( file ) );
|
||||
BigLump.Length = getFileSize( ( file ) );
|
||||
BigLump.LengthLeft = BigLump.Length;
|
||||
BigLump.ReadSoFar=0;
|
||||
BigLump.LoadMode = FILEIO_MODE_NONE;
|
||||
BigLump.ChunkLeft=0;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/*** Read ********************************************************************/
|
||||
/*****************************************************************************/
|
||||
void CFileIO::CheckChunk()
|
||||
{
|
||||
int ChunkCount;
|
||||
if (!BigLump.ChunkLeft)
|
||||
{
|
||||
ChunkCount=BigLump.LengthLeft/2048;
|
||||
if (ChunkCount>FILEIO_MAXCHUNKS) ChunkCount=FILEIO_MAXCHUNKS;
|
||||
else
|
||||
if (ChunkCount<FILEIO_MINCHUNKS) ChunkCount=FILEIO_MINCHUNKS;
|
||||
BigLump.ChunkPtr=BigLump.ChunkBuffer;
|
||||
BigLump.ChunkLeft=ChunkCount*2048;
|
||||
FileIO->Read(ChunkCount, (char*)BigLump.ChunkPtr);
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
long CFileIO::ReadFile( void * Buffer, s32 Length )
|
||||
{
|
||||
int ThisLoadSize;
|
||||
|
||||
BigLump.LoadLeft=Length;
|
||||
BigLump.DstPtr=(u8*)Buffer;
|
||||
|
||||
while (BigLump.LoadLeft)
|
||||
{
|
||||
if (BigLump.LoadMode==FILEIO_MODE_NONE)
|
||||
{
|
||||
if (BigLump.LoadLeft>=FILEIO_CHUNKSIZE)
|
||||
BigLump.LoadMode = FILEIO_MODE_CHUNK;
|
||||
else
|
||||
BigLump.LoadMode = FILEIO_MODE_STREAM;
|
||||
}
|
||||
|
||||
switch (BigLump.LoadMode)
|
||||
{
|
||||
case FILEIO_MODE_CHUNK: // Load large chunk
|
||||
ThisLoadSize=BigLump.LoadLeft-(BigLump.LoadLeft%FILEIO_CHUNKSIZE);
|
||||
FileIO->Read(ThisLoadSize/FILEIO_CHUNKSIZE, (char*)BigLump.DstPtr);
|
||||
BigLump.DstPtr+=ThisLoadSize;
|
||||
BigLump.LoadLeft-=ThisLoadSize;
|
||||
BigLump.LengthLeft-=ThisLoadSize;
|
||||
BigLump.ReadSoFar+=ThisLoadSize;
|
||||
BigLump.LoadMode=FILEIO_MODE_NONE;
|
||||
break;
|
||||
|
||||
case FILEIO_MODE_STREAM: // Stream chunk
|
||||
CheckChunk();
|
||||
ThisLoadSize=BigLump.LoadLeft;
|
||||
if (ThisLoadSize>BigLump.ChunkLeft) ThisLoadSize=BigLump.ChunkLeft;
|
||||
if (BigLump.DstPtr) MCmemcpy(BigLump.DstPtr, BigLump.ChunkPtr, ThisLoadSize );
|
||||
|
||||
BigLump.ChunkLeft-=ThisLoadSize;
|
||||
BigLump.DstPtr+=ThisLoadSize;
|
||||
BigLump.ChunkPtr+=ThisLoadSize;
|
||||
BigLump.LoadLeft-=ThisLoadSize;
|
||||
BigLump.LengthLeft-=ThisLoadSize;
|
||||
BigLump.ReadSoFar+=ThisLoadSize;
|
||||
if (!BigLump.ChunkLeft) BigLump.LoadMode=FILEIO_MODE_NONE;
|
||||
break;
|
||||
default:
|
||||
ASSERT(!"Unknown Load Type!");
|
||||
}
|
||||
}
|
||||
|
||||
return (BigLump.LoadLeft);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/*** Load ********************************************************************/
|
||||
/*****************************************************************************/
|
||||
u8 * CFileIO::loadFile( FileEquate file, char *allocName )
|
||||
{
|
||||
u8 * buffer;
|
||||
s32 Length;
|
||||
|
||||
// Is Already loaded in a databank?
|
||||
buffer=isFileInDataBank(file);
|
||||
if (buffer) return(buffer);
|
||||
|
||||
Length = getFileSize( file );
|
||||
|
||||
buffer = (u8 *)MemAlloc( Length ,allocName);
|
||||
ASSERT( buffer );
|
||||
#if defined(__USER_ART__)
|
||||
EnterCriticalSection();
|
||||
#endif
|
||||
OpenFile( file );
|
||||
ReadFile( buffer, Length );
|
||||
CloseFile();
|
||||
#if defined(__USER_ART__)
|
||||
ExitCriticalSection();
|
||||
#endif
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
int CFileIO::IsFromDataBank(void *Addr)
|
||||
{
|
||||
// See if we can find the file by its address
|
||||
// Simply check if address is within a bank range
|
||||
// Dont check start address, as this will prevent the bank from being freed
|
||||
for (int Bank=0;Bank<DATABANK_MAX; Bank++)
|
||||
{
|
||||
sDataBank &ThisBank=DataBank[Bank];
|
||||
if (ThisBank.Data)
|
||||
{
|
||||
int Size=getFileSize(ThisBank.Filename);
|
||||
u8 *StartAddr=(u8*)ThisBank.Data;
|
||||
u8 *EndAddr=StartAddr+Size;
|
||||
if (Addr>StartAddr && Addr <=EndAddr) return(1);
|
||||
}
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
u8 * CFileIO::loadFileAtAddr( FileEquate file, u8* buffer)
|
||||
{
|
||||
s32 Length;
|
||||
|
||||
Length = getFileSize( file );
|
||||
|
||||
ASSERT( buffer );
|
||||
#if defined(__USER_ART__)
|
||||
EnterCriticalSection();
|
||||
#endif
|
||||
OpenFile( file );
|
||||
ReadFile( buffer, Length );
|
||||
CloseFile();
|
||||
#if defined(__USER_ART__)
|
||||
ExitCriticalSection();
|
||||
#endif
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/*** Close *******************************************************************/
|
||||
/*****************************************************************************/
|
||||
void CFileIO::CloseFile()
|
||||
{
|
||||
FileIO->Close();
|
||||
BigLump.Status=BLStatusReady;
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
void CFileIO::LoadFileSizeAtAddr(FileEquate Filename,void *Buffer,u32 Length)
|
||||
{
|
||||
#if defined(__USER_ART__)
|
||||
EnterCriticalSection();
|
||||
#endif
|
||||
OpenFile(Filename);
|
||||
ReadFile(Buffer,Length);
|
||||
CloseFile();
|
||||
#if defined(__USER_ART__)
|
||||
ExitCriticalSection();
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CFileIO::AlignFile(int Align)
|
||||
{
|
||||
int Length = ((BigLump.ReadSoFar+Align-1)&-Align)-BigLump.ReadSoFar;
|
||||
|
||||
if (Length)
|
||||
{
|
||||
ReadFile( NULL, Length );
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
s32 CFileIO::getFileSize( FileEquate file )
|
||||
{
|
||||
s32 Ret=MainFAT[file].FileSize;
|
||||
return (Ret);
|
||||
}
|
||||
|
||||
|
||||
s32 CFileIO::getFileSector( FileEquate file )
|
||||
{
|
||||
s32 Ret=MainFAT[file].FilePos/2048;
|
||||
return (Ret);
|
||||
}
|
||||
|
||||
s32 CFileIO::getFileOffset( FileEquate file )
|
||||
{
|
||||
s32 Ret=MainFAT[file].FilePos;
|
||||
return (Ret);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CFileIO::SkipFile(int Skip)
|
||||
{
|
||||
if (Skip) ReadFile(0,Skip);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
int CFileIO::GetFilePos(int File)
|
||||
{
|
||||
return(FilePosList[File]);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
#if !defined(__USER_CDBUILD__)
|
||||
#include "fileio/filetab.cpp"
|
||||
#endif
|
||||
|
||||
void CFileIO::FindAllFilePos()
|
||||
{
|
||||
#if !defined(__USER_CDBUILD__)
|
||||
CalcFilePos(FilePosList);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
// File positions are passed by Bootstrap VIA Scratch Ram (nice!)
|
||||
void CFileIO::GetAllFilePos()
|
||||
{
|
||||
int *Pos=(int*)SCRATCH_RAM;
|
||||
|
||||
for (int Loop=0;Loop<FILEPOS_MAX;Loop++)
|
||||
{
|
||||
FilePosList[Loop]=*Pos++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/****************************************************************************/
|
||||
int CFileIO::GetReadLeft()
|
||||
{
|
||||
return(BigLump.LengthLeft);
|
||||
}
|
||||
/*****************************************************************************/
|
||||
/*** Data Banks **************************************************************/
|
||||
/*****************************************************************************/
|
||||
void CFileIO::loadDataBank(DataBankEquate Bank)
|
||||
{
|
||||
// Check if already loaded
|
||||
if (DataBank[Bank].Data) return;
|
||||
|
||||
// Check to see no more are loaded
|
||||
ASSERT(CurrentDataBank==DATABANK_MAX);
|
||||
|
||||
DataBank[Bank].Data=(sFAT*)loadFile(DataBank[Bank].Filename,"DataBank");
|
||||
CurrentDataBank=Bank;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CFileIO::dumpDataBank()
|
||||
{
|
||||
// Check if loaded
|
||||
ASSERT(CurrentDataBank!=DATABANK_MAX);
|
||||
MemFree(DataBank[CurrentDataBank].Data);
|
||||
DataBank[CurrentDataBank].Data=0;
|
||||
CurrentDataBank=DATABANK_MAX;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
u8 *CFileIO::isFileInDataBank(FileEquate File)
|
||||
{
|
||||
for (int Bank=0;Bank<DATABANK_MAX; Bank++)
|
||||
{
|
||||
sDataBank &ThisBank=DataBank[Bank];
|
||||
if (ThisBank.Data)
|
||||
{
|
||||
int Pos=ThisBank.Data[File].FilePos;
|
||||
if (Pos!=-1) return(MakePtr(ThisBank.Data,Pos));
|
||||
}
|
||||
}
|
||||
DBG_MSG1("File Not in Cache [%i]",File);
|
||||
|
||||
return(0);
|
||||
}
|
||||
130
source/fileio/fileio.h
Normal file
130
source/fileio/fileio.h
Normal file
@ -0,0 +1,130 @@
|
||||
/***************************************/
|
||||
/*** PSX PC/CD Big Lump FileIO Stuff ***/
|
||||
/***************************************/
|
||||
|
||||
#ifndef _FILEIO_HEADER_
|
||||
#define _FILEIO_HEADER_
|
||||
|
||||
#include "BigLump.h"
|
||||
#include "fileio\filetab.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
#define FILEIO_MINCHUNKS (1) // 2k
|
||||
#define FILEIO_MAXCHUNKS (1) // 2k 64k (only needed for small files, daft streams and end of files now)
|
||||
#define FILEIO_CHUNKSIZE (2048)
|
||||
#define FILEIO_MINCHUNKSIZE (FILEIO_CHUNKSIZE*FILEIO_MINCHUNKS)
|
||||
#define FILEIO_MAXCHUNKSIZE (FILEIO_CHUNKSIZE*FILEIO_MAXCHUNKS)
|
||||
|
||||
enum
|
||||
{
|
||||
FILEIO_MODE_NONE=0,
|
||||
FILEIO_MODE_CHUNK,
|
||||
FILEIO_MODE_STREAM,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
BLStatusOffline=-1,
|
||||
BLStatusReady,
|
||||
BLStatusOpen,
|
||||
BLStatusRead,
|
||||
BLStatusFail
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
DataLump=0,
|
||||
OverlayLump,
|
||||
MaxLumps
|
||||
};
|
||||
|
||||
struct sFAT
|
||||
{
|
||||
s32 FilePos;
|
||||
s32 FileSize;
|
||||
};
|
||||
|
||||
struct sBigLump
|
||||
{
|
||||
s16 Status;
|
||||
u32 Sector;
|
||||
u8 *ChunkPtr,*DstPtr;
|
||||
int ChunkLeft;
|
||||
int Length,LengthLeft,ReadSoFar;
|
||||
int LoadLeft;
|
||||
int LoadMode;
|
||||
u8 ChunkBuffer[FILEIO_MAXCHUNKSIZE];
|
||||
};
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
enum DataBankEquate
|
||||
{
|
||||
DATABANK_MAX
|
||||
};
|
||||
|
||||
struct sDataBank
|
||||
{
|
||||
FileEquate Filename;
|
||||
sFAT *Data;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
class CLOFileIO;
|
||||
class CFileIO
|
||||
{
|
||||
public:
|
||||
|
||||
static void Init();
|
||||
static void OpenFile(FileEquate file);
|
||||
static long ReadFile(void *Buffer,s32 Length);
|
||||
static void CloseFile();
|
||||
static void AlignFile(int Length);
|
||||
static void SkipFile(int Skip);
|
||||
|
||||
static int GetStatus() {return(BigLump.Status);}
|
||||
|
||||
static void LoadFileSizeAtAddr(FileEquate Filename,void *Buffer,u32 Length);
|
||||
|
||||
static u8 *loadFile( FileEquate file, char *allocName="CFileIO::loadFile" );
|
||||
static int IsFromDataBank(void *Addr);
|
||||
static u8 *loadFileAtAddr(FileEquate file, u8* buffer);
|
||||
|
||||
static void loadDataBank(DataBankEquate Bank);
|
||||
static void dumpDataBank();
|
||||
static u8 *isFileInDataBank(FileEquate File);
|
||||
|
||||
static s32 getFileSize( FileEquate file );
|
||||
static s32 getFileSector( FileEquate file );
|
||||
static s32 getFileOffset( FileEquate file );
|
||||
|
||||
static int GetFilePos(int File);
|
||||
static void FindAllFilePos();
|
||||
static void GetAllFilePos();
|
||||
static int GetReadLeft();
|
||||
|
||||
private:
|
||||
static void CheckChunk();
|
||||
|
||||
static sBigLump BigLump;
|
||||
static CLOFileIO *FileIO;
|
||||
static int FilePosList[FILEPOS_MAX];
|
||||
|
||||
static sDataBank DataBank[DATABANK_MAX];
|
||||
static DataBankEquate CurrentDataBank;
|
||||
|
||||
static sFAT *MainFAT;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
class CLOFileIO
|
||||
{
|
||||
public:
|
||||
virtual void Open()=0;
|
||||
virtual void Read(u32 Length,void *Buffer)=0;
|
||||
virtual void Close()=0;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
#endif
|
||||
44
source/fileio/filetab.cpp
Normal file
44
source/fileio/filetab.cpp
Normal file
@ -0,0 +1,44 @@
|
||||
/******************/
|
||||
/*** File Table ***/
|
||||
/******************/
|
||||
|
||||
/*******************************************************************************/
|
||||
char *FilenameList[FILEPOS_MAX]=
|
||||
{
|
||||
"BIGLUMP.BIN",
|
||||
"TRACK1.IXA",
|
||||
"CLIMAX.STR",
|
||||
"INTRO.STR",
|
||||
"LEVEL1.STR",
|
||||
"LEVEL2.STR",
|
||||
"LEVEL3.STR",
|
||||
"LEVEL4.STR",
|
||||
"LEVEL5.STR",
|
||||
"LEVEL6.STR",
|
||||
"LEVEL7.STR",
|
||||
"ZORD1.STR",
|
||||
"ZORD2.STR",
|
||||
/*
|
||||
"DEMO2.STR",
|
||||
"DEMO3.STR",
|
||||
"DEMO4.STR",
|
||||
"DEMO5.STR",
|
||||
"DEMO6.STR"
|
||||
*/
|
||||
};
|
||||
|
||||
/*******************************************************************************/
|
||||
void CalcFilePos(int *Dst)
|
||||
{
|
||||
for (int Loop=0;Loop<FILEPOS_MAX;Loop++)
|
||||
{
|
||||
CdlFILE RetFile;
|
||||
int Pos;
|
||||
char Name[32];
|
||||
sprintf(Name,"\\%s;1",FilenameList[Loop]);
|
||||
while ( !CdSearchFile(&RetFile,Name) );
|
||||
Dst[Loop]=CdPosToInt(&RetFile.pos);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
36
source/fileio/filetab.h
Normal file
36
source/fileio/filetab.h
Normal file
@ -0,0 +1,36 @@
|
||||
/******************/
|
||||
/*** File Table ***/
|
||||
/******************/
|
||||
|
||||
#ifndef __FILE_TABLE___
|
||||
#define __FILE_TABLE___
|
||||
|
||||
/*******************************************************************************/
|
||||
enum FILEPOS_ENUM
|
||||
{
|
||||
FILEPOS_BIGLUMP,
|
||||
FILEPOS_TRACK1,
|
||||
FILEPOS_CLIMAX_STR,
|
||||
FILEPOS_INTRO_STR,
|
||||
FILEPOS_LEVEL1_STR,
|
||||
FILEPOS_LEVEL2_STR,
|
||||
FILEPOS_LEVEL3_STR,
|
||||
FILEPOS_LEVEL4_STR,
|
||||
FILEPOS_LEVEL5_STR,
|
||||
FILEPOS_LEVEL6_STR,
|
||||
FILEPOS_LEVEL7_STR,
|
||||
FILEPOS_ZORD1_STR,
|
||||
FILEPOS_ZORD2_STR,
|
||||
/*
|
||||
FILEPOS_DEMO2_STR,
|
||||
FILEPOS_DEMO3_STR,
|
||||
FILEPOS_DEMO4_STR,
|
||||
FILEPOS_DEMO5_STR,
|
||||
FILEPOS_DEMO6_STR,
|
||||
*/
|
||||
FILEPOS_MAX
|
||||
};
|
||||
|
||||
/*******************************************************************************/
|
||||
|
||||
#endif
|
||||
40
source/fileio/pcfile.cpp
Normal file
40
source/fileio/pcfile.cpp
Normal file
@ -0,0 +1,40 @@
|
||||
/***********************************/
|
||||
/*** PSX PC BigLump FileIO Stuff ***/
|
||||
/***********************************/
|
||||
|
||||
#include "system\global.h"
|
||||
#include "fileio\fileio.h"
|
||||
#include "fileio\pcfile.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
CPCFileIO::CPCFileIO(char *Filename,sBigLump *BigLumpPtr)
|
||||
{
|
||||
int NoPath=0;
|
||||
PCinit();
|
||||
sprintf(FullFilename,"out\\%s\\%s\\version\\%s\\%s",INF_Territory,INF_Version,INF_FileSystem,Filename);
|
||||
BigLump=BigLumpPtr;
|
||||
FileHandle=-1;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CPCFileIO::Open()
|
||||
{
|
||||
FileHandle=PCopen(FullFilename,F_READ,0);
|
||||
ASSERT(FileHandle!=-1);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CPCFileIO::Read(u32 Count,void *Dst)
|
||||
{
|
||||
PClseek(FileHandle,BigLump->Sector*FILEIO_CHUNKSIZE,0);
|
||||
PCread(FileHandle,(char*)Dst,Count*FILEIO_CHUNKSIZE);
|
||||
BigLump->Sector+=Count;
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
void CPCFileIO::Close()
|
||||
{
|
||||
if (FileHandle!=-1) PCclose(FileHandle);
|
||||
FileHandle=-1;
|
||||
|
||||
}
|
||||
36
source/fileio/pcfile.h
Normal file
36
source/fileio/pcfile.h
Normal file
@ -0,0 +1,36 @@
|
||||
/***************************/
|
||||
/*** PSX PC FileIO Stuff ***/
|
||||
/***************************/
|
||||
|
||||
#ifndef __PCFILE_H__
|
||||
#define __PCFILE_H__
|
||||
|
||||
#include "fileio\fileio.h"
|
||||
/*****************************************************************************/
|
||||
enum
|
||||
{
|
||||
F_READ,
|
||||
F_WRITE,
|
||||
F_READWRITE,
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
class CPCFileIO : public CLOFileIO
|
||||
{
|
||||
public:
|
||||
CPCFileIO(char *Filename,sBigLump *BigLumpPtr);
|
||||
virtual ~CPCFileIO(){};
|
||||
|
||||
void Open();
|
||||
void Read(u32 Length,void *Buffer);
|
||||
void Close();
|
||||
|
||||
private:
|
||||
sBigLump *BigLump;
|
||||
s32 FileHandle;
|
||||
char FullFilename[256];
|
||||
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user