739 lines
20 KiB
C
739 lines
20 KiB
C
#include "platform.h"
|
|
#include "os.h"
|
|
#include "cgdoom.h"
|
|
#include <stdlib.h>
|
|
#include "libprof.h"
|
|
|
|
#include "doomtype.h"
|
|
#include "m_misc.h"
|
|
|
|
#ifndef CG_EMULATOR
|
|
# include "cgdoom-alloc.h"
|
|
# include "cgdoom-ui.h"
|
|
#endif
|
|
|
|
void * CGDMalloc(int iSize)
|
|
{
|
|
void *p = malloc(iSize);
|
|
if (!p)
|
|
I_Error ("CGDMalloc failure");
|
|
return p;
|
|
}
|
|
|
|
void * CGDCalloc(int iSize)
|
|
{
|
|
void *p = CGDMalloc(iSize);
|
|
if(p != NULL)
|
|
{
|
|
memset(p,0,iSize);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
void * CGDRealloc (void *p, int iSize)
|
|
{
|
|
if(p == NULL)
|
|
return malloc(iSize);
|
|
else
|
|
return realloc(p,iSize);
|
|
}
|
|
|
|
unsigned short *VRAM;
|
|
unsigned char *SaveVRAMBuffer;
|
|
unsigned char *SystemStack;
|
|
|
|
void CGDAppendNum09(const char *pszText,int iNum,char *pszBuf)
|
|
{
|
|
int i = 0;
|
|
while(pszText[i])
|
|
{
|
|
pszBuf[i] = pszText[i];
|
|
i++;
|
|
}
|
|
ASSERT(iNum < 10);
|
|
ASSERT(iNum >= 0);
|
|
pszBuf[i] = (char)('0'+iNum);
|
|
pszBuf[i+1] = 0;
|
|
}
|
|
|
|
void CGDAppendNum0_999(const char *pszText,int iNum,int iMinDigits,char *pszBuf)
|
|
{
|
|
int i = 0;
|
|
int z = 0;
|
|
while(pszText[i])
|
|
{
|
|
pszBuf[i] = pszText[i];
|
|
i++;
|
|
}
|
|
ASSERT(iNum < 1000000);
|
|
ASSERT(iNum >= 0);
|
|
if((iNum > 999999) || (iMinDigits>6))
|
|
{
|
|
pszBuf[i] = (char)('0'+(iNum / 1000000));
|
|
iNum %= 1000000;
|
|
i++;
|
|
z = 1;
|
|
}
|
|
if(z || (iNum > 99990) || (iMinDigits>5))
|
|
{
|
|
pszBuf[i] = (char)('0'+(iNum / 100000));
|
|
iNum %= 100000;
|
|
i++;
|
|
z = 1;
|
|
}
|
|
|
|
if(z || (iNum > 9999) || (iMinDigits>4))
|
|
{
|
|
pszBuf[i] = (char)('0'+(iNum / 10000));
|
|
iNum %= 10000;
|
|
i++;
|
|
z = 1;
|
|
}
|
|
if(z || (iNum > 999) || (iMinDigits>3))
|
|
{
|
|
pszBuf[i] = (char)('0'+(iNum / 1000));
|
|
iNum %= 1000;
|
|
i++;
|
|
z = 1;
|
|
}
|
|
if(z || (iNum > 99) || (iMinDigits>2))
|
|
{
|
|
pszBuf[i] = (char)('0'+(iNum / 100));
|
|
iNum %= 100;
|
|
i++;
|
|
z = 1;
|
|
}
|
|
if(z || (iNum > 9) || (iMinDigits>1))
|
|
{
|
|
pszBuf[i] = (char)('0'+(iNum / 10));
|
|
iNum %= 10;
|
|
i++;
|
|
}
|
|
pszBuf[i] = (char)('0'+iNum);
|
|
pszBuf[i+1] = 0;
|
|
}
|
|
|
|
void CGDAppendHex32(const char *pszText,int iNum,int iDigits,char *pszBuf)
|
|
{
|
|
strcpy(pszBuf, pszText);
|
|
pszBuf += strlen(pszText);
|
|
for(int i = 0; i < iDigits; i++)
|
|
{
|
|
int c = (iNum >> (i * 4)) & 0xf;
|
|
c = c + '0' + 7 * (c > 9);
|
|
pszBuf[iDigits-i-1] = c;
|
|
}
|
|
pszBuf[iDigits] = 0;
|
|
}
|
|
|
|
int strnicmp(const char *s1,const char *s2,int count)
|
|
{
|
|
for(int i = 0; i < count; i++) {
|
|
int c1 = (s1[i] >= 'a' && s1[i] <= 'z') ? s1[i] & ~0x20 : s1[i];
|
|
int c2 = (s2[i] >= 'a' && s2[i] <= 'z') ? s2[i] & ~0x20 : s2[i];
|
|
|
|
if(c1 != c2 || !c1 || !c2)
|
|
return c1 - c2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// WAD file access mechanism
|
|
//
|
|
// Since BFile is too slow to access the WAD file in real-time, the fragments
|
|
// are searched in ROM and their physical addresses are stored for direct
|
|
// access later. This is similar to mmap() except that a manual translation is
|
|
// used instead of the MMU. As far as I know, the first version of this system
|
|
// was implemented by Martin Poupe.
|
|
//
|
|
// The file is obviously fragmented and Yatis reverse-engineered Fugue enough
|
|
// to determine that storage units are sectors of 512 bytes. While clusters of
|
|
// 4 kiB are used in general, a file might not start on the first sector of a
|
|
// cluster, and some sectors might also simply be dead.
|
|
//
|
|
// Although all 65536 Flash sectors are searched when needed, several
|
|
// heuristics are used:
|
|
// * The region between FLASH_FS_HINT and FLASH_END is searched first, since
|
|
// this is roughly where the filesystem is located.
|
|
// * All sectors aligned on 4-kiB boundaries between FLASH_FS_HINT and
|
|
// FLASH_END (of which there are 4096) are indexed by their first 4 bytes and
|
|
// binary searched for matches before anything else.
|
|
//
|
|
// See <platform.h> for Flash traversal parameters.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef CG_EMULATOR
|
|
|
|
//The whole sound doesn't fir onto the RAM.
|
|
//Reading per partes is not possible as this is synchronnous player (there would be silences when reading).
|
|
|
|
/* Fast memcmp() for 512-byte sectors. */
|
|
int CGD_sector_memcmp(const void *fast_ram, const void *rom, size_t _512);
|
|
|
|
/* Caching structure to read WAD files by larger chunks than Flash sectors. */
|
|
typedef struct {
|
|
int fd;
|
|
int size, offset;
|
|
char *data; /* of size FLASH_BFILE_UNIT */
|
|
} FileAccessCache;
|
|
|
|
/* Index of most likely ROM sectors. */
|
|
typedef struct {
|
|
const void *sector;
|
|
uint32_t start_bytes;
|
|
} SectorIndexInfo;
|
|
|
|
/* Description of a fragment of a WAD file, in Flash. This is placed in PRAM0
|
|
to save RAM elsewhere. PRAM0 only supports 32-bit accesses, so we make this
|
|
structure a volatile bitfield where each entry has a 32-bit supporting type,
|
|
and build with -fstrict-volatile-bitfields which instructs GCC to use
|
|
accesses of the size of the supporting type without compromising on the
|
|
naming of the fields. */
|
|
typedef volatile struct {
|
|
/* Index of first sector in Flash (0...64k) */
|
|
uint32_t flash_address :16;
|
|
/* Corresponding sector in the WAD file */
|
|
uint32_t file_address :16;
|
|
} FileMappingItem;
|
|
|
|
/* Maximum number of fragments in the file map. Fragment information is stored
|
|
in PRAM0, so up to ~40k entries can be stored; this limit is mostly to catch
|
|
failures in fragment detection. (I have witnessed Ultimate Doom WADs with
|
|
up to 500 fragments.)*/
|
|
#define MAX_FRAGMENTS 2048
|
|
|
|
typedef struct {
|
|
/* Table of fragments */
|
|
FileMappingItem *mTable;
|
|
int miItemCount;
|
|
/* Length of the file */
|
|
int miTotalLength;
|
|
} FileMapping;
|
|
|
|
/* Find WAD files in the filesystem. */
|
|
int FindWADs(WADFileInfo *files, int max)
|
|
{
|
|
uint16_t path[32];
|
|
Bfile_FileInfo info;
|
|
|
|
int sd, rc, total=0;
|
|
rc = Bfile_FindFirst(u"\\\\fls0\\*.wad", &sd, path, &info);
|
|
|
|
while(rc != -16 && total < max)
|
|
{
|
|
memcpy(files[total].path, u"\\\\fls0\\", 14);
|
|
memcpy(files[total].path+7, path, 32*2);
|
|
Bfile_NameToStr_ncpy(files[total].name, path, 32);
|
|
files[total].size = info.fsize;
|
|
total++;
|
|
|
|
rc = Bfile_FindNext(sd, path, &info);
|
|
}
|
|
|
|
Bfile_FindClose(sd);
|
|
return total;
|
|
}
|
|
|
|
/* WAD file access method. */
|
|
static int gWADmethod = CGDOOM_WAD_MMAP;
|
|
/* File descriptor to WAD, used in Flash_ReadFile calls. (CGDOOM_WAD_BFILE) */
|
|
static int gWADfd = -1;
|
|
/* Memory map of WAD file. (CGDOOM_WAD_MMAP) */
|
|
static FileMapping gWADMap;
|
|
/* Index of most likely sectors for fragment search. (CGDOOM_WAD_MMAP) */
|
|
static SectorIndexInfo *gIndex = NULL;
|
|
|
|
/* Global options */
|
|
int CGD_TrustUnalignedLumps = 1;
|
|
int CGD_EnableDemos = 0;
|
|
int CGD_SingleEpisodeUltimate = 0;
|
|
int CGD_2MBLineMemory = 0;
|
|
int CGD_Frameskip = 1;
|
|
const char *CGD_WADFileName = NULL;
|
|
|
|
/* Delayed file accesses */
|
|
CGD_DelayedFileWrite CGD_DelayedSaves[6] = { 0 };
|
|
|
|
/* Performance counters */
|
|
struct CGD_Perf CGD_Perf;
|
|
/* Developer statistics */
|
|
struct CGD_Stats CGD_Stats;
|
|
|
|
/* Read next sector from file, while caching into a buffer. */
|
|
const void *ReadNextSector(FileAccessCache *fc, int *size)
|
|
{
|
|
if(fc->size == 0)
|
|
{
|
|
fc->size = Bfile_ReadFile_OS(fc->fd, fc->data, FLASH_BFILE_UNIT, -1);
|
|
fc->offset = 0;
|
|
}
|
|
if(fc->size <= 0)
|
|
{
|
|
*size = -1;
|
|
return NULL;
|
|
}
|
|
|
|
*size = min(fc->size, FLASH_PAGE_SIZE);
|
|
fc->size -= *size;
|
|
const void *sector = fc->data + fc->offset;
|
|
fc->offset += *size;
|
|
return sector;
|
|
}
|
|
|
|
/* Compare two sectors in ROM for the index. */
|
|
int IndexCompareSectors(const void *p1, const void *p2)
|
|
{
|
|
const SectorIndexInfo *i1 = p1;
|
|
const SectorIndexInfo *i2 = p2;
|
|
return i1->start_bytes - i2->start_bytes;
|
|
}
|
|
|
|
/* Find all matching sectors in index (returns in-out interval). */
|
|
void IndexSearchSector(SectorIndexInfo *index, const void *buf, int *lo_ptr, int *hi_ptr)
|
|
{
|
|
uint32_t needle = *(const uint32_t *)buf;
|
|
*lo_ptr = *hi_ptr = -1;
|
|
|
|
/* Find the first occurrence, set it in *lo_ptr */
|
|
int lo=0, hi=FLASH_INDEX_SIZE;
|
|
|
|
while(lo < hi) {
|
|
int m = (lo + hi) / 2;
|
|
if(index[m].start_bytes < needle) lo = m + 1;
|
|
else hi = m;
|
|
}
|
|
|
|
if(lo >= FLASH_INDEX_SIZE || index[lo].start_bytes != needle) return;
|
|
*lo_ptr = hi = lo;
|
|
|
|
/* Store last occurrence in *hi_ptr */
|
|
do hi++;
|
|
while(hi < FLASH_INDEX_SIZE && index[hi].start_bytes == needle);
|
|
|
|
*hi_ptr = hi;
|
|
}
|
|
|
|
/* Find a flash sector which contains the same data as buf. */
|
|
int FindSectorInFlash(const void *buf, int size)
|
|
{
|
|
typeof(&memcmp) memcmp_fun = &memcmp;
|
|
if(size == FLASH_PAGE_SIZE) memcmp_fun = &CGD_sector_memcmp;
|
|
|
|
CGD_Stats.WADFragments++;
|
|
|
|
#ifdef FLASH_INDEX
|
|
/* If an index has been built, search in it */
|
|
int lo, hi;
|
|
IndexSearchSector(gIndex, buf, &lo, &hi);
|
|
for(int i = lo; i < hi; i++) {
|
|
if(!memcmp_fun(buf, gIndex[i].sector, size)) {
|
|
CGD_Stats.WADIndexHits++;
|
|
return (gIndex[i].sector - FLASH_START) / FLASH_PAGE_SIZE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
const void *sector = FLASH_FS_HINT;
|
|
do {
|
|
if(!memcmp_fun(buf, sector, size))
|
|
return (sector - FLASH_START) / FLASH_PAGE_SIZE;
|
|
|
|
sector += FLASH_PAGE_SIZE;
|
|
if(sector == FLASH_END)
|
|
sector = FLASH_START;
|
|
}
|
|
while(sector != FLASH_FS_HINT);
|
|
return -1;
|
|
}
|
|
|
|
int CreateFileMapping(int fd, FileMapping *pMap)
|
|
{
|
|
/* Cache accesses through a larger buffer */
|
|
FileAccessCache fc = {
|
|
.data = (void *)0xe5007000, /* XRAM */
|
|
.fd = fd
|
|
};
|
|
int iLength = 0;
|
|
int iFileSize = Bfile_GetFileSize_OS(fd);
|
|
|
|
pMap->miItemCount = 0;
|
|
pMap->miTotalLength = 0;
|
|
|
|
int iLastProgress = 0;
|
|
|
|
const void *pFileData = ReadNextSector(&fc, &iLength);
|
|
while(iLength > 0)
|
|
{
|
|
/* Don't show this too often, or it will eat several seconds */
|
|
if((pMap->miTotalLength - iLastProgress) * 20 > iFileSize) {
|
|
UI_ProgressBar(HEIGHT-10, pMap->miTotalLength, iFileSize);
|
|
iLastProgress = pMap->miTotalLength;
|
|
}
|
|
|
|
int iSectorID = FindSectorInFlash(pFileData, iLength);
|
|
if(iSectorID == -1)
|
|
return -2; // Page not found!
|
|
|
|
pMap->miItemCount++;
|
|
if(pMap->miItemCount >= MAX_FRAGMENTS)
|
|
return -3; // File too fragmented!
|
|
|
|
pMap->mTable[pMap->miItemCount-1].flash_address = iSectorID;
|
|
pMap->mTable[pMap->miItemCount-1].file_address = pMap->miTotalLength / FLASH_PAGE_SIZE;
|
|
|
|
/* Look for consecutive sectors in the same fragment */
|
|
const void *pFragment = FLASH_START + (iSectorID * FLASH_PAGE_SIZE);
|
|
if(!CGD_Stats.WADLowestFragment || pFragment<CGD_Stats.WADLowestFragment)
|
|
CGD_Stats.WADLowestFragment = pFragment;
|
|
|
|
for(;;)
|
|
{
|
|
pMap->miTotalLength += iLength;
|
|
iSectorID++;
|
|
pFragment += FLASH_PAGE_SIZE;
|
|
|
|
if(iLength < FLASH_PAGE_SIZE)
|
|
{
|
|
//this was the last page
|
|
return pMap->miTotalLength;
|
|
}
|
|
pFileData = ReadNextSector(&fc, &iLength);
|
|
if(iLength <= 0)
|
|
break;
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstringop-overread"
|
|
if((iLength == FLASH_PAGE_SIZE)
|
|
? CGD_sector_memcmp(pFileData, pFragment, iLength)
|
|
: memcmp(pFileData, pFragment, iLength))
|
|
break;
|
|
#pragma GCC diagnostic pop
|
|
}
|
|
}
|
|
if(iLength < 0)
|
|
return -1;
|
|
return pMap->miTotalLength;
|
|
}
|
|
|
|
/* Find a fragment in the file map by binary search. */
|
|
int FindFragmentInMap(FileMapping *map, int sector_number)
|
|
{
|
|
int lo=0, hi=map->miItemCount;
|
|
|
|
while (lo < hi)
|
|
{
|
|
int m = (lo + hi) / 2;
|
|
if (map->mTable[m].file_address > sector_number) hi = m;
|
|
else lo = m + 1;
|
|
}
|
|
|
|
return hi - 1;
|
|
}
|
|
|
|
int FindInFlash(const void **buf, int size, int readpos)
|
|
{
|
|
if(gWADmethod == CGDOOM_WAD_BFILE)
|
|
return 0;
|
|
|
|
ASSERT(readpos >= 0);
|
|
if (readpos + size > gWADMap.miTotalLength)
|
|
return -1;
|
|
|
|
int iFragIndx = FindFragmentInMap(&gWADMap, readpos / FLASH_PAGE_SIZE);
|
|
int iFragOffset = gWADMap.mTable[iFragIndx].file_address * FLASH_PAGE_SIZE;
|
|
int iSubOffset = readpos - iFragOffset;
|
|
|
|
int iFragEnd;
|
|
if (iFragIndx+1 < gWADMap.miItemCount)
|
|
iFragEnd = gWADMap.mTable[iFragIndx+1].file_address * FLASH_PAGE_SIZE;
|
|
else
|
|
iFragEnd = gWADMap.miTotalLength;
|
|
|
|
*buf = FLASH_CACHED_START + (gWADMap.mTable[iFragIndx].flash_address * FLASH_PAGE_SIZE) + iSubOffset;
|
|
|
|
/* Return how many bytes can be read off the fragment (up to size). */
|
|
int iAvailableLen = min(iFragEnd - readpos, size);
|
|
ASSERT(iAvailableLen > 0);
|
|
return iAvailableLen;
|
|
}
|
|
|
|
int Flash_ReadFile(void *buf, int size, int readpos)
|
|
{
|
|
if(gWADmethod == CGDOOM_WAD_BFILE)
|
|
return Bfile_ReadFile_OS(gWADfd, buf, size, readpos);
|
|
|
|
const void *pSrc;
|
|
int iRet = 0;
|
|
while(size >0)
|
|
{
|
|
int i = FindInFlash(&pSrc,size, readpos);
|
|
if(i<0) {
|
|
I_Error ("Flash_ReadFile: cannot find position %d (size %d)", readpos,
|
|
size);
|
|
return i;
|
|
}
|
|
memcpy(buf,pSrc,i);
|
|
buf = ((char*)buf)+i;
|
|
readpos +=i;
|
|
size -=i;
|
|
iRet +=i;
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
void abort(void){
|
|
int x=0,y=160;
|
|
PrintMini(&x,&y,"Abort called",0,0xFFFFFFFF,0,0,0xFFFF,0,1,0);
|
|
int key;
|
|
for(;;)
|
|
GetKey(&key);
|
|
}
|
|
|
|
#endif /* CG_EMULATOR */
|
|
|
|
static int FindZeroedMemory(void *start)
|
|
{
|
|
/* Look for zero-longwords every 16 bytes */
|
|
int size = 0;
|
|
|
|
/* Limit to 6 MB since the fx-CG 50 doesn't have any more memory and
|
|
anything after the RAM is likely to be zero non-writable */
|
|
while(size < CGDOOM_2MBLINEMEMORY_MAX && !*(uint32_t *)(start + size))
|
|
size += 16;
|
|
|
|
/* Round down to a multiple of 4096 */
|
|
return size & ~0xfff;
|
|
}
|
|
|
|
static void DelayedWriteFile(int i)
|
|
{
|
|
CGD_DelayedFileWrite const *dfw = &CGD_DelayedSaves[i];
|
|
|
|
uint16_t fc_path[100] = u"\\\\fls0\\";
|
|
int j=7, rc, fd;
|
|
|
|
for (int i = 0; dfw->filename[i]; i++)
|
|
fc_path[j++] = dfw->filename[i];
|
|
fc_path[j++] = 0x0000;
|
|
|
|
UI_DelayedWrites(CGD_DelayedSaves, 6, i, -1);
|
|
|
|
Bfile_DeleteEntry(fc_path);
|
|
|
|
rc = Bfile_CreateEntry_OS(fc_path, BFILE_CREATEMODE_FILE,
|
|
(size_t *)&dfw->size);
|
|
if (rc < 0) {
|
|
I_Error("Bfile_CreateEntry_OS(%s, %d bytes): %d", dfw->filename,
|
|
dfw->size, rc);
|
|
return;
|
|
}
|
|
|
|
fd = Bfile_OpenFile_OS(fc_path, BFILE_WRITE, 0);
|
|
if (fd < 0) {
|
|
I_Error("Bfile_OpenFile_OS(%s): %d", dfw->filename, fd);
|
|
return;
|
|
}
|
|
|
|
/* Write chunks of 4096 bytes and show progress in-between chunks */
|
|
int size = dfw->size;
|
|
const void *source = dfw->data;
|
|
|
|
while(size > 0) {
|
|
int chunk_size = (size >= 4096) ? 4096 : size;
|
|
Bfile_WriteFile_OS(fd, source, chunk_size);
|
|
source += chunk_size;
|
|
size -= chunk_size;
|
|
|
|
UI_DelayedWrites(CGD_DelayedSaves, 6, i, dfw->size - size);
|
|
}
|
|
|
|
Bfile_CloseFile_OS(fd);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
int main(void)
|
|
{
|
|
extern boolean autostart;
|
|
int autostart_ = 0;
|
|
startmap = 1;
|
|
startepisode = 1;
|
|
|
|
VRAM = (unsigned short*)GetVRAMAddress();
|
|
|
|
int time, ms_index=0, ms_mmap=0;
|
|
|
|
EnableColor(1);
|
|
EnableStatusArea(3);
|
|
Bdisp_FrameAndColor(3, 16);
|
|
Bdisp_FrameAndColor(1, 0);
|
|
|
|
prof_init();
|
|
|
|
WADFileInfo wads[16];
|
|
int wad_count = FindWADs(wads, 16);
|
|
|
|
int dev_info = 0;
|
|
|
|
/* Allow the user to use memory past the 2 MB line on known OS versions */
|
|
int *enable_2MBline=NULL;
|
|
char const *osv = (void *)0x80020020;
|
|
if(!strncmp(osv, "03.", 3) && osv[3] <= '6') // 3.60 or earlier
|
|
enable_2MBline = &CGD_2MBLineMemory;
|
|
|
|
int choice = UI_Main(wads, wad_count, &dev_info, &gWADmethod,
|
|
&startmap, &startepisode, &CGD_TrustUnalignedLumps, &autostart_,
|
|
&CGD_EnableDemos, enable_2MBline);
|
|
if(choice < 0)
|
|
return 1;
|
|
|
|
autostart = autostart_;
|
|
|
|
/* Override version detection for single-episode Ultimate Doom WADs */
|
|
if (!strcmp(wads[choice].name, "doomu1.wad"))
|
|
CGD_SingleEpisodeUltimate = 1;
|
|
if (!strcmp(wads[choice].name, "doomu2.wad"))
|
|
CGD_SingleEpisodeUltimate = 2;
|
|
if (!strcmp(wads[choice].name, "doomu3.wad"))
|
|
CGD_SingleEpisodeUltimate = 3;
|
|
if (!strcmp(wads[choice].name, "doomu4.wad"))
|
|
CGD_SingleEpisodeUltimate = 4;
|
|
|
|
unsigned tmp=((unsigned)getSecondaryVramAddress()+3)&(~3);
|
|
SaveVRAMBuffer = (unsigned char*)tmp;
|
|
/* fx-CG 50 / Graph 90+E: RAM starts at 0x0c000000 in physical memory */
|
|
SystemStack = (void *)0xac0f0000;
|
|
|
|
/* Determine how much RAM is zeroed out at 2 MB */
|
|
if(CGD_2MBLineMemory)
|
|
CGD_2MBLineMemory = FindZeroedMemory((void *)0xac200000);
|
|
|
|
/* Remember WAD file name for saves and loads */
|
|
static char wad_name[32] = { 0 };
|
|
for (int i = 0; wads[choice].name[i] != '.'; i++)
|
|
wad_name[i] = wads[choice].name[i];
|
|
CGD_WADFileName = wad_name;
|
|
|
|
/* Setup access to WAD file */
|
|
#ifdef CG_EMULATOR
|
|
gWADmethod = CGDOOM_WAD_BFILE;
|
|
#endif
|
|
if(gWADmethod == CGDOOM_WAD_BFILE)
|
|
{
|
|
gWADfd = Bfile_OpenFile_OS(wads[choice].path, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
#ifdef FLASH_INDEX
|
|
/* Index most likely flash sectors into a sorted array, so that
|
|
sectors can be hit quickly. The index contains every sector
|
|
on a 4-kiB boundary (where fragments are most likely to
|
|
start) between FLASH_FS_HINT and FLASH_END. */
|
|
time = RTC_GetTicks();
|
|
gIndex = (void *)SystemStack;
|
|
for(int i = 0; i < FLASH_INDEX_SIZE; i++) {
|
|
SectorIndexInfo *info = &gIndex[i];
|
|
info->sector = FLASH_FS_HINT + (i * 4096);
|
|
info->start_bytes = *(const uint32_t *)info->sector;
|
|
}
|
|
qsort(gIndex, FLASH_INDEX_SIZE, sizeof *gIndex, IndexCompareSectors);
|
|
ms_index = (RTC_GetTicks() - time) * 8;
|
|
#endif /* FLASH_INDEX */
|
|
|
|
time = RTC_GetTicks();
|
|
gWADMap.mTable = (void *)0xfe200000; /* PRAM0 */
|
|
int fd = Bfile_OpenFile_OS(wads[choice].path, 0, 0);
|
|
int size = CreateFileMapping(fd, &gWADMap);
|
|
Bfile_CloseFile_OS(fd);
|
|
UI_ProgressBar(HEIGHT-10, 1, 1);
|
|
ms_mmap = (RTC_GetTicks() - time) * 8;
|
|
|
|
if(size == -1) {
|
|
I_Error ("File read error");
|
|
return 1;
|
|
}
|
|
else if(size == -2) {
|
|
I_Error ("Page not found");
|
|
return 1;
|
|
}
|
|
else if(size == -3) {
|
|
I_Error ("File too fragmented");
|
|
return 1;
|
|
}
|
|
else if(dev_info) {
|
|
Layout l;
|
|
Layout_Init(&l);
|
|
Bdisp_AllClr_VRAM();
|
|
Layout_CenteredText(&l, "Developer info");
|
|
Layout_Spacing(&l, 12);
|
|
Layout_Text(&l, "Fragments:", "%d", CGD_Stats.WADFragments);
|
|
Layout_Text(&l, "Index hits:", "%d (%d%%)", CGD_Stats.WADIndexHits,
|
|
(CGD_Stats.WADIndexHits * 100 / CGD_Stats.WADFragments));
|
|
Layout_Text(&l, "Lowest fragment:", "%p",
|
|
CGD_Stats.WADLowestFragment);
|
|
Layout_Spacing(&l, 12);
|
|
Layout_Text(&l, "Index build time:", "%d ms", ms_index);
|
|
Layout_Text(&l, "File mapping time:", "%d ms", ms_mmap);
|
|
Layout_Spacing(&l, 12);
|
|
Layout_Text(&l, "Memory beyond the 2MB line:", "%d kB",
|
|
CGD_2MBLineMemory >> 10);
|
|
Bdisp_PutDisp_DD();
|
|
int key;
|
|
GetKey(&key);
|
|
}
|
|
|
|
/* Initialize the PRAM allocator */
|
|
void *PRAM0_start = (void *)0xfe200000;
|
|
void *PRAM0_end = (void *)0xfe228000;
|
|
PRAM0_start += gWADMap.miItemCount * sizeof(FileMappingItem);
|
|
CGD_PRAM_Init(PRAM0_start, PRAM0_end);
|
|
}
|
|
|
|
memset(VRAM, 0, WIDTH*HEIGHT*2);
|
|
D_DoomMain();
|
|
|
|
if(gWADfd >= 0)
|
|
Bfile_CloseFile_OS(gWADfd);
|
|
|
|
int delayed_writes = sizeof(CGD_DelayedSaves) / sizeof(CGD_DelayedSaves[0]);
|
|
for(int i = 0; i < delayed_writes; i++) {
|
|
CGD_DelayedFileWrite *dfw = &CGD_DelayedSaves[i];
|
|
if(dfw->data != NULL)
|
|
DelayedWriteFile(i);
|
|
}
|
|
|
|
if(dev_info) {
|
|
Layout l;
|
|
Layout_Init(&l);
|
|
Bdisp_AllClr_VRAM();
|
|
Layout_CenteredText(&l, "Developer info");
|
|
Layout_Spacing(&l, 12);
|
|
|
|
Layout_Text(&l, "Memory allocated:", "%d kB",
|
|
CGD_Stats.MemoryAllocated >> 10);
|
|
Layout_Spacing(&l, 12);
|
|
|
|
Layout_Text(&l, "Lumps loaded:", "%d (%d kB)",
|
|
CGD_Stats.LumpsLoaded,
|
|
(int)(CGD_Stats.LumpsLoadedTotal >> 10));
|
|
Layout_Text(&l, "... of which unaligned:", "%d (%d kB)",
|
|
CGD_Stats.UnalignedLumpsLoaded,
|
|
(int)(CGD_Stats.UnalignedLumpsLoadedTotal >> 10));
|
|
Layout_Text(&l, "Lumps referenced:", "%d (%d kB)",
|
|
CGD_Stats.LumpsReferenced,
|
|
(int)(CGD_Stats.LumpsReferencedTotal >> 10));
|
|
Bdisp_FrameAndColor(3, 16);
|
|
Bdisp_FrameAndColor(1, 0);
|
|
Bdisp_PutDisp_DD();
|
|
while(PRGM_GetKey() != 0) {}
|
|
int key;
|
|
GetKey(&key);
|
|
}
|
|
|
|
prof_quit();
|
|
return 1;
|
|
}
|
|
|
|
//todo: wrapper pro (patch_t*), + flash
|