PackedScreenResolution Config_ReadScreenSettings()
{
PackedScreenResolution packedResolution;
packedResolution.width = ConfigGetParamInt(video_general_section, "ScreenWidth");
packedResolution.height = ConfigGetParamInt(video_general_section, "ScreenHeight");
packedResolution.fullscreen = ConfigGetParamBool(video_general_section, "Fullscreen");
return packedResolution;
}
void event_sdl_keyup(int keysym, int keymod)
{
if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdStop)))
{
return;
}
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdForward)))
{
main_set_fastforward(0);
}
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdGameshark)))
{
event_set_gameshark(0);
}
else input.keyUp(keymod, keysym);
}
void event_sdl_keyup(int keysym, int keymod)
{
if (keysym == ConfigGetParamInt(g_CoreConfig, kbdStop))
{
return;
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdForward))
{
main_set_fastforward(0);
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdGameshark))
{
KbdGamesharkPressed = 0;
}
else keyUp(keymod, keysym);
}
EXPORT m64p_error CALL ConfigGetParameter(m64p_handle ConfigSectionHandle, const char *ParamName, m64p_type ParamType, void *ParamValue, int MaxSize)
{
config_section *section;
config_var *var;
/* check input conditions */
if (!l_ConfigInit)
return M64ERR_NOT_INIT;
if (ConfigSectionHandle == NULL || ParamName == NULL || ParamValue == NULL || (int) ParamType < 1 || (int) ParamType > 4)
return M64ERR_INPUT_ASSERT;
section = (config_section *) ConfigSectionHandle;
if (section->magic != SECTION_MAGIC)
return M64ERR_INPUT_INVALID;
/* if this parameter doesn't already exist, return an error */
var = find_section_var(section, ParamName);
if (var == NULL)
return M64ERR_INPUT_NOT_FOUND;
/* call the specific Get function to translate the parameter to the desired type */
switch(ParamType)
{
case M64TYPE_INT:
if (MaxSize < sizeof(int)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_INT && var->type != M64TYPE_FLOAT) return M64ERR_WRONG_TYPE;
*((int *) ParamValue) = ConfigGetParamInt(ConfigSectionHandle, ParamName);
break;
case M64TYPE_FLOAT:
if (MaxSize < sizeof(float)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_INT && var->type != M64TYPE_FLOAT) return M64ERR_WRONG_TYPE;
*((float *) ParamValue) = ConfigGetParamFloat(ConfigSectionHandle, ParamName);
break;
case M64TYPE_BOOL:
if (MaxSize < sizeof(int)) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_BOOL && var->type != M64TYPE_INT) return M64ERR_WRONG_TYPE;
*((int *) ParamValue) = ConfigGetParamBool(ConfigSectionHandle, ParamName);
break;
case M64TYPE_STRING:
{
const char *string;
if (MaxSize < 1) return M64ERR_INPUT_INVALID;
if (var->type != M64TYPE_STRING && var->type != M64TYPE_BOOL) return M64ERR_WRONG_TYPE;
string = ConfigGetParamString(ConfigSectionHandle, ParamName);
strncpy((char *) ParamValue, string, MaxSize);
*((char *) ParamValue + MaxSize - 1) = 0;
break;
}
default:
/* this is logically impossible because of the ParamType check at the top of this function */
break;
}
return M64ERR_SUCCESS;
}
BOOL Config_ReadInt(const char *itemname, const char *desc, int def_value, int create, int isBoolean)
{
VLOG("Getting value %s", itemname);
if (isBoolean)
{
ConfigSetDefaultBool(video_glide64_section, itemname, def_value, desc);
return ConfigGetParamBool(video_glide64_section, itemname);
}
else
{
ConfigSetDefaultInt(video_glide64_section, itemname, def_value, desc);
return ConfigGetParamInt(video_glide64_section, itemname);
}
}
void Config_LoadConfig()
{
const u32 hacks = config.generalEmulation.hacks;
if (!Config_SetDefault()) {
config.generalEmulation.hacks = hacks;
return;
}
config.version = ConfigGetParamInt(g_configVideoGliden64, "configVersion");
if (config.version != CONFIG_VERSION_CURRENT) {
m64p_error res = ConfigDeleteSection("Video-GLideN64");
assert(res == M64ERR_SUCCESS);
ConfigSaveFile();
if (!Config_SetDefault()) {
config.generalEmulation.hacks = hacks;
return;
}
}
config.video.fullscreen = ConfigGetParamBool(g_configVideoGeneral, "Fullscreen");
config.video.windowedWidth = ConfigGetParamInt(g_configVideoGeneral, "ScreenWidth");
config.video.windowedHeight = ConfigGetParamInt(g_configVideoGeneral, "ScreenHeight");
config.video.verticalSync = ConfigGetParamBool(g_configVideoGeneral, "VerticalSync");
#ifdef GL_MULTISAMPLING_SUPPORT
config.video.multisampling = ConfigGetParamInt(g_configVideoGliden64, "MultiSampling");
#else
config.video.multisampling = 0;
#endif
config.frameBufferEmulation.aspect = ConfigGetParamInt(g_configVideoGliden64, "AspectRatio");
config.frameBufferEmulation.bufferSwapMode = ConfigGetParamInt(g_configVideoGliden64, "BufferSwapMode");
config.frameBufferEmulation.nativeResFactor = ConfigGetParamInt(g_configVideoGliden64, "UseNativeResolutionFactor");
//#Texture Settings
config.texture.bilinearMode = ConfigGetParamBool(g_configVideoGliden64, "bilinearMode");
config.texture.maxAnisotropy = ConfigGetParamInt(g_configVideoGliden64, "MaxAnisotropy");
config.texture.maxBytes = ConfigGetParamInt(g_configVideoGliden64, "CacheSize") * uMegabyte;
//#Emulation Settings
config.generalEmulation.enableNoise = ConfigGetParamBool(g_configVideoGliden64, "EnableNoise");
config.generalEmulation.enableLOD = ConfigGetParamBool(g_configVideoGliden64, "EnableLOD");
config.generalEmulation.enableHWLighting = ConfigGetParamBool(g_configVideoGliden64, "EnableHWLighting");
config.generalEmulation.enableShadersStorage = ConfigGetParamBool(g_configVideoGliden64, "EnableShadersStorage");
config.generalEmulation.correctTexrectCoords = ConfigGetParamInt(g_configVideoGliden64, "CorrectTexrectCoords");
config.generalEmulation.enableNativeResTexrects = ConfigGetParamBool(g_configVideoGliden64, "enableNativeResTexrects");
#ifdef ANDROID
config.generalEmulation.forcePolygonOffset = ConfigGetParamBool(g_configVideoGliden64, "ForcePolygonOffset");
config.generalEmulation.polygonOffsetFactor = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetFactor");
config.generalEmulation.polygonOffsetUnits = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetUnits");
#endif
//#Frame Buffer Settings:"
config.frameBufferEmulation.enable = ConfigGetParamBool(g_configVideoGliden64, "EnableFBEmulation");
config.frameBufferEmulation.copyAuxToRDRAM = ConfigGetParamBool(g_configVideoGliden64, "EnableCopyAuxiliaryToRDRAM");
config.frameBufferEmulation.copyToRDRAM = ConfigGetParamInt(g_configVideoGliden64, "EnableCopyColorToRDRAM");
config.frameBufferEmulation.copyDepthToRDRAM = ConfigGetParamInt(g_configVideoGliden64, "EnableCopyDepthToRDRAM");
config.frameBufferEmulation.copyFromRDRAM = ConfigGetParamBool(g_configVideoGliden64, "EnableCopyColorFromRDRAM");
config.frameBufferEmulation.N64DepthCompare = ConfigGetParamBool(g_configVideoGliden64, "EnableN64DepthCompare");
config.frameBufferEmulation.fbInfoDisabled = ConfigGetParamBool(g_configVideoGliden64, "DisableFBInfo");
config.frameBufferEmulation.fbInfoReadColorChunk = ConfigGetParamBool(g_configVideoGliden64, "FBInfoReadColorChunk");
config.frameBufferEmulation.fbInfoReadDepthChunk = ConfigGetParamBool(g_configVideoGliden64, "FBInfoReadDepthChunk");
//#Texture filter settings
config.textureFilter.txFilterMode = ConfigGetParamInt(g_configVideoGliden64, "txFilterMode");
config.textureFilter.txEnhancementMode = ConfigGetParamInt(g_configVideoGliden64, "txEnhancementMode");
config.textureFilter.txDeposterize = ConfigGetParamInt(g_configVideoGliden64, "txDeposterize");
config.textureFilter.txFilterIgnoreBG = ConfigGetParamBool(g_configVideoGliden64, "txFilterIgnoreBG");
config.textureFilter.txCacheSize = ConfigGetParamInt(g_configVideoGliden64, "txCacheSize") * uMegabyte;
config.textureFilter.txHiresEnable = ConfigGetParamBool(g_configVideoGliden64, "txHiresEnable");
config.textureFilter.txHiresFullAlphaChannel = ConfigGetParamBool(g_configVideoGliden64, "txHiresFullAlphaChannel");
config.textureFilter.txHresAltCRC = ConfigGetParamBool(g_configVideoGliden64, "txHresAltCRC");
config.textureFilter.txDump = ConfigGetParamBool(g_configVideoGliden64, "txDump");
config.textureFilter.txForce16bpp = ConfigGetParamBool(g_configVideoGliden64, "txForce16bpp");
config.textureFilter.txCacheCompression = ConfigGetParamBool(g_configVideoGliden64, "txCacheCompression");
config.textureFilter.txSaveCache = ConfigGetParamBool(g_configVideoGliden64, "txSaveCache");
::mbstowcs(config.textureFilter.txPath, ConfigGetParamString(g_configVideoGliden64, "txPath"), PLUGIN_PATH_SIZE);
//#Font settings
config.font.name = ConfigGetParamString(g_configVideoGliden64, "fontName");
if (config.font.name.empty())
config.font.name = "arial.ttf";
char buf[16];
sprintf(buf, "0x%s", ConfigGetParamString(g_configVideoGliden64, "fontColor"));
long int uColor = strtol(buf, nullptr, 16);
if (uColor != 0) {
config.font.color[0] = _SHIFTR(uColor, 16, 8);
config.font.color[1] = _SHIFTR(uColor, 8, 8);
config.font.color[2] = _SHIFTR(uColor, 0, 8);
config.font.color[3] = 0xFF;
config.font.colorf[0] = _FIXED2FLOAT(config.font.color[0], 8);
config.font.colorf[1] = _FIXED2FLOAT(config.font.color[1], 8);
config.font.colorf[2] = _FIXED2FLOAT(config.font.color[2], 8);
config.font.colorf[3] = 1.0f;
}
config.font.size = ConfigGetParamInt(g_configVideoGliden64, "fontSize");
if (config.font.size == 0)
config.font.size = 30;
//#Bloom filter settings
config.bloomFilter.enable = ConfigGetParamBool(g_configVideoGliden64, "EnableBloom");
config.bloomFilter.thresholdLevel = ConfigGetParamInt(g_configVideoGliden64, "bloomThresholdLevel");
config.bloomFilter.blendMode = ConfigGetParamInt(g_configVideoGliden64, "bloomBlendMode");
config.bloomFilter.blurAmount = ConfigGetParamInt(g_configVideoGliden64, "blurAmount");
config.bloomFilter.blurStrength = ConfigGetParamInt(g_configVideoGliden64, "blurStrength");
//#Gamma correction settings
config.gammaCorrection.force = ConfigGetParamBool(g_configVideoGliden64, "ForceGammaCorrection");
config.gammaCorrection.level = ConfigGetParamFloat(g_configVideoGliden64, "GammaCorrectionLevel");
config.generalEmulation.hacks = hacks;
}
int Config_ReadScreenInt(const char *itemname)
{
return ConfigGetParamInt(video_general_section, itemname);
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_run(void)
{
VILimit = (float) GetVILimit();
VILimitMilliseconds = (double) 1000.0/VILimit;
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
/* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
event_initialize();
// initialize memory, and do byte-swapping if it's not been done yet
if (g_MemHasBeenBSwapped == 0)
{
init_memory(1);
g_MemHasBeenBSwapped = 1;
}
else
{
init_memory(0);
}
// Attach rom to plugins
if (!romOpen_gfx())
{
free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (!romOpen_audio())
{
romClosed_gfx(); free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (!romOpen_input())
{
romClosed_audio(); romClosed_gfx(); free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
// init on-screen display
int width = 640, height = 480;
readScreen(NULL, &width, &height, 0); // read screen to get width and height
osd_init(width, height);
}
// setup rendering callback from video plugin to the core, for screenshots and On-Screen-Display
setRenderingCallback(video_plugin_render_callback);
#ifdef WITH_LIRC
lircStart();
#endif // WITH_LIRC
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
/* Startup message on the OSD */
osd_new_message(OSD_MIDDLE_CENTER, "Mupen64Plus Started...");
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
r4300_execute();
#ifdef WITH_LIRC
lircStop();
#endif // WITH_LIRC
#ifdef DBG
if (g_DebuggerActive)
destroy_debugger();
#endif
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
osd_exit();
}
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
free_memory();
// clean up
g_EmulatorRunning = 0;
StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
SDL_Quit();
return M64ERR_SUCCESS;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_init(void)
{
size_t i;
unsigned int disable_extra_mem;
static int channels[] = { 0, 1, 2, 3 };
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
disable_extra_mem = ConfigGetParamInt(g_CoreConfig, "DisableExtraMem");
#if 0
count_per_op = ConfigGetParamInt(g_CoreConfig, "CountPerOp");
#endif
if (count_per_op <= 0)
count_per_op = 2;
/* do byte-swapping if it's not been done yet */
if (g_MemHasBeenBSwapped == 0)
{
swap_buffer(g_rom, 4, g_rom_size / 4);
g_MemHasBeenBSwapped = 1;
}
if (g_DDMemHasBeenBSwapped == 0)
{
swap_buffer(g_ddrom, 4, g_ddrom_size / 4);
g_DDMemHasBeenBSwapped = 1;
}
connect_all(&g_r4300, &g_dp, &g_sp,
&g_ai, &g_pi, &g_ri, &g_si, &g_vi, &g_dd,
g_rdram, (disable_extra_mem == 0) ? 0x800000 : 0x400000,
g_rom, g_rom_size, g_ddrom, g_ddrom_size, g_dd_disk, g_dd_disk_size);
init_memory();
// Attach rom to plugins
printf("Gfx RomOpen.\n");
if (!gfx.romOpen())
{
printf("Gfx RomOpen failed.\n");
return M64ERR_PLUGIN_FAIL;
}
printf("Input RomOpen.\n");
if (!input.romOpen())
{
printf("Input RomOpen failed.\n");
gfx.romClosed();
return M64ERR_PLUGIN_FAIL;
}
/* connect external time source to AF_RTC component */
g_si.pif.af_rtc.user_data = NULL;
g_si.pif.af_rtc.get_time = get_time_using_C_localtime;
/* connect external game controllers */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].user_data = &channels[i];
g_si.pif.controllers[i].is_connected = egcvip_is_connected;
g_si.pif.controllers[i].get_input = egcvip_get_input;
}
/* connect external rumblepaks */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].rumblepak.user_data = &channels[i];
g_si.pif.controllers[i].rumblepak.rumble = rvip_rumble;
}
/* connect saved_memory.mempacks to mempaks */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].mempak.user_data = NULL;
g_si.pif.controllers[i].mempak.save = dummy_save;
g_si.pif.controllers[i].mempak.data = &saved_memory.mempack[i][0];
}
/* connect saved_memory.eeprom to eeprom */
g_si.pif.eeprom.user_data = NULL;
g_si.pif.eeprom.save = dummy_save;
g_si.pif.eeprom.data = saved_memory.eeprom;
if (ROM_SETTINGS.savetype != EEPROM_16KB)
{
/* 4kbits EEPROM */
g_si.pif.eeprom.size = 0x200;
g_si.pif.eeprom.id = 0x8000;
}
else
{
/* 16kbits EEPROM */
g_si.pif.eeprom.size = 0x800;
g_si.pif.eeprom.id = 0xc000;
}
/* connect saved_memory.flashram to flashram */
g_pi.flashram.user_data = NULL;
g_pi.flashram.save = dummy_save;
g_pi.flashram.data = saved_memory.flashram;
/* connect saved_memory.sram to SRAM */
g_pi.sram.user_data = NULL;
g_pi.sram.save = dummy_save;
g_pi.sram.data = saved_memory.sram;
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
r4300_init();
return M64ERR_SUCCESS;
}
void event_sdl_keydown(int keysym, int keymod)
{
/* check for the only 2 hard-coded key commands: Alt-enter for fullscreen and 0-9 for save state slot */
if (keysym == SDLK_RETURN && keymod & (KMOD_LALT | KMOD_RALT))
{
changeWindow();
}
else if (keysym >= SDLK_0 && keysym <= SDLK_9)
{
main_state_set_slot(keysym - SDLK_0);
}
/* check all of the configurable commands */
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdStop))
main_stop();
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdFullscreen))
changeWindow();
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdSave))
main_state_save(0, NULL); /* save in mupen64plus format using current slot */
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdLoad))
main_state_load(NULL); /* load using current slot */
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdIncrement))
main_state_inc_slot();
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdReset))
{
add_interupt_event(HW2_INT, 0); /* Hardware 2 Interrupt immediately */
add_interupt_event(NMI_INT, 50000000); /* Non maskable Interrupt after 1/2 second */
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdSpeeddown))
main_speeddown(5);
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdSpeedup))
main_speedup(5);
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdScreenshot))
main_take_next_screenshot(); /* screenshot will be taken at the end of frame rendering */
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdPause))
main_toggle_pause();
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdMute))
{
volumeMute();
main_draw_volume_osd();
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdIncrease))
{
volumeUp();
main_draw_volume_osd();
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdDecrease))
{
volumeDown();
main_draw_volume_osd();
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdForward))
{
main_set_fastforward(1);
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdAdvance))
{
main_advance_one();
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdGameshark))
{
KbdGamesharkPressed = 1;
}
else
{
/* pass all other keypresses to the input plugin */
keyDown(keymod, keysym);
}
}
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;
m64p_handle CoreSection = NULL;
/* check input requirements */
if (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 */
rom_size = size;
rom = (unsigned char *) malloc(size);
if (rom == NULL)
return M64ERR_NO_MEMORY;
memcpy(rom, romimage, size);
swap_rom(rom, &imagetype, rom_size);
memcpy(&ROM_HEADER, rom, sizeof(m64p_rom_header));
/* Calculate MD5 hash */
md5_init(&state);
md5_append(&state, (const md5_byte_t*)rom, 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.vilimit = rom_system_type_to_vi_limit(ROM_PARAMS.systemtype);
ROM_PARAMS.aidacrate = rom_system_type_to_ai_dac_rate(ROM_PARAMS.systemtype);
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;
}
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;
}
*/
strcpy(ROM_SETTINGS.goodname, ROM_PARAMS.headername);
strcat(ROM_SETTINGS.goodname, " (unknown rom)");
ROM_SETTINGS.savetype = 0;
if (ConfigOpenSection("Core", &CoreSection) == M64ERR_SUCCESS)
{
ConfigSetDefaultInt(CoreSection, "SaveType", NONE, "The savetype for the game");
ROM_SETTINGS.savetype = ConfigGetParamInt(CoreSection, "SaveType");
}
ROM_SETTINGS.status = 0;
ROM_SETTINGS.players = 0;
ROM_SETTINGS.rumble = 0;
/* 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: %x %x", 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)", rom_size, rom_size/1024/1024, rom_size/1024/1024*8);
DebugMessage(M64MSG_VERBOSE, "ClockRate = %x", sl(ROM_HEADER.ClockRate));
DebugMessage(M64MSG_INFO, "Version: %x", sl(ROM_HEADER.Release));
if(sl(ROM_HEADER.Manufacturer_ID) == 'N')
DebugMessage(M64MSG_INFO, "Manufacturer: Nintendo");
else
DebugMessage(M64MSG_INFO, "Manufacturer: %x", sl(ROM_HEADER.Manufacturer_ID));
DebugMessage(M64MSG_VERBOSE, "Cartridge_ID: %x", ROM_HEADER.Cartridge_ID);
countrycodestring(ROM_HEADER.Country_code, buffer);
DebugMessage(M64MSG_INFO, "Country: %s", buffer);
DebugMessage(M64MSG_VERBOSE, "PC = %x", sl((unsigned int)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;
}
void event_sdl_keydown(int keysym, int keymod)
{
int slot;
/* check for the only 2 hard-coded key commands: Alt-enter for fullscreen and 0-9 for save state slot */
if (keysym == SDL_SCANCODE_RETURN && keymod & (KMOD_LALT | KMOD_RALT))
gfx.changeWindow();
else if ((slot = get_saveslot_from_keysym(keysym)) >= 0)
main_state_set_slot(slot);
/* check all of the configurable commands */
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdStop)))
main_stop();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdFullscreen)))
gfx.changeWindow();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdSave)))
main_state_save(0, NULL); /* save in mupen64plus format using current slot */
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdLoad)))
main_state_load(NULL); /* load using current slot */
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdIncrement)))
main_state_inc_slot();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdReset)))
reset_soft();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdSpeeddown)))
main_speeddown(5);
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdSpeedup)))
main_speedup(5);
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdScreenshot)))
main_take_next_screenshot(); /* screenshot will be taken at the end of frame rendering */
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdPause)))
main_toggle_pause();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdMute)))
main_volume_mute();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdIncrease)))
main_volume_up();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdDecrease)))
main_volume_down();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdForward)))
main_set_fastforward(1);
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdAdvance)))
main_advance_one();
else if (keysym == sdl_keysym2native(ConfigGetParamInt(l_CoreEventsConfig, kbdGameshark)))
event_set_gameshark(1);
else
{
/* pass all other keypresses to the input plugin */
input.keyDown(keymod, keysym);
}
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_run(void)
{
DebugMessage(M64MSG_STATUS, "Main Run!");
VILimit = (float) GetVILimit();
VILimitMilliseconds = (double) 1000.0/VILimit;
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
/* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
event_initialize();
// initialize memory, and do byte-swapping if it's not been done yet
if (g_MemHasBeenBSwapped == 0)
{
init_memory(1);
g_MemHasBeenBSwapped = 1;
}
else
{
init_memory(0);
}
// Attach rom to plugins
if (!romOpen_gfx())
{
free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Graphics Plugin Opened!");
if (!romOpen_audio())
{
romClosed_gfx(); free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Audio Plugin Opened!");
if (!romOpen_input())
{
romClosed_audio(); romClosed_gfx(); free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Input Plugin Opened!");
printf("Plugins opened!\n");fflush(stdout);
#ifdef WITH_LIRC
lircStart();
#endif // WITH_LIRC
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
//PumpEvents();
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
DebugMessage(M64MSG_STATUS, "Starting to reset r4300!");fflush(stdout);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
DebugMessage(M64MSG_STATUS, "About to execute!");
fflush(stdout);
r4300_execute();
#ifdef WITH_LIRC
lircStop();
#endif // WITH_LIRC
#ifdef DBG
if (g_DebuggerActive)
destroy_debugger();
#endif
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
free_memory();
// clean up
g_EmulatorRunning = 0;
StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
//PDL_Quit();
SDL_Quit();
return M64ERR_SUCCESS;
}
/* Simulates end result of PIFBootROM execution */
void r4300_reset_soft(void)
{
uint32_t bsd_dom1_config;
unsigned int rom_type = 0; /* 0:Cart, 1:DD */
unsigned int reset_type = 0; /* 0:ColdReset, 1:NMI */
unsigned int s7 = 0; /* ??? */
unsigned int tv_type = get_tv_type(); /* 0:PAL, 1:NTSC, 2:MPAL */
if ((ConfigGetParamInt(g_CoreConfig, "BootDevice") != 0) && (g_ddrom != NULL) && (g_ddrom_size != 0))
{
bsd_dom1_config = *(uint32_t*)g_ddrom;
rom_type = 1;
}
else
bsd_dom1_config = *(uint32_t*)g_rom;
g_cp0_regs[CP0_STATUS_REG] = 0x34000000;
g_cp0_regs[CP0_CONFIG_REG] = 0x0006e463;
g_sp.regs[SP_STATUS_REG] = 1;
g_sp.regs2[SP_PC_REG] = 0;
g_pi.regs[PI_BSD_DOM1_LAT_REG] = (bsd_dom1_config ) & 0xff;
g_pi.regs[PI_BSD_DOM1_PWD_REG] = (bsd_dom1_config >> 8) & 0xff;
g_pi.regs[PI_BSD_DOM1_PGS_REG] = (bsd_dom1_config >> 16) & 0x0f;
g_pi.regs[PI_BSD_DOM1_RLS_REG] = (bsd_dom1_config >> 20) & 0x03;
g_pi.regs[PI_STATUS_REG] = 0;
g_ai.regs[AI_DRAM_ADDR_REG] = 0;
g_ai.regs[AI_LEN_REG] = 0;
g_vi.regs[VI_V_INTR_REG] = 1023;
g_vi.regs[VI_CURRENT_REG] = 0;
g_vi.regs[VI_H_START_REG] = 0;
g_r4300.mi.regs[MI_INTR_REG] &= ~(MI_INTR_PI | MI_INTR_VI | MI_INTR_AI | MI_INTR_SP);
if ((ConfigGetParamInt(g_CoreConfig, "BootDevice") != 0) && (g_ddrom != NULL) && (g_ddrom_size != 0))
memcpy((unsigned char*)g_sp.mem+0x40, g_ddrom+0x40, 0xfc0);
else
memcpy((unsigned char*)g_sp.mem+0x40, g_rom+0x40, 0xfc0);
reg[19] = rom_type; /* s3 */
reg[20] = tv_type; /* s4 */
reg[21] = reset_type; /* s5 */
reg[22] = g_si.pif.cic.seed; /* s6 */
reg[23] = s7; /* s7 */
if ((ConfigGetParamInt(g_CoreConfig, "BootDevice") != 0) && (g_ddrom != NULL) && (g_ddrom_size != 0))
reg[22] = 0xdd;
/* required by CIC x105 */
g_sp.mem[0x1000/4] = 0x3c0dbfc0;
g_sp.mem[0x1004/4] = 0x8da807fc;
g_sp.mem[0x1008/4] = 0x25ad07c0;
g_sp.mem[0x100c/4] = 0x31080080;
g_sp.mem[0x1010/4] = 0x5500fffc;
g_sp.mem[0x1014/4] = 0x3c0dbfc0;
g_sp.mem[0x1018/4] = 0x8da80024;
g_sp.mem[0x101c/4] = 0x3c0bb000;
/* required by CIC x105 */
reg[11] = 0xffffffffa4000040ULL; /* t3 */
reg[29] = 0xffffffffa4001ff0ULL; /* sp */
reg[31] = 0xffffffffa4001550ULL; /* ra */
/* ready to execute IPL3 */
}
