Emulation/mupen64plus-oldsvn
1
0
Fork 0
mirror of https://github.com/mupen64plus/mupen64plus-oldsvn.git synced 2025-04-02 10:52:35 -04:00
Code Issues Projects Releases Packages Wiki Activity
mupen64plus-oldsvn/main/rom.c

662 lines
23 KiB
C
Raw Permalink Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Mupen64plus - rom.c *
* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
* Copyright (C) 2008 Tillin9 *
* Copyright (C) 2002 Hacktarux *
* *
* This program 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 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <zlib.h>
#include "zip/unzip.h"
#include "bzip2/bzlib.h"
#include "lzma/lzmadec.h"
#include "7zip/7zExtract.h"
#include "7zip/7zCrc.h"
#include "md5.h"
#include "rom.h"
#include "romcache.h"
#include "translate.h"
#include "main.h"
#include "util.h"
#include "../memory/memory.h"
#include "../opengl/osd.h"
#define CHUNKSIZE 1024*128 /* Read files 128KB at a time. */
#ifndef NO_GUI
#include "gui.h"
#endif
/* Global loaded rom memory space. */
unsigned char* rom;
/* Global loaded rom size. */
int taille_rom;
/* TODO: Replace with a glocal cache_entry. */
rom_header* ROM_HEADER;
rom_settings ROM_SETTINGS;
/* Tests if a file is a valid N64 rom by checking the first 4 bytes. */
int is_valid_rom(unsigned char buffer[4])
{
/* Test if rom is a native .z64 image with header 0x80371240. [ABCD] */
if((buffer[0]==0x80)&&(buffer[1]==0x37)&&(buffer[2]==0x12)&&(buffer[3]==0x40))
return 1;
/* Test if rom is a byteswapped .v64 image with header 0x37804012. [BADC] */
else if((buffer[0]==0x37)&&(buffer[1]==0x80)&&(buffer[2]==0x40)&&(buffer[3]==0x12))
return 1;
/* Test if rom is a wordswapped .n64 image with header 0x40123780. [DCBA] */
else if((buffer[0]==0x40)&&(buffer[1]==0x12)&&(buffer[2]==0x37)&&(buffer[3]==0x80))
return 1;
else
return 0;
}
/* If rom is a .v64 or .n64 image, byteswap or wordswap loadlength amount of
* rom data to native .z64 before forwarding. Makes sure that data extraction
* and MD5ing routines always deal with a .z64 image.
*/
void swap_rom(unsigned char* localrom, unsigned char* imagetype, int loadlength)
{
unsigned char temp;
int i;
/* Btyeswap if .v64 image. */
if(localrom[0]==0x37)
{
*imagetype = V64IMAGE;
for (i = 0; i < loadlength; i+=2)
{
temp=localrom[i];
localrom[i]=localrom[i+1];
localrom[i+1]=temp;
}
}
/* Wordswap if .n64 image. */
else if(localrom[0]==0x40)
{
*imagetype = N64IMAGE;
for (i = 0; i < loadlength; i+=4)
{
temp=localrom[i];
localrom[i]=localrom[1+3];
localrom[i+3]=temp;
temp=localrom[i+1];
localrom[i+1]=localrom[i+2];
localrom[i+2]=temp;
}
}
else
*imagetype = Z64IMAGE;
}
/* Open a file and test if its an uncompressed rom, bzip2ed rom, lzma stream compressed
* rom, or gzipped rom. If so, set compressiontype and load *loadlength of the rom
* into the returned pointer. On failure return NULL.
*/
unsigned char* load_single_rom(const char* filename, int* romsize, unsigned char* compressiontype, int* loadlength)
{
int i;
unsigned short romread = 0;
unsigned char buffer[4];
unsigned char* localrom;
FILE* romfile;
/* Uncompressed roms. */
romfile=fopen(filename, "rb");
if(romfile!=NULL)
{
fread(buffer, 1, 4, romfile);
if(is_valid_rom(buffer))
{
*compressiontype = UNCOMPRESSED;
fseek(romfile, 0L, SEEK_END);
*romsize=ftell(romfile);
fseek(romfile, 0L, SEEK_SET);
localrom = (unsigned char*)malloc(*loadlength*sizeof(unsigned char));
if(localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
fread(localrom, 1, *loadlength, romfile);
romread = 1;
}
if(romread==0)
{
/* Bzip2 roms. */
BZFILE* bzromfile;
int bzerror;
fseek(romfile, 0L, SEEK_SET);
bzromfile = BZ2_bzReadOpen(&bzerror, romfile, 0, 0, NULL, 0);
if(bzerror==BZ_OK)
BZ2_bzRead(&bzerror, bzromfile, buffer, 4);
if(bzerror==BZ_OK)
{
if(is_valid_rom(buffer))
{
*compressiontype = BZIP2_COMPRESSION;
fseek(romfile, 0L, SEEK_SET);
bzromfile = BZ2_bzReadOpen(&bzerror, romfile, 0, 0, NULL, 0);
*romsize=0;
localrom=NULL;
for( i = 0; bzerror==BZ_OK; ++i )
{
localrom = (unsigned char*)realloc(localrom, (i+1)*CHUNKSIZE*sizeof(unsigned char));
if(localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
*romsize += BZ2_bzRead(&bzerror, bzromfile, localrom+(i*CHUNKSIZE), CHUNKSIZE);
}
if(bzerror==BZ_STREAM_END)
{
localrom = (unsigned char*)realloc(localrom,*loadlength*sizeof(unsigned char));
romread = 1;
}
else
free(localrom);
}
}
BZ2_bzReadClose(&bzerror, bzromfile);
}
if(romread==0)
{
/* LZMA roms. */
fseek(romfile, 0L, SEEK_SET);
int lzmastatus;
lzmadec_stream stream;
stream.lzma_alloc = NULL;
stream.lzma_free = NULL;
stream.opaque = NULL;
stream.avail_in = 0;
stream.next_in = NULL;
/* Minimum size to get decoded blocks back is 45.
LZMA has 13 byte headers, likely 32 byte internal buffer. */
unsigned char* buffer_in = (unsigned char*)malloc(45*sizeof(unsigned char));
unsigned char* buffer_out = (unsigned char*)malloc(45*128*sizeof(unsigned char));
if(buffer_in==NULL||buffer_out==NULL||lzmadec_init(&stream)!=LZMADEC_OK)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
fread(buffer_in, sizeof(unsigned char), 45, romfile);
stream.next_in = buffer_in;
stream.avail_in = 45;
stream.next_out = buffer_out;
stream.avail_out = 45;
lzmastatus = lzmadec_decode (&stream, (stream.avail_in==0));
if(lzmastatus==LZMADEC_OK&&is_valid_rom(buffer_out))
{
*compressiontype = LZMA_COMPRESSION;
int oldsize;
*romsize = 45 - stream.avail_out;
buffer_in = (unsigned char*)realloc(buffer_in,CHUNKSIZE*sizeof(unsigned char));
buffer_out = (unsigned char*)realloc(buffer_out,CHUNKSIZE*128*sizeof(unsigned char));
localrom = (unsigned char*)malloc(*romsize*sizeof(unsigned char));
if(buffer_in==NULL||buffer_out==NULL||localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
memcpy(localrom,buffer_out, *romsize);
while(lzmastatus==LZMADEC_OK)
{
fread(buffer_in, sizeof(unsigned char), CHUNKSIZE, romfile);
stream.next_in = buffer_in;
stream.avail_in = CHUNKSIZE;
stream.next_out = buffer_out;
stream.avail_out = CHUNKSIZE*128;
lzmastatus = lzmadec_decode (&stream, (stream.avail_in==0));
oldsize = *romsize;
*romsize += CHUNKSIZE*128-stream.avail_out;
localrom = (unsigned char*)realloc(localrom,*romsize*sizeof(unsigned char));
if(localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
memcpy(localrom+oldsize,buffer_out,CHUNKSIZE*128-stream.avail_out);
}
if(lzmastatus==LZMADEC_STREAM_END)
{
lzmadec_end(&stream);
localrom = (unsigned char*)realloc(localrom,*loadlength*sizeof(unsigned char));
romread = 1;
}
}
free(buffer_in);
free(buffer_out);
}
fclose(romfile);
}
/* Gzipped roms. */
if(romread==0)
{
gzFile* gzromfile;
gzromfile=gzopen(filename, "rb");
if(gzromfile!=NULL)
{
gzread(gzromfile, buffer, 4);
if(is_valid_rom(buffer))
{
*compressiontype = GZIP_COMPRESSION;
gzseek(gzromfile, 0L, SEEK_SET);
*romsize=0;
localrom=NULL;
for( i = 0; !gzeof(gzromfile); ++i )
{
localrom = (unsigned char*)realloc(localrom, (i+1)*CHUNKSIZE*sizeof(unsigned char));
if(localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
*romsize += gzread(gzromfile, localrom+(i*CHUNKSIZE), CHUNKSIZE);
}
if(gzeof(gzromfile))
{
localrom = (unsigned char*)realloc(localrom,*loadlength*sizeof(unsigned char));
romread = 1;
}
else
free(localrom);
gzclose(gzromfile);
}
}
}
/* File invalid, or valid rom not found in file. */
if(romread==0)
return NULL;
return localrom;
}
/* Open a file and test if its a zip or 7zip archive. If so load check if *archivefile
* is a rom and load *loadlength into the returned pointer. If *archivefile is not a rom
* in a many file archive, function will keep checking until a rom is found or the
* end of the archive is reached. Returns NULL if unable to find a rom. The large function
* API is to allow for persistent 7zip memory space.
*/
unsigned char* load_archive_rom(const char* filename, int* romsize, unsigned char* compressiontype, int* loadlength, unsigned int* archivefile, UInt32* blockIndex, Byte** outBuffer, size_t* outBufferSize, CFileInStream* archiveStream, CArchiveDatabaseEx* db)
{
int status;
unsigned int filecounter = 0;
unsigned short romread = 0;
unsigned char* localrom;
/* Zip roms. */
unsigned char buffer[4];
unzFile zipromfile;
unz_file_info fileinfo;
char szFileName[256], szExtraField[256], szComment[256];
zipromfile = unzOpen(filename);
if(zipromfile!=NULL)
{
if(unzGoToFirstFile(zipromfile)==UNZ_OK)
{
/* Get first valid rom in archive. */
do
{
if(unzGetCurrentFileInfo(zipromfile, &fileinfo, szFileName, 255,
szExtraField, 255, szComment, 255)!=UNZ_OK)
break;
if(unzOpenCurrentFile(zipromfile)!=UNZ_OK)
break;
if(fileinfo.uncompressed_size>=4&&filecounter>=*archivefile)
{
if(unzReadCurrentFile(zipromfile, buffer, 4)!=4)
break;
if(is_valid_rom(buffer))
{
unzOpenCurrentFile(zipromfile);
*romsize = fileinfo.uncompressed_size;
localrom = (unsigned char*)malloc(*loadlength*sizeof(unsigned char));
if(localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
if(unzReadCurrentFile(zipromfile, localrom, *loadlength)==*loadlength)
{
*compressiontype = ZIP_COMPRESSION;
unzCloseCurrentFile(zipromfile);
romread = 1;
break;
}
else
free(localrom);
}
}
++filecounter;
}
while ((status=unzGoToNextFile(zipromfile)) != UNZ_END_OF_LIST_OF_FILE);
unzClose(zipromfile);
}
}
else
{
/* 7zip */
ISzAlloc allocImp;
allocImp.Free = SzFree;
allocImp.Alloc = SzAlloc;
ISzAlloc allocTempImp;
allocTempImp.Alloc = SzAllocTemp;
allocTempImp.Free = SzFreeTemp;
if(archiveStream->File==NULL)
{
archiveStream->File = fopen(filename, "rb");
if(archiveStream->File==NULL)
return NULL;
status = SzArchiveOpen(&(archiveStream->InStream), db, &allocImp, &allocTempImp);
if(status==SZ_OK)
printf("Deflating 7zip archive.\n");
}
else
status = SZ_OK;
if(status==SZ_OK)
{
for (filecounter = *archivefile; filecounter < db->Database.NumFiles; ++filecounter)
{
size_t offset;
size_t outSizeProcessed;
CFileItem *f = db->Database.Files + filecounter;
status = SzExtract(&(archiveStream->InStream), db, filecounter, blockIndex, outBuffer, outBufferSize, &offset, &outSizeProcessed, &allocImp, &allocTempImp);
if(status!=SZ_OK)
{
if(status==SZE_NOTIMPL)
printf("7zip decoder doesn't support this archive.");
else if(status==SZE_OUTOFMEMORY)
printf("7zip decoder can not allocate memory\n");
else if(status==SZE_CRC_ERROR)
printf("7zip CRC error");
else
printf("7zip Error# %d\n", status);
break;
}
if(is_valid_rom(*outBuffer+offset))
{
*romsize=f->Size;
*compressiontype = SZIP_COMPRESSION;
localrom = (unsigned char*)malloc(*loadlength*sizeof(unsigned char));
if(localrom==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return NULL;
}
memcpy(localrom,*outBuffer+offset,*loadlength);
romread = 1;
break;
}
}
}
}
/* File invalid, or valid rom not found in file. */
if(romread==0)
return NULL;
*archivefile = filecounter;
return localrom;
}
static int ask_bad(void)
{
#ifndef NO_GUI
if(!g_Noask)
return gui_message(GUI_MESSAGE_CONFIRM,
tr("The rom you are trying to load is probably a bad dump!\n"
"Be warned that this will probably give unexpected results.\n"
"Do you still want to run it?"));
else
#endif
printf(tr("The rom you are trying to load is probably a bad dump!\n"
"Be warned that this will probably give unexpected results.\n"));
return 1;
}
static int ask_hack(void)
{
#ifndef NO_GUI
if(!g_Noask)
return gui_message(GUI_MESSAGE_CONFIRM, tr("The rom you are trying to load is probably a hack!\n"
"Be warned that this will probably give unexpected results.\n"
"Do you still want to run it?"));
else
#endif
printf(tr("The rom you are trying to load is probably a hack!\n"
"Be warned that this will probably give unexpected results.\n"));
return 1;
}
int open_rom(const char* filename, unsigned int archivefile)
{
if(g_EmulatorRunning)
{
#ifndef NO_GUI
if(!g_Noask)
{
if(!gui_message(GUI_MESSAGE_CONFIRM,
tr("Emulation is running. Do you want to\n"
"stop it and load the selected rom?")))
return -1;
}
#endif
stopEmulation();
}
md5_state_t state;
md5_byte_t digest[16];
romdatabase_entry* entry;
char buffer[PATH_MAX];
unsigned char compressiontype, imagetype;
int i;
if(rom)
free(rom);
/* Clear Byte-swapped flag, since ROM is now deleted. */
g_MemHasBeenBSwapped = 0;
UInt32 blockIndex = 0xFFFFFFFF;
Byte* outBuffer = NULL;
size_t outBufferSize = 0;
CFileInStream archiveStream;
archiveStream.File = NULL;
archiveStream.InStream.Read = SzFileReadImp;
archiveStream.InStream.Seek = SzFileSeekImp;
CArchiveDatabaseEx db;
SzArDbExInit(&db);
CrcGenerateTable();
strncpy(buffer, filename, PATH_MAX-1);
buffer[PATH_MAX-1] = 0;
if ((rom=load_single_rom(filename, &taille_rom, &compressiontype, &taille_rom))==NULL)
{
if((rom=load_archive_rom(filename, &taille_rom, &compressiontype, &taille_rom, &archivefile, &blockIndex, &outBuffer, &outBufferSize, &archiveStream, &db))==NULL)
{
error_message(tr("Couldn't load Rom!"));
return -1;
}
}
if(outBuffer)
free(outBuffer);
if(archiveStream.File)
fclose(archiveStream.File);
SzArDbExFree(&db, free);
swap_rom(rom, &imagetype, taille_rom);
compressionstring(compressiontype, buffer);
printf("Compression: %s\n", buffer);
imagestring(imagetype, buffer);
printf("Imagetype: %s\n", buffer);
printf("Rom size: %d bytes (or %d Mb or %d Megabits)\n",
taille_rom, taille_rom/1024/1024, taille_rom/1024/1024*8);
/* TODO: Replace the following validation code with fill_entry(). */
/* Load rom settings and check if it's a good dump. */
md5_init(&state);
md5_append(&state, (const md5_byte_t*)rom, taille_rom);
md5_finish(&state, digest);
for ( i = 0; i < 16; ++i )
sprintf(buffer+i*2, "%02X", digest[i]);
buffer[32] = '\0';
strcpy(ROM_SETTINGS.MD5, buffer);
printf("MD5: %s\n", buffer);
if(ROM_HEADER)
free(ROM_HEADER);
ROM_HEADER = malloc(sizeof(rom_header));
if(ROM_HEADER==NULL)
{
fprintf(stderr, "%s, %d: Out of memory!\n", __FILE__, __LINE__);
return 0;
}
memcpy(ROM_HEADER, rom, sizeof(rom_header));
trim((char*)ROM_HEADER->nom); /* Remove trailing whitespace from Rom name. */
printf("%x %x %x %x\n", ROM_HEADER->init_PI_BSB_DOM1_LAT_REG,
ROM_HEADER->init_PI_BSB_DOM1_PGS_REG,
ROM_HEADER->init_PI_BSB_DOM1_PWD_REG,
ROM_HEADER->init_PI_BSB_DOM1_PGS_REG2);
printf("ClockRate = %x\n", sl((unsigned int)ROM_HEADER->ClockRate));
printf("Version: %x\n", sl((unsigned int)ROM_HEADER->Release));
printf("CRC: %x %x\n", sl((unsigned int)ROM_HEADER->CRC1), sl((unsigned int)ROM_HEADER->CRC2));
printf ("Name: %s\n", ROM_HEADER->nom);
if(sl(ROM_HEADER->Manufacturer_ID) == 'N')
printf ("Manufacturer: Nintendo\n");
else
printf("Manufacturer: %x\n", (unsigned int)(ROM_HEADER->Manufacturer_ID));
printf("Cartridge_ID: %x\n", ROM_HEADER->Cartridge_ID);
countrycodestring(ROM_HEADER->Country_code, buffer);
printf("Country: %s\n", buffer);
printf ("PC = %x\n", sl((unsigned int)ROM_HEADER->PC));
if((entry=ini_search_by_md5(digest))==&empty_entry)
{
if((entry=ini_search_by_crc(sl(ROM_HEADER->CRC1),sl(ROM_HEADER->CRC2)))==&empty_entry)
{
strcpy(ROM_SETTINGS.goodname, (char*)ROM_HEADER->nom);
strcat(ROM_SETTINGS.goodname, " (unknown rom)");
printf("%s\n", ROM_SETTINGS.goodname);
ROM_SETTINGS.eeprom_16kb = 0;
return 0;
}
}
unsigned short close = 0;
char* s = entry->goodname;
if(s!=NULL)
{
for ( i = strlen(s); i > 1; --i )
if(i!=0)
{
if(s[i-1]=='['&&(s[i]=='T'||s[i]=='t'||s[i]=='h'||s[i]=='f'))
{
if(!ask_hack())
close = 1;
}
else if(s[i-1]=='['&&s[i]=='b')
{
if(!ask_bad())
close = 1;
}
}
}
if(close)
{
free(rom);
rom = NULL;
free(ROM_HEADER);
ROM_HEADER = NULL;
main_message(0, 1, 0, OSD_BOTTOM_LEFT, tr("Rom closed."));
return -3;
}
strncpy(ROM_SETTINGS.goodname, entry->goodname, 255);
ROM_SETTINGS.goodname[255] = '\0';
if(entry->savetype==EEPROM_16KB)
ROM_SETTINGS.eeprom_16kb = 1;
printf("EEPROM type: %d\n", ROM_SETTINGS.eeprom_16kb);
return 0;
}
int close_rom(void)
{
if(g_EmulatorRunning)
stopEmulation();
if(ROM_HEADER)
{
free(ROM_HEADER);
ROM_HEADER = NULL;
}
if(rom)
{
free(rom);
rom = NULL;
}
else
return -1;
/* Clear Byte-swapped flag, since ROM is now deleted. */
g_MemHasBeenBSwapped = 0;
main_message(0, 1, 0, OSD_BOTTOM_LEFT, tr("Rom closed."));
return 0;
}
Reference in a new issue View git blame Copy permalink