mirror of
https://github.com/RetroDECK/Supermodel.git
synced 2024-11-26 15:45:41 +00:00
510 lines
16 KiB
C++
510 lines
16 KiB
C++
/**
|
|
** Supermodel
|
|
** A Sega Model 3 Arcade Emulator.
|
|
** Copyright 2011 Bart Trzynadlowski, Nik Henson
|
|
**
|
|
** This file is part of Supermodel.
|
|
**
|
|
** Supermodel is free software: you can redistribute it and/or modify it under
|
|
** the terms of the GNU General Public License as published by the Free
|
|
** Software Foundation, either version 3 of the License, or (at your option)
|
|
** any later version.
|
|
**
|
|
** Supermodel is distributed in the hope that it will be useful, but WITHOUT
|
|
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
** FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
** more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License along
|
|
** with Supermodel. If not, see <http://www.gnu.org/licenses/>.
|
|
**/
|
|
|
|
/*
|
|
* ROMLoad.cpp
|
|
*
|
|
* ROM loading functions.
|
|
*/
|
|
|
|
#include <new>
|
|
#include <cstring>
|
|
#include "Supermodel.h"
|
|
#include "Pkgs/unzip.h"
|
|
|
|
static bool isPowerOfTwo(long x)
|
|
{
|
|
while (((x & 1) == 0) && x > 1) // while x is even and > 1
|
|
x >>= 1;
|
|
return (x == 1);
|
|
}
|
|
|
|
// Sega Bass Fishing
|
|
static struct GameInfo cromInfo =
|
|
{
|
|
"crom.bin",
|
|
NULL,
|
|
"Custom CROM Image",
|
|
"Bart Trzynadlowski",
|
|
2015,
|
|
0x10,
|
|
0, // size of CROM image (filled in at run time)
|
|
false, // no need to mirror anything
|
|
0, // no VROM
|
|
0, // no sample ROMs
|
|
GAME_INPUT_COMMON|GAME_INPUT_JOYSTICK1,
|
|
0, // no MPEG board
|
|
false, // no drive board
|
|
{
|
|
{ NULL, false, NULL, 0, 0, 0, 0, 0, false }
|
|
}
|
|
};
|
|
|
|
static GameInfo * LoadCROMDirect(const struct ROMMap *Map, const char *file)
|
|
{
|
|
FILE *fp = fopen(file, "rb");
|
|
if (!fp)
|
|
{
|
|
ErrorLog("Could not open '%s'.", file);
|
|
return NULL;
|
|
}
|
|
fseek(fp, 0, SEEK_END);
|
|
long fileSize = ftell(fp);
|
|
rewind(fp);
|
|
if (fileSize > 0x800000)
|
|
{
|
|
ErrorLog("CROM image exceeds 8MB.");
|
|
fclose(fp);
|
|
return NULL;
|
|
}
|
|
if (!isPowerOfTwo(fileSize))
|
|
{
|
|
ErrorLog("CROM image size is not a power of 2.");
|
|
fclose(fp);
|
|
return NULL;
|
|
}
|
|
while (Map->region && strcmp(Map->region, "CROM"))
|
|
++Map;
|
|
if (!Map->region)
|
|
{
|
|
ErrorLog("Internal error: No CROM region in ROM map!");
|
|
fclose(fp);
|
|
return NULL;
|
|
}
|
|
// Read file into upper part of CROM region
|
|
fread(Map->ptr + 0x800000 - fileSize, sizeof(UINT8), fileSize, fp);
|
|
fclose(fp);
|
|
// Return fake game info structure
|
|
cromInfo.cromSize = fileSize;
|
|
return &cromInfo;
|
|
}
|
|
|
|
/*
|
|
* CopyRegion(dest, destOffset, destSize, src, srcSize):
|
|
*
|
|
* Repeatedly mirror (copy) to destination from source until destination is
|
|
* filled.
|
|
*
|
|
* Parameters:
|
|
* dest Destination region.
|
|
* destOffset Offset within destination to begin mirroring to.
|
|
* destSize Size in bytes of destination region.
|
|
* src Source region to copy from.
|
|
* srcSize Size of region to copy from.
|
|
*/
|
|
void CopyRegion(UINT8 *dest, unsigned destOffset, unsigned destSize, UINT8 *src, unsigned srcSize)
|
|
{
|
|
if (!destSize || !srcSize)
|
|
return;
|
|
while (destOffset < destSize)
|
|
{
|
|
// If we'll overrun the destination, trim the copy length
|
|
if ((destOffset+srcSize) >= destSize)
|
|
srcSize = destSize-destOffset;
|
|
|
|
// Copy!
|
|
memcpy(&dest[destOffset], src, srcSize);
|
|
|
|
destOffset += srcSize;
|
|
}
|
|
}
|
|
|
|
// Search for a ROM within a single game based on its CRC
|
|
static bool FindROMByCRCInGame(const struct GameInfo **gamePtr, int *romIdxPtr, const struct GameInfo *Game, UINT32 crc)
|
|
{
|
|
for (int j = 0; Game->ROM[j].region != NULL; j++)
|
|
{
|
|
if (crc == Game->ROM[j].crc) // found it!
|
|
{
|
|
*gamePtr = Game; // I know this seems redundant, but we do it here because FindROMByCRC() uses this function
|
|
*romIdxPtr = j;
|
|
return OKAY;
|
|
}
|
|
}
|
|
|
|
return FAIL;
|
|
}
|
|
|
|
// Search for a ROM in the complete game list based on CRC32 and return its GameInfo and ROMInfo entries
|
|
static bool FindROMByCRC(const struct GameInfo **gamePtr, int *romIdxPtr, const struct GameInfo *GameList, const struct GameInfo *TryGame, UINT32 crc)
|
|
{
|
|
if (TryGame != NULL)
|
|
{
|
|
if (FindROMByCRCInGame(gamePtr, romIdxPtr, TryGame, crc) == OKAY)
|
|
return OKAY;
|
|
}
|
|
|
|
for (int i = 0; GameList[i].title != NULL; i++)
|
|
{
|
|
if (FindROMByCRCInGame(gamePtr, romIdxPtr, &(GameList[i]), crc) == OKAY)
|
|
return OKAY;
|
|
}
|
|
|
|
return FAIL;
|
|
}
|
|
|
|
// Returns true if this ROM appears only a single time in the entire game list (ie., it is not shared between games)
|
|
static bool ROMIsUnique(const struct GameInfo *GameList, UINT32 crc)
|
|
{
|
|
int timesFound = 0;
|
|
|
|
for (int i = 0; GameList[i].title != NULL; i++)
|
|
{
|
|
for (int j = 0; GameList[i].ROM[j].region != NULL; j++)
|
|
{
|
|
if (crc == GameList[i].ROM[j].crc)
|
|
timesFound++;
|
|
}
|
|
}
|
|
|
|
return (timesFound == 1) ? true : false;
|
|
}
|
|
|
|
static void ByteSwap(UINT8 *buf, unsigned size)
|
|
{
|
|
for (size_t i = 0; i < size; i += 2)
|
|
{
|
|
UINT8 x = buf[i+0];
|
|
buf[i+0] = buf[i+1];
|
|
buf[i+1] = x;
|
|
}
|
|
}
|
|
|
|
// Load a single ROM file
|
|
static bool LoadROM(UINT8 *buf, unsigned bufSize, const struct ROMMap *Map, const struct ROMInfo *ROM, unzFile zf, const char *zipFile, bool loadAll)
|
|
{
|
|
char file[2048+1];
|
|
unz_file_info fileInfo;
|
|
|
|
// Read the file into the buffer
|
|
int err = unzGetCurrentFileInfo(zf, &fileInfo, file, 2048, NULL, 0, NULL, 0);
|
|
if (err != UNZ_OK)
|
|
return ErrorLog("Unable to extract a file name from '%s'.", zipFile);
|
|
if (fileInfo.uncompressed_size != ROM->fileSize)
|
|
return ErrorLog("'%s' in '%s' is not the correct size (must be %d bytes).", file, zipFile, ROM->fileSize);
|
|
err = unzOpenCurrentFile(zf);
|
|
if (UNZ_OK != err)
|
|
return ErrorLog("Unable to read '%s' from '%s'.", file, zipFile);
|
|
size_t bytes = unzReadCurrentFile(zf, buf, bufSize);
|
|
if (bytes != ROM->fileSize)
|
|
{
|
|
unzCloseCurrentFile(zf);
|
|
return ErrorLog("Unable to read '%s' from '%s'.", file, zipFile);
|
|
}
|
|
err = unzCloseCurrentFile(zf);
|
|
if (UNZ_CRCERROR == err)
|
|
ErrorLog("CRC error reading '%s' from '%s'. File may be corrupt.", file, zipFile);
|
|
|
|
// Byte swap
|
|
if (ROM->byteSwap)
|
|
ByteSwap(buf, ROM->fileSize);
|
|
|
|
// Find out how to map the ROM and do it
|
|
for (size_t i = 0; Map[i].region != NULL; i++)
|
|
{
|
|
if (!strcmp(Map[i].region, ROM->region))
|
|
{
|
|
size_t destIdx = ROM->offset;
|
|
for (size_t srcIdx = 0; srcIdx < ROM->fileSize; )
|
|
{
|
|
for (size_t j = 0; j < ROM->groupSize; j++)
|
|
Map[i].ptr[destIdx+j] = buf[srcIdx++];
|
|
destIdx += ROM->stride;
|
|
}
|
|
return OKAY;
|
|
}
|
|
}
|
|
|
|
if (loadAll) // need to load all ROMs, so there should be no unmapped regions
|
|
return ErrorLog("%s:%d: No mapping for '%s'.", __FILE__, __LINE__, ROM->region);
|
|
else
|
|
return OKAY;
|
|
}
|
|
|
|
/*
|
|
* LoadROMSetFromZIPFile(Map, GameList, zipFile):
|
|
*
|
|
* Loads a complete ROM set from a ZIP archive. Automatically detects the game.
|
|
* If multiple games exist within the archive, an error will be printed and all
|
|
* but the first detected game will be ignored.
|
|
*
|
|
* Parameters:
|
|
* Map A list of pointers to the memory buffers for each ROM
|
|
* region.
|
|
* GameList List of all supported games and their ROMs.
|
|
* zipFile ZIP file to load from.
|
|
* loadAll If true, will check to ensure all ROMs were loaded.
|
|
* Otherwise, omits this check and loads only specified
|
|
* regions.
|
|
*
|
|
* Returns:
|
|
* Pointer to GameInfo struct for loaded game if successful, NULL
|
|
* otherwise. Prints errors.
|
|
*/
|
|
const struct GameInfo * LoadROMSetFromZIPFile(const struct ROMMap *Map, const struct GameInfo *GameList, const char *zipFile, bool loadAll)
|
|
{
|
|
if (!strcmp(zipFile, "crom.bin"))
|
|
return LoadCROMDirect(Map, zipFile);
|
|
|
|
const struct GameInfo *Game = NULL;
|
|
const struct GameInfo *CurGame; // this is the game to which the last ROM found is thought to belong
|
|
unz_file_info fileInfo;
|
|
string zipFileParent, zfpErr = "";
|
|
int romIdx = 0; // index within Game->ROM
|
|
unsigned romsFound[sizeof(Game->ROM)/sizeof(struct ROMInfo)];
|
|
bool multipleGameError = false;
|
|
|
|
// Try to open file
|
|
unzFile zf = unzOpen(zipFile);
|
|
if (NULL == zf)
|
|
{
|
|
ErrorLog("Could not open '%s'.", zipFile);
|
|
return NULL;
|
|
}
|
|
|
|
// First pass: scan every file and determine the game
|
|
int err = unzGoToFirstFile(zf);
|
|
if (UNZ_OK != err)
|
|
{
|
|
ErrorLog("Unable to read the contents of '%s' (code %X)", zipFile, err);
|
|
return NULL;
|
|
}
|
|
for (; err != UNZ_END_OF_LIST_OF_FILE; err = unzGoToNextFile(zf))
|
|
{
|
|
// Identify the file we're looking at
|
|
err = unzGetCurrentFileInfo(zf, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
|
|
if (err != UNZ_OK)
|
|
continue;
|
|
if (OKAY != FindROMByCRC(&CurGame, &romIdx, GameList, Game, fileInfo.crc))
|
|
continue;
|
|
|
|
// If the ROM appears in multiple games, do not use it to identify the game!
|
|
if (!ROMIsUnique(GameList, fileInfo.crc))
|
|
continue;
|
|
|
|
// We have a unique ROM used by a single game; identify that game
|
|
if (Game == NULL) // this is the first game we've identified within the ZIP
|
|
{
|
|
Game = CurGame;
|
|
DebugLog("ROM set identified: %s (%s), %s\n", Game->id, Game->title, zipFile);
|
|
}
|
|
else // we've already identified a game
|
|
{
|
|
if (CurGame != Game) // another game?
|
|
{
|
|
DebugLog("%s also contains: %s (%s)\n", zipFile, CurGame->id, CurGame->title);
|
|
if (multipleGameError == false) // only warn about this once
|
|
{
|
|
ErrorLog("Multiple games were found in '%s'; loading '%s'.", zipFile, Game->title);
|
|
multipleGameError = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Game == NULL)
|
|
{
|
|
ErrorLog("No Model 3 games found in '%s'.", zipFile);
|
|
unzClose(zf);
|
|
return NULL;
|
|
}
|
|
|
|
unzFile zfp = 0;
|
|
if (CurGame->parent)
|
|
{
|
|
// Create parent zip file name
|
|
string path = "";
|
|
if (strstr(zipFile, "/"))
|
|
{
|
|
path = string(zipFile);
|
|
path = path.substr(0, path.find_last_of("/") + 1);
|
|
}
|
|
if (strstr(zipFile, "\\"))
|
|
{
|
|
path = string(zipFile);
|
|
path = path.substr(0, path.find_last_of("\\") + 1);
|
|
}
|
|
zipFileParent = path + CurGame->parent + ".zip";
|
|
|
|
// Create error message
|
|
zfpErr = " or '" + string(zipFileParent) + "'";
|
|
|
|
// Try to open file
|
|
zfp = unzOpen(zipFileParent.c_str());
|
|
if (NULL == zfp)
|
|
{
|
|
ErrorLog("Parent ROM set '%s' is missing.", zipFileParent.c_str());
|
|
unzClose(zf);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
// Second pass: check if all ROM files for the identified game are present
|
|
err = unzGoToFirstFile(zf);
|
|
if (UNZ_OK != err)
|
|
{
|
|
ErrorLog("Unable to read the contents of '%s' (code %X)", zipFile, err);
|
|
unzClose(zf);
|
|
return NULL;
|
|
}
|
|
memset(romsFound, 0, sizeof(romsFound)); // here, romsFound[] indicates which ROMs were found in the ZIP file for the game
|
|
for (; err != UNZ_END_OF_LIST_OF_FILE; err = unzGoToNextFile(zf))
|
|
{
|
|
// Identify the file we're looking at
|
|
err = unzGetCurrentFileInfo(zf, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
|
|
if (err != UNZ_OK)
|
|
continue;
|
|
|
|
// If it's not part of the game we've identified, skip it
|
|
if (OKAY != FindROMByCRCInGame(&CurGame, &romIdx, Game, fileInfo.crc))
|
|
continue;
|
|
|
|
// If we have found a ROM for the correct game, mark its corresponding indicator
|
|
romsFound[romIdx] = 1;
|
|
}
|
|
if (zfp)
|
|
{
|
|
err = unzGoToFirstFile(zfp);
|
|
if (UNZ_OK != err)
|
|
{
|
|
ErrorLog("Unable to read the contents of '%s' (code %X)", zipFileParent.c_str(), err);
|
|
unzClose(zf);
|
|
return NULL;
|
|
}
|
|
for (; err != UNZ_END_OF_LIST_OF_FILE; err = unzGoToNextFile(zfp))
|
|
{
|
|
// Identify the file we're looking at
|
|
err = unzGetCurrentFileInfo(zfp, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
|
|
if (err != UNZ_OK)
|
|
continue;
|
|
|
|
// If it's not part of the game we've identified, skip it
|
|
if (OKAY != FindROMByCRCInGame(&CurGame, &romIdx, Game, fileInfo.crc))
|
|
continue;
|
|
|
|
// If we have found a ROM for the correct game, mark its corresponding indicator
|
|
romsFound[romIdx] = 1;
|
|
}
|
|
}
|
|
|
|
// Compute how many ROM files this game has
|
|
size_t numROMs = 0;
|
|
for (; Game->ROM[numROMs].region != NULL; numROMs++)
|
|
;
|
|
|
|
// If not all ROMs were present, tell the user
|
|
err = OKAY;
|
|
for (size_t i = 0; i < numROMs; i++)
|
|
{
|
|
if ((0 == romsFound[i]) && !Game->ROM[i].optional) // if not found and also not optional
|
|
err |= (int) ErrorLog("'%s' (CRC=%08X) is missing from '%s'%s.", Game->ROM[i].fileName, Game->ROM[i].crc, zipFile, zfp ? zfpErr.c_str() : "");
|
|
}
|
|
if (err != OKAY)
|
|
{
|
|
unzClose(zf);
|
|
if (zfp) unzClose(zfp);
|
|
return NULL;
|
|
}
|
|
|
|
// Allocate a scratch buffer big enough to hold the biggest ROM
|
|
size_t maxSize = 0;
|
|
for (size_t i = 0; i < numROMs; i++)
|
|
{
|
|
if (Game->ROM[i].fileSize > maxSize)
|
|
maxSize = Game->ROM[i].fileSize;
|
|
}
|
|
UINT8 *buf = new(std::nothrow) UINT8[maxSize];
|
|
if (NULL == buf)
|
|
{
|
|
unzClose(zf);
|
|
if (zfp) unzClose(zfp);
|
|
ErrorLog("Insufficient memory to load ROM files (%d bytes).", maxSize);
|
|
return NULL;
|
|
}
|
|
|
|
// Third pass: load the ROMs
|
|
memset(romsFound, 0, sizeof(romsFound)); // now, romsFound[] is used to indicate whether we successfully loaded the ROM
|
|
err = unzGoToFirstFile(zf);
|
|
if (UNZ_OK != err)
|
|
{
|
|
ErrorLog("Unable to read the contents of '%s' (code %X).", zipFile, err);
|
|
err = FAIL;
|
|
goto Quit;
|
|
}
|
|
for (; err != UNZ_END_OF_LIST_OF_FILE; err = unzGoToNextFile(zf))
|
|
{
|
|
err = unzGetCurrentFileInfo(zf, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
|
|
if (err != UNZ_OK)
|
|
continue;
|
|
|
|
// If this ROM is not part of the game we're loading, skip it
|
|
if (OKAY != FindROMByCRCInGame(&CurGame, &romIdx, Game, fileInfo.crc))
|
|
continue;
|
|
|
|
// Load the ROM and mark that we did so successfully
|
|
if (OKAY == LoadROM(buf, maxSize, Map, &Game->ROM[romIdx], zf, zipFile, loadAll))
|
|
romsFound[romIdx] = 1; // success! mark as loaded
|
|
}
|
|
if (zfp)
|
|
{
|
|
err = unzGoToFirstFile(zfp);
|
|
if (UNZ_OK != err)
|
|
{
|
|
ErrorLog("Unable to read the contents of '%s' (code %X).", zipFileParent.c_str(), err);
|
|
err = FAIL;
|
|
goto Quit;
|
|
}
|
|
for (; err != UNZ_END_OF_LIST_OF_FILE; err = unzGoToNextFile(zfp))
|
|
{
|
|
err = unzGetCurrentFileInfo(zfp, &fileInfo, NULL, 0, NULL, 0, NULL, 0);
|
|
if (err != UNZ_OK)
|
|
continue;
|
|
|
|
// If this ROM is not part of the game we're loading, skip it
|
|
if (OKAY != FindROMByCRCInGame(&CurGame, &romIdx, Game, fileInfo.crc))
|
|
continue;
|
|
|
|
// Load the ROM and mark that we did so successfully
|
|
if (OKAY == LoadROM(buf, maxSize, Map, &Game->ROM[romIdx], zfp, zipFileParent.c_str(), loadAll))
|
|
romsFound[romIdx] = 1; // success! mark as loaded
|
|
}
|
|
}
|
|
|
|
// Ensure all ROMs were loaded
|
|
if (loadAll)
|
|
{
|
|
// See if any ROMs (that are not optional) could not be found
|
|
err = OKAY;
|
|
for (size_t i = 0; i < numROMs; i++)
|
|
{
|
|
if (!(romsFound[i] || Game->ROM[i].optional)) // if ROM not found and also not optional
|
|
err = ErrorLog("Could not load '%s' (CRC=%08X) from '%s'%s.", Game->ROM[i].fileName, Game->ROM[i].crc, zipFile, zfp ? zfpErr.c_str() : "");
|
|
}
|
|
}
|
|
else
|
|
err = OKAY;
|
|
|
|
Quit:
|
|
unzClose(zf);
|
|
delete [] buf;
|
|
return (err == OKAY) ? Game : NULL;
|
|
}
|