422 lines
11 KiB
C++
422 lines
11 KiB
C++
/***************************************/
|
|
/*** 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"
|
|
|
|
//#define FILEIO_DBG
|
|
|
|
#ifdef FILEIO_DBG
|
|
#define FILEIO_DBGMSG SYSTEM_DBGMSG
|
|
#else
|
|
#define FILEIO_DBGMSG //
|
|
|
|
#endif
|
|
|
|
char *LumpNames[]=
|
|
{
|
|
"BIGLUMP.BIN",
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
sBigLump CFileIO::BigLump;
|
|
CLOFileIO *CFileIO::FileIO;
|
|
int CFileIO::FilePosList[FILEPOS_MAX];
|
|
|
|
sFAT *CFileIO::MainFAT=0;
|
|
sASyncQueue CFileIO::ASyncQueue;
|
|
bool CFileIO::ASyncFlag;
|
|
bool CFileIO::LogFlag;
|
|
|
|
/*****************************************************************************/
|
|
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()
|
|
{
|
|
#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");
|
|
|
|
FILEIO_DBGMSG("IoInit:FATSIZE=%i",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;
|
|
ASyncQueue.Status=BLStatusOffline;
|
|
ASyncFlag=false;
|
|
LogFlag=false;
|
|
#if defined(__USER_daveo__)
|
|
LogFlag=true;
|
|
#endif
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
/*** 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 );
|
|
|
|
if (LogFlag)
|
|
{
|
|
SYSTEM_DBGMSG("File: %i = %i",(int)file,Length);
|
|
}
|
|
|
|
buffer = (u8 *)MemAlloc( Length ,allocName);
|
|
ASSERT( buffer );
|
|
#if defined(__CLIMAX_DEVKIT__)
|
|
EnterCriticalSection();
|
|
#endif
|
|
OpenFile( file );
|
|
ReadFile( buffer, Length );
|
|
CloseFile();
|
|
#if defined(__CLIMAX_DEVKIT__)
|
|
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(__CLIMAX_DEVKIT__)
|
|
EnterCriticalSection();
|
|
#endif
|
|
OpenFile( file );
|
|
ReadFile( buffer, Length );
|
|
CloseFile();
|
|
#if defined(__CLIMAX_DEVKIT__)
|
|
ExitCriticalSection();
|
|
#endif
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*** Close *******************************************************************/
|
|
/*****************************************************************************/
|
|
void CFileIO::CloseFile()
|
|
{
|
|
FileIO->Close();
|
|
BigLump.Status=BLStatusReady;
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
void CFileIO::LoadFileSizeAtAddr(FileEquate Filename,void *Buffer,u32 Length)
|
|
{
|
|
#if defined(__CLIMAX_DEVKIT__)
|
|
EnterCriticalSection();
|
|
#endif
|
|
OpenFile(Filename);
|
|
ReadFile(Buffer,Length);
|
|
CloseFile();
|
|
#if defined(__CLIMAX_DEVKIT__)
|
|
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);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
void CFileIO::AddASyncFile(FileEquate file,u8 *Dst)
|
|
{
|
|
ASyncQueue.Sector = getFileSector(file);
|
|
ASyncQueue.Length = getFileSize(file )/2048;
|
|
ASyncQueue.Dst=Dst;
|
|
ASyncQueue.Status=BLStatusReady;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
void CFileIO::LoadASyncFiles()
|
|
{
|
|
if (ASyncQueue.Status!=BLStatusOffline && ASyncFlag)
|
|
{
|
|
FileIO->ReadAsync(ASyncQueue);
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*** 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));
|
|
}
|
|
}
|
|
FILEIO_DBGMSG("File Not in Cache [%i]",File);
|
|
|
|
return(0);
|
|
}
|