mupenEntry* ini_search_by_CRC(const char *crc)
{
char t[3];
int i;
iniElem *aux;
if (ini.comment == NULL) return emptyEntry;
t[0] = crc[0];
t[1] = crc[1];
t[2] = 0;
sscanf(t, "%X", &i);
aux = ini.CRC_lists[i];
while (aux != NULL && strncmp(aux->entry.CRC, crc, 21))
aux = aux->next_crc;
if (aux == NULL) return NULL;
if (strcmp(aux->entry.refMD5, ""))
{
mupenEntry* temp = ini_search_by_md5(aux->entry.refMD5);
if (strncmp(aux->entry.CRC, temp->CRC, 21))
return &(aux->entry);
else
return temp;
}
else
return &(aux->entry);
}
static size_t romdatabase_resolve_round(void)
{
romdatabase_search *entry;
romdatabase_entry *ref;
size_t skipped = 0;
/* Resolve RefMD5 references */
for (entry = g_romdatabase.list; entry; entry = entry->next_entry) {
if (!entry->entry.refmd5)
continue;
ref = ini_search_by_md5(entry->entry.refmd5);
if (!ref) {
DebugMessage(M64MSG_WARNING, "ROM Database: Error solving RefMD5s");
continue;
}
/* entry is not yet resolved, skip for now */
if (ref->refmd5) {
skipped++;
continue;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_GOODNAME) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_GOODNAME)) {
entry->entry.goodname = strdup(ref->goodname);
if (entry->entry.goodname)
entry->entry.set_flags |= ROMDATABASE_ENTRY_GOODNAME;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_CRC) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_CRC)) {
entry->entry.crc1 = ref->crc1;
entry->entry.crc2 = ref->crc2;
entry->entry.set_flags |= ROMDATABASE_ENTRY_CRC;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_STATUS) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_STATUS)) {
entry->entry.status = ref->status;
entry->entry.set_flags |= ROMDATABASE_ENTRY_STATUS;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_SAVETYPE) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_SAVETYPE)) {
entry->entry.savetype = ref->savetype;
entry->entry.set_flags |= ROMDATABASE_ENTRY_SAVETYPE;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_PLAYERS) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_PLAYERS)) {
entry->entry.players = ref->players;
entry->entry.set_flags |= ROMDATABASE_ENTRY_PLAYERS;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_RUMBLE) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_RUMBLE)) {
entry->entry.rumble = ref->rumble;
entry->entry.set_flags |= ROMDATABASE_ENTRY_RUMBLE;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_COUNTEROP) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_COUNTEROP)) {
entry->entry.countperop = ref->countperop;
entry->entry.set_flags |= ROMDATABASE_ENTRY_COUNTEROP;
}
if (!isset_bitmask(entry->entry.set_flags, ROMDATABASE_ENTRY_CHEATS) &&
isset_bitmask(ref->set_flags, ROMDATABASE_ENTRY_CHEATS)) {
if (ref->cheats)
entry->entry.cheats = strdup(ref->cheats);
entry->entry.set_flags |= ROMDATABASE_ENTRY_CHEATS;
}
free(entry->entry.refmd5);
entry->entry.refmd5 = NULL;
}
return skipped;
}
m64p_error open_rom(const unsigned char* romimage, unsigned int size)
{
md5_state_t state;
md5_byte_t digest[16];
romdatabase_entry* entry;
char buffer[256];
unsigned char imagetype;
int i;
/* check input requirements */
if (g_rom != NULL)
{
DebugMessage(M64MSG_ERROR, "open_rom(): previous ROM image was not freed");
return M64ERR_INTERNAL;
}
if (romimage == NULL || !is_valid_rom(romimage))
{
DebugMessage(M64MSG_ERROR, "open_rom(): not a valid ROM image");
return M64ERR_INPUT_INVALID;
}
/* Clear Byte-swapped flag, since ROM is now deleted. */
g_MemHasBeenBSwapped = 0;
/* allocate new buffer for ROM and copy into this buffer */
g_rom_size = size;
g_rom = (unsigned char *) malloc(size);
if (g_rom == NULL)
return M64ERR_NO_MEMORY;
swap_copy_rom(g_rom, romimage, size, &imagetype);
memcpy(&ROM_HEADER, g_rom, sizeof(m64p_rom_header));
/* Calculate MD5 hash */
md5_init(&state);
md5_append(&state, (const md5_byte_t*)g_rom, g_rom_size);
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);
/* add some useful properties to ROM_PARAMS */
ROM_PARAMS.systemtype = rom_country_code_to_system_type(ROM_HEADER.Country_code);
ROM_PARAMS.countperop = COUNT_PER_OP_DEFAULT;
ROM_PARAMS.vitiming = ALTERNATE_VI_TIMING_DEFAULT;
ROM_PARAMS.countperscanline = DEFAULT_COUNT_PER_SCANLINE;
ROM_PARAMS.cheats = NULL;
memcpy(ROM_PARAMS.headername, ROM_HEADER.Name, 20);
ROM_PARAMS.headername[20] = '\0';
trim(ROM_PARAMS.headername); /* Remove trailing whitespace from ROM name. */
/* Look up this ROM in the .ini file and fill in goodname, etc */
if ((entry=ini_search_by_md5(digest)) != NULL ||
(entry=ini_search_by_crc(sl(ROM_HEADER.CRC1),sl(ROM_HEADER.CRC2))) != NULL)
{
strncpy(ROM_SETTINGS.goodname, entry->goodname, 255);
ROM_SETTINGS.goodname[255] = '\0';
ROM_SETTINGS.savetype = entry->savetype;
ROM_SETTINGS.status = entry->status;
ROM_SETTINGS.players = entry->players;
ROM_SETTINGS.rumble = entry->rumble;
ROM_PARAMS.countperop = entry->countperop;
ROM_PARAMS.vitiming = entry->alternate_vi_timing;
ROM_PARAMS.countperscanline = entry->count_per_scanline;
ROM_PARAMS.cheats = entry->cheats;
}
else
{
strcpy(ROM_SETTINGS.goodname, ROM_PARAMS.headername);
strcat(ROM_SETTINGS.goodname, " (unknown rom)");
ROM_SETTINGS.savetype = NONE;
ROM_SETTINGS.status = 0;
ROM_SETTINGS.players = 0;
ROM_SETTINGS.rumble = 0;
ROM_PARAMS.countperop = COUNT_PER_OP_DEFAULT;
ROM_PARAMS.vitiming = ALTERNATE_VI_TIMING_DEFAULT;
ROM_PARAMS.countperscanline = DEFAULT_COUNT_PER_SCANLINE;
ROM_PARAMS.cheats = NULL;
}
/* print out a bunch of info about the ROM */
DebugMessage(M64MSG_INFO, "Goodname: %s", ROM_SETTINGS.goodname);
DebugMessage(M64MSG_INFO, "Name: %s", ROM_HEADER.Name);
imagestring(imagetype, buffer);
DebugMessage(M64MSG_INFO, "MD5: %s", ROM_SETTINGS.MD5);
DebugMessage(M64MSG_INFO, "CRC: %08" PRIX32 " %08" PRIX32, sl(ROM_HEADER.CRC1), sl(ROM_HEADER.CRC2));
DebugMessage(M64MSG_INFO, "Imagetype: %s", buffer);
DebugMessage(M64MSG_INFO, "Rom size: %d bytes (or %d Mb or %d Megabits)", g_rom_size, g_rom_size/1024/1024, g_rom_size/1024/1024*8);
DebugMessage(M64MSG_VERBOSE, "ClockRate = %" PRIX32, sl(ROM_HEADER.ClockRate));
DebugMessage(M64MSG_INFO, "Version: %" PRIX32, sl(ROM_HEADER.Release));
if(sl(ROM_HEADER.Manufacturer_ID) == 'N')
DebugMessage(M64MSG_INFO, "Manufacturer: Nintendo");
else
DebugMessage(M64MSG_INFO, "Manufacturer: %" PRIX32, sl(ROM_HEADER.Manufacturer_ID));
DebugMessage(M64MSG_VERBOSE, "Cartridge_ID: %" PRIX16, ROM_HEADER.Cartridge_ID);
countrycodestring(ROM_HEADER.Country_code, buffer);
DebugMessage(M64MSG_INFO, "Country: %s", buffer);
DebugMessage(M64MSG_VERBOSE, "PC = %" PRIX32, sl(ROM_HEADER.PC));
DebugMessage(M64MSG_VERBOSE, "Save type: %d", ROM_SETTINGS.savetype);
//Prepare Hack for GOLDENEYE
isGoldeneyeRom = 0;
if(strcmp(ROM_PARAMS.headername, "GOLDENEYE") == 0)
isGoldeneyeRom = 1;
return M64ERR_SUCCESS;
}
int rom_read(const char *argv)
{
md5_state_t state;
md5_byte_t digest[16];
mupenEntry *entry;
char buf[1024], arg[1024], *s;
strncpy(arg, argv, 1000);
if (find_file(arg))
{
strncpy(arg, "roms/", 1000);
if (find_file(strncat(arg, argv, 1000)))
{
rom_file=fopen("path.cfg", "rb");
if(rom_file) fscanf(rom_file, "%1000s", buf);
else buf[0]=0;
if(rom_file) fclose(rom_file);
strncpy(arg, argv, 1000);
if (find_file(strcat(buf, arg)))
{
printf ("file not found or wrong path\n");
return 1;
}
}
}
printf ("file found\n");
/*------------------------------------------------------------------------*/
findsize();
if (rom) free(rom);
rom = malloc(taille_rom);
tmp=0;
if (!z)
{
for (i=0; i<taille_rom;i+=fread(rom+i, 1, 1000, rom_file))
{
if (tmp!=(int)((i/(float)taille_rom)*100))
{
tmp=(int)(i/(float)(taille_rom)*100);
display_loading_progress(tmp);
}
}
}
else if (z == 1)
{
for (i=0; i<taille_rom;i+=gzread(z_rom_file, rom+i, 1000))
{
if (tmp!=(int)((i/(float)taille_rom)*100))
{
tmp=(int)(i/(float)(taille_rom)*100);
display_loading_progress(tmp);
}
}
}
else
{
unzOpenCurrentFile(zip);
for (i=0; i<taille_rom;i+=unzReadCurrentFile(zip, rom+i, 1000))
{
if (tmp!=(int)((i/(float)taille_rom)*100))
{
tmp=(int)(i/(float)(taille_rom)*100);
display_loading_progress(tmp);
}
}
unzCloseCurrentFile(zip);
}
if (!z) fclose(rom_file);
else if (z==1) gzclose(z_rom_file);
else unzClose(zip);
if (rom[0]==0x37)
{
printf ("byteswaping rom...\n");
for (i=0; i<(taille_rom/2); i++)
{
tmp=rom[i*2];
rom[i*2]=rom[i*2+1];
rom[i*2+1]=tmp;
}
printf ("rom byteswaped\n");
}
if (rom[0]==0x40)
{
for (i=0; i<(taille_rom/4); i++)
{
tmp=rom[i*4];
rom[i*4]=rom[i*4+3];
rom[i*4+3]=tmp;
tmp=rom[i*4+1];
rom[i*4+1]=rom[i*4+2];
rom[i*4+2]=tmp;
}
printf("rom byteswaped\n");
}
else if ((rom[0] != 0x80) || (rom[1] != 0x37) || (rom[2] != 0x12) || (rom[3] != 0x40))
{
printf("wrong file format !\n");
free(rom);
rom = NULL;
return 1;
}
printf("rom loaded succesfully\n");
if (!ROM_HEADER) ROM_HEADER = malloc(sizeof(rom_header));
memcpy(ROM_HEADER, rom, sizeof(rom_header));
display_loading_progress(100);
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);
switch(ROM_HEADER->Country_code)
{
case 0x0044:
printf("Country : Germany\n");
break;
case 0x0045:
printf("Country : United States\n");
break;
case 0x004A:
printf("Country : Japan\n");
break;
case 0x0050:
printf("European cartridge\n");
break;
case 0x0055:
printf("Country : Australie\n");
default:
printf("Country Code : %x\n", ROM_HEADER->Country_code);
}
printf ("size: %d\n", (unsigned int)(sizeof(rom_header)));
printf ("PC= %x\n", sl((unsigned int)ROM_HEADER->PC));
// loading rom settings and checking if it's a good dump
md5_init(&state);
md5_append(&state, (const md5_byte_t *)rom, taille_rom);
md5_finish(&state, digest);
printf("md5 code:");
for (i=0; i<16; i++) printf("%02X", digest[i]);
printf("\n");
ini_openFile();
for (i=0; i<16; i++) sprintf(arg+i*2, "%02X", digest[i]);
arg[32] = 0;
strcpy(ROM_SETTINGS.MD5, arg);
if ((entry = ini_search_by_md5(arg)) == NULL)
{
char mycrc[1024];
printf("%x\n", (int)entry);
sprintf(mycrc, "%08X-%08X-C%02X",
(int)sl(ROM_HEADER->CRC1), (int)sl(ROM_HEADER->CRC2),
ROM_HEADER->Country_code);
if ((entry = ini_search_by_CRC(mycrc)) == NULL)
{
strcpy(ROM_SETTINGS.goodname, ROM_HEADER->nom);
strcat(ROM_SETTINGS.goodname, " (unknown rom)");
printf("%s\n", ROM_SETTINGS.goodname);
ROM_SETTINGS.eeprom_16kb = 0;
return 0;
}
else
{
if (!ask_bad())
{
free(rom);
rom = NULL;
free(ROM_HEADER);
ROM_HEADER = NULL;
return 1;
}
strcpy(ROM_SETTINGS.goodname, entry->goodname);
strcat(ROM_SETTINGS.goodname, " (bad dump)");
if (strcmp(entry->refMD5, ""))
entry = ini_search_by_md5(entry->refMD5);
ROM_SETTINGS.eeprom_16kb = entry->eeprom16kb;
return 0;
}
}
s=entry->goodname;
for (i=strlen(s); i > 0 && s[i-1] != '['; i--);
if (i != 0)
{
if (s[i] == 'T' || s[i] == 't' || s[i] == 'h' || s[i] == 'f' || s[i] == 'o')
{
if (!ask_hack())
{
free(rom);
rom = NULL;
free(ROM_HEADER);
ROM_HEADER = NULL;
return 1;
}
}
if (s[i] == 'b')
{
if (!ask_bad())
{
free(rom);
rom = NULL;
free(ROM_HEADER);
ROM_HEADER = NULL;
return 1;
}
}
}
strcpy(ROM_SETTINGS.goodname, entry->goodname);
if (strcmp(entry->refMD5, ""))
entry = ini_search_by_md5(entry->refMD5);
ROM_SETTINGS.eeprom_16kb = entry->eeprom16kb;
printf("eeprom type:%d\n", ROM_SETTINGS.eeprom_16kb);
return 0;
}
