bool8 S9xUnfreezeGame(const char* filename)
{
if (statef_open(filename, "rb"))
{
int result;
if ((result = Unfreeze()) != SUCCESS)
{
switch (result)
{
case WRONG_FORMAT:
S9xMessage(S9X_ERROR, S9X_WRONG_FORMAT,
"File not in Snes9x freeze format");
S9xReset();
break;
case WRONG_VERSION:
S9xMessage(S9X_ERROR, S9X_WRONG_VERSION,
"Incompatable Snes9x freeze file format version");
S9xReset();
break;
default:
// should never happen
break;
}
statef_close();
return (FALSE);
}
statef_close();
return (TRUE);
}
return (FALSE);
}
bool SnesEmu::init(const QString &diskPath, QString *error) {
S9xSetSoundMute(FALSE);
setDefaultSettings();
S9xSetPlaybackRate();
m_frame = QImage(512, 239, QImage::Format_RGB16);
setVideoSrcRect(QRectF(0.0f, 0.0f, 256.0f, 224.f));
setFrameRate(60);
GFX.Pitch = 512 * 2;
GFX.RealPitch = 512 * 2;
GFX.PPL = GFX.Pitch >> 1;
GFX.PPLx2 = GFX.Pitch;
GFX.Screen = (u8 *)m_frame.bits();
GFX.SubScreen = (u8 *) malloc(GFX.RealPitch * 239);
GFX.ZBuffer = (u8 *) malloc(GFX.PPL * 239);
GFX.SubZBuffer = (u8 *) malloc(GFX.PPL * 239);
GFX.Delta = (GFX.SubScreen - GFX.Screen) >> 1;
if (!GFX.Screen || !GFX.SubScreen || !GFX.ZBuffer || !Memory.Init() || !S9xInitAPU() || !GFX.SubZBuffer ) {
*error = tr("SNES emulation init failed!");
return false;
}
S9xInitSound();
if (!S9xGraphicsInit()) {
*error = tr("SNES emulation init failed!");
return false;
}
S9xReset();
setDefaultSettings();
*error = setDisk(diskPath);
return error->isEmpty();
}
void SNES9X_Reset(void) // Hardware Reset
{
if (cartOpen)
{
SNES9X_SaveSRAM();
S9xReset();
SNES9X_LoadSRAM();
}
}
void SNES9X_Reset (void)
{
if (cartOpen)
{
SNES9X_SaveSRAM();
S9xReset();
SNES9X_LoadSRAM();
}
}
extern "C" void SIReset()
{
SI_EmulationPaused = 1;
SISaveSRAM();
S9xReset();
SILoadSRAM();
SI_NextFrameTime = (timeval){0,0};
SI_FrameTimeDebt = 0;
SI_SleptLastFrame = 0;
SI_EmulationPaused = 0;
}
static void
S9xNetplayConnect (void)
{
GtkWidget *msg;
S9xNetplayPreconnect ();
uint32 flags = CPU.Flags;
if (*(gui_config->netplay_last_rom) &&
top_level->try_open_rom (gui_config->netplay_last_rom))
{
return;
}
if (!S9xNPConnectToServer (gui_config->netplay_last_host,
gui_config->netplay_last_port,
Memory.ROMName))
{
msg = gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Couldn't connect to server: %s:%d",
gui_config->netplay_last_host,
gui_config->netplay_last_port);
gtk_dialog_run (GTK_DIALOG (msg));
gtk_widget_destroy (msg);
}
gui_config->netplay_activated = TRUE;
/* If no rom is specified, assume we'll get it from the server */
if (*(gui_config->netplay_last_rom) == 0)
{
Settings.StopEmulation = FALSE;
S9xROMLoaded ();
}
S9xReset ();
CPU.Flags = flags;
top_level->configure_widgets ();
return;
}
void
S9xNetplayStartServer (void)
{
uint32 flags;
S9xNetplayPreconnect ();
flags = CPU.Flags;
if (*(gui_config->netplay_last_rom) == 0 ||
top_level->try_open_rom (gui_config->netplay_last_rom))
{
return;
}
Settings.NetPlayServer = TRUE;
NPServer.SyncByReset = gui_config->netplay_sync_reset;
NPServer.SendROMImageOnConnect = gui_config->netplay_send_rom;
npthread = g_thread_create (S9xNetplayServerThread,
NULL,
TRUE,
NULL);
/* Sleep to let the server create itself */
usleep (10000);
S9xNPConnectToServer ("127.0.0.1",
gui_config->netplay_default_port,
Memory.ROMName);
S9xReset ();
S9xROMLoaded ();
gui_config->netplay_activated = TRUE;
gui_config->netplay_server_up = TRUE;
CPU.Flags = flags;
top_level->configure_widgets ();
return;
}
void SnesEmu::sl() {
if (emsl.save) {
S9xSRTCPreSaveState();
} else {
S9xReset();
}
snesCpuSl();
snesMemSl();
snesPpuSl();
snesDmaSl();
snesSoundSl();
snesSpuSl();
if (!emsl.save) {
S9xFixSoundAfterSnapshotLoad();
S9xSetPCBase(ICPU.ShiftedPB + Registers.PC);
S9xReschedule();
S9xSRTCPostLoadState();
if (Settings.SDD1)
S9xSDD1PostLoadState();
S9xSetSoundMute(FALSE);
}
}
static
int SnesRomLoad()
{
char filename[SAL_MAX_PATH+1];
int check;
char text[256];
FILE *stream=NULL;
MenuMessageBox("Loading Rom...",mRomName,"",MENU_MESSAGE_BOX_MODE_MSG);
if (!Memory.LoadROM (mRomName))
{
MenuMessageBox("Loading Rom...",mRomName,"FAILED!!!!",MENU_MESSAGE_BOX_MODE_PAUSE);
return SAL_ERROR;
}
MenuMessageBox("Loading Rom...OK!",mRomName,"",MENU_MESSAGE_BOX_MODE_MSG);
S9xReset();
S9xResetSound(1);
S9xLoadSRAM();
return SAL_OK;
}
int S9xMovieOpen (const char* filename, bool8 read_only)
{
FILE* fd;
STREAM stream;
int result;
int fn;
if(!(fd=fopen(filename, read_only ? "rb" : "rb+")))
return FILE_NOT_FOUND;
// stop current movie before opening
change_state(MOVIE_STATE_NONE);
// read header
if((result=read_movie_header(fd, &Movie))!=SUCCESS)
{
fclose(fd);
return result;
}
fn=dup(fileno(fd));
fclose(fd);
// apparently this lseek is necessary
lseek(fn, Movie.SaveStateOffset, SEEK_SET);
if(!(stream=REOPEN_STREAM(fn, "rb")))
return FILE_NOT_FOUND;
if(Movie.Opts & MOVIE_OPT_FROM_RESET)
{
S9xReset();
// save only SRAM for a from-reset snapshot
result=(READ_STREAM(SRAM, 0x20000, stream) == 0x20000) ? SUCCESS : WRONG_FORMAT;
}
else
{
result=S9xUnfreezeFromStream(stream);
}
CLOSE_STREAM(stream);
if(result!=SUCCESS)
{
return result;
}
if(!(fd=fopen(filename, read_only ? "rb" : "rb+")))
return FILE_NOT_FOUND;
if(fseek(fd, Movie.ControllerDataOffset, SEEK_SET))
return WRONG_FORMAT;
// read controller data
Movie.File=fd;
Movie.BytesPerFrame=bytes_per_frame();
Movie.InputBufferPtr=Movie.InputBuffer;
uint32 to_read=Movie.BytesPerFrame * (Movie.MaxFrame+1);
reserve_buffer_space(to_read);
fread(Movie.InputBufferPtr, 1, to_read, fd);
// read "baseline" controller data
read_frame_controller_data();
strncpy(Movie.Filename, filename, _MAX_PATH);
Movie.Filename[_MAX_PATH-1]='\0';
Movie.CurrentFrame=0;
Movie.ReadOnly=read_only;
change_state(MOVIE_STATE_PLAY);
S9xMessage(S9X_INFO, S9X_MOVIE_INFO, MOVIE_INFO_REPLAY);
return SUCCESS;
}
int S9xMovieOpen (const char* filename, bool8 read_only)
{
FILE* fd;
STREAM stream;
int result;
int fn;
char movie_filename [_MAX_PATH];
#ifdef __WIN32__
_fullpath(movie_filename, filename, _MAX_PATH);
#else
strcpy(movie_filename, filename);
#endif
if(!(fd=fopen(movie_filename, "rb+")))
if(!(fd=fopen(movie_filename, "rb")))
return FILE_NOT_FOUND;
else
read_only = TRUE;
const bool8 wasPaused = Settings.Paused;
// stop current movie before opening
change_state(MOVIE_STATE_NONE);
// read header
if((result=read_movie_header(fd, &Movie))!=SUCCESS)
{
fclose(fd);
return result;
}
read_movie_extrarominfo(fd, &Movie);
fn=dup(fileno(fd));
fclose(fd);
// apparently this lseek is necessary
lseek(fn, Movie.SaveStateOffset, SEEK_SET);
if(!(stream=REOPEN_STREAM(fn, "rb")))
return FILE_NOT_FOUND;
// store previous, before changing to the movie's settings
store_previous_settings();
// set from movie
restore_movie_settings();
if(Movie.Opts & MOVIE_OPT_FROM_RESET)
{
Movie.State = MOVIE_STATE_PLAY; // prevent NSRT controller switching (in S9xPostRomInit)
if(!Memory.LoadLastROM())
S9xReset();
Memory.ClearSRAM(false); // in case the SRAM read fails
Movie.State = MOVIE_STATE_NONE;
S9xMovieResetControls();
// save only SRAM for a from-reset snapshot
result=(READ_STREAM(Memory.SRAM, 0x20000, stream) == 0x20000) ? SUCCESS : WRONG_FORMAT;
}
else
{
result=S9xUnfreezeFromStream(stream);
}
CLOSE_STREAM(stream);
if(result!=SUCCESS)
{
return result;
}
if(!(fd=fopen(movie_filename, "rb+")))
if(!(fd=fopen(movie_filename, "rb")))
return FILE_NOT_FOUND;
else
read_only = TRUE;
if(fseek(fd, Movie.ControllerDataOffset, SEEK_SET))
return WRONG_FORMAT;
// read controller data
Movie.File=fd;
Movie.BytesPerSample=bytes_per_sample();
Movie.InputBufferPtr=Movie.InputBuffer;
uint32 to_read=Movie.BytesPerSample * (Movie.MaxSample+1);
reserve_buffer_space(to_read);
fread(Movie.InputBufferPtr, 1, to_read, fd);
// read "baseline" controller data
if(Movie.MaxSample && Movie.MaxFrame)
read_frame_controller_data(true);
strncpy(Movie.Filename, movie_filename, _MAX_PATH);
Movie.Filename[_MAX_PATH-1]='\0';
Movie.CurrentFrame=0;
Movie.CurrentSample=0;
Movie.ReadOnly=read_only;
change_state(MOVIE_STATE_PLAY);
Settings.Paused = wasPaused;
Movie.RecordedThisSession = false;
S9xUpdateFrameCounter(-1);
S9xMessage(S9X_INFO, S9X_MOVIE_INFO, MOVIE_INFO_REPLAY);
return SUCCESS;
}
int main(int argc, char ** argv) {
// Initialise SDL
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) < 0)
DIE("SDL_Init: %s", SDL_GetError());
GL_Init();
//Init SDL_TTF to print text to the screen...
if ( TTF_Init() )
{
fprintf( stderr, "Error initializing SDL_ttf!\n" );
exit ( 1 );
}
S9xInitDisplay(argc, argv);
// Configure snes9x
#if CONF_GUI
OssoInit(); // Hildon-games-wrapper initialization.
#endif
S9xLoadConfig(argc, argv); // Load config files and parse cmd line.
readOptions();
#if CONF_GUI
OssoConfig(); // Apply specific hildon-games config.
#endif
// S9x initialization
S9xInitDisplay(argc, argv);
S9xInitAudioOutput();
S9xInitInputDevices();
while(1)
{
S9xInit();
S9xReset();
char * rom = romSelector();
S9xSetRomFile(rom);
free(rom);
// Load rom and related files: state, unfreeze if needed
loadRom();
resumeGame();
// Late initialization
sprintf(String, "DrNokSnes - %s", Memory.ROMName);
S9xSetTitle(String);
S9xHacksLoadFile(Config.hacksFile);
if (!S9xGraphicsInit())
DIE("S9xGraphicsInit failed");
S9xAudioOutputEnable(true);
SDL_PauseAudio(0);
S9xVideoReset();
Config.running = true;
do {
frameSync(); // May block, or set frameskip to true.
S9xMainLoop(); // Does CPU things, renders if needed.
pollEvents();
//Ouch that this is going here...
updateBindingMessage();
} while (Config.running);
S9xVideoReset();
S9xGraphicsDeinit();
// Save state
Memory.SaveSRAM(S9xGetFilename(FILE_SRAM));
pauseGame();
Memory.Deinit();
S9xDeinitAPU();
}
// Deinitialization
S9xAudioOutputEnable(false);
S9xDeinitInputDevices();
S9xDeinitAudioOutput();
S9xDeinitDisplay();
// Late deinitialization
S9xUnloadConfig();
#if CONF_GUI
OssoDeinit();
#endif
SDL_Quit();
return 0;
}
void SnesEmu::reset() {
S9xReset();
}
void SNESSystem::Reset()
{
S9xReset();
}
extern "C" int SIStartWithROM(char* rom_filename)
{
// notify that we're running
SI_EmulationIsRunning = 1;
// frameskip settings reset
SI_NextFrameTime = (timeval){0, 0};
SI_FrameTimeDebt = 0;
SI_SleptLastFrame = 0;
// ensure dirs exist
mode_t dir_mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH;
mkdir(SI_SRAMPath, dir_mode);
// unix init
ZeroMemory(&Settings, sizeof(Settings));
Settings.MouseMaster = TRUE;
Settings.SuperScopeMaster = TRUE;
Settings.JustifierMaster = TRUE;
Settings.MultiPlayer5Master = TRUE;
Settings.FrameTimePAL = 20000;
Settings.FrameTimeNTSC = 16667;
Settings.SixteenBitSound = TRUE;
Settings.Stereo = TRUE;
//Settings.Stereo = FALSE;
Settings.SoundPlaybackRate = 32000;
//Settings.SoundPlaybackRate = 22050;
//Settings.SoundInputRate = 32000;
Settings.SoundInputRate = 32000;
Settings.SoundSync = FALSE;
Settings.SupportHiRes = TRUE;
Settings.Transparency = TRUE;
Settings.AutoDisplayMessages = TRUE;
Settings.InitialInfoStringTimeout = 120;
Settings.HDMATimingHack = 100;
Settings.BlockInvalidVRAMAccessMaster = TRUE;
Settings.StopEmulation = TRUE;
Settings.WrongMovieStateProtection = TRUE;
Settings.DumpStreamsMaxFrames = -1;
Settings.StretchScreenshots = 1;
Settings.SnapshotScreenshots = TRUE;
if(SI_AutoFrameskip)
Settings.SkipFrames = AUTO_FRAMERATE;
else
Settings.SkipFrames = SI_Frameskip;
//Settings.SkipFrames = 1;
Settings.TurboSkipFrames = 15;
Settings.CartAName[0] = 0;
Settings.CartBName[0] = 0;
#ifdef NETPLAY_SUPPORT
Settings.ServerName[0] = 0;
#endif
CPU.Flags = 0;
/*S9xLoadConfigFiles(argv, argc);
rom_filename = S9xParseArgs(argv, argc);
make_snes9x_dirs();*/
if (!Memory.Init() || !S9xInitAPU())
{
fprintf(stderr, "Snes9x: Memory allocation failure - not enough RAM/virtual memory available.\nExiting...\n");
Memory.Deinit();
S9xDeinitAPU();
exit(1);
}
int samplecount = Settings.SoundPlaybackRate/(Settings.PAL ? 50 : 60);
int soundBufferSize = samplecount<<(1+(Settings.Stereo?1:0));
S9xInitSound(soundBufferSize, 0);
S9xSetSoundMute(TRUE);
S9xReset();
S9xUnmapAllControls();
S9xSetController(0, CTL_JOYPAD, 0, 0, 0, 0);
//S9xSetController(1, CTL_JOYPAD, 1, 0, 0, 0);
s9xcommand_t cmd;
ASSIGN_BUTTONf(SIOS_X, "Joypad1 X");
ASSIGN_BUTTONf(SIOS_A, "Joypad1 A");
ASSIGN_BUTTONf(SIOS_B, "Joypad1 B");
ASSIGN_BUTTONf(SIOS_Y, "Joypad1 Y");
ASSIGN_BUTTONf(SIOS_L, "Joypad1 L");
ASSIGN_BUTTONf(SIOS_R, "Joypad1 R");
ASSIGN_BUTTONf(SIOS_SELECT, "Joypad1 Select");
ASSIGN_BUTTONf(SIOS_START, "Joypad1 Start");
ASSIGN_BUTTONf(SIOS_UP, "Joypad1 Up");
ASSIGN_BUTTONf(SIOS_DOWN, "Joypad1 Down");
ASSIGN_BUTTONf(SIOS_LEFT, "Joypad1 Left");
ASSIGN_BUTTONf(SIOS_RIGHT, "Joypad1 Right");
S9xReportControllers();
#ifdef GFX_MULTI_FORMAT
S9xSetRenderPixelFormat(RGB565);
#endif
uint32 saved_flags = CPU.Flags;
bool8 loaded = FALSE;
if (Settings.Multi)
{
loaded = Memory.LoadMultiCart(Settings.CartAName, Settings.CartBName);
if (!loaded)
{
char s1[PATH_MAX + 1], s2[PATH_MAX + 1];
char drive[_MAX_DRIVE + 1], dir[_MAX_DIR + 1], fname[_MAX_FNAME + 1], ext[_MAX_EXT + 1];
s1[0] = s2[0] = 0;
if (Settings.CartAName[0])
{
_splitpath(Settings.CartAName, drive, dir, fname, ext);
snprintf(s1, PATH_MAX + 1, "%s%s%s", S9xGetDirectory(ROM_DIR), SLASH_STR, fname);
if (ext[0] && (strlen(s1) <= PATH_MAX - 1 - strlen(ext)))
{
strcat(s1, ".");
strcat(s1, ext);
}
}
if (Settings.CartBName[0])
{
_splitpath(Settings.CartBName, drive, dir, fname, ext);
snprintf(s2, PATH_MAX + 1, "%s%s%s", S9xGetDirectory(ROM_DIR), SLASH_STR, fname);
if (ext[0] && (strlen(s2) <= PATH_MAX - 1 - strlen(ext)))
{
strcat(s2, ".");
strcat(s2, ext);
}
}
loaded = Memory.LoadMultiCart(s1, s2);
}
}
else
if (rom_filename)
{
char rom_path[1024] = {0};
sprintf(rom_path,"%s%s%s",SI_DocumentsPath,DIR_SEPERATOR,rom_filename);
loaded = Memory.LoadROM(rom_path);
/*if (!loaded && rom_filename[0])
{
char s[PATH_MAX + 1];
char drive[_MAX_DRIVE + 1], dir[_MAX_DIR + 1], fname[_MAX_FNAME + 1], ext[_MAX_EXT + 1];
_splitpath(rom_filename, drive, dir, fname, ext);
snprintf(s, PATH_MAX + 1, "%s%s%s", S9xGetDirectory(ROM_DIR), SLASH_STR, fname);
if (ext[0] && (strlen(s) <= PATH_MAX - 1 - strlen(ext)))
{
strcat(s, ".");
strcat(s, ext);
}
loaded = Memory.LoadROM(s);
}*/
}
if (!loaded)
{
fprintf(stderr, "Error opening the ROM file.\n");
exit(1);
}
//NSRTControllerSetup();
//Memory.LoadSRAM(S9xGetFilename(".srm", SRAM_DIR));
SILoadSRAM();
//S9xLoadCheatFile(S9xGetFilename(".cht", CHEAT_DIR));
CPU.Flags = saved_flags;
Settings.StopEmulation = FALSE;
#ifdef DEBUGGER
struct sigaction sa;
sa.sa_handler = sigbrkhandler;
#ifdef SA_RESTART
sa.sa_flags = SA_RESTART;
#else
sa.sa_flags = 0;
#endif
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
#endif
GFX.Pitch = SNES_WIDTH*2;
/*vrambuffer = (uint8*) malloc (GFX.Pitch * SNES_HEIGHT_EXTENDED*2);
memset (vrambuffer, 0, GFX.Pitch * SNES_HEIGHT_EXTENDED*2);
GFX.Screen = (uint16*)vrambuffer;*/
S9xGraphicsInit();
#ifdef NETPLAY_SUPPORT
if (strlen(Settings.ServerName) == 0)
{
char *server = getenv("S9XSERVER");
if (server)
{
strncpy(Settings.ServerName, server, 127);
Settings.ServerName[127] = 0;
}
}
char *port = getenv("S9XPORT");
if (Settings.Port >= 0 && port)
Settings.Port = atoi(port);
else
if (Settings.Port < 0)
Settings.Port = -Settings.Port;
if (Settings.NetPlay)
{
NetPlay.MaxFrameSkip = 10;
if (!S9xNPConnectToServer(Settings.ServerName, Settings.Port, Memory.ROMName))
{
fprintf(stderr, "Failed to connect to server %s on port %d.\n", Settings.ServerName, Settings.Port);
S9xExit();
}
fprintf(stderr, "Connected to server %s on port %d as player #%d playing %s.\n", Settings.ServerName, Settings.Port, NetPlay.Player, Memory.ROMName);
}
#endif
// HACK: disabling SMV
/*if (play_smv_filename)
{
uint32 flags = CPU.Flags & (DEBUG_MODE_FLAG | TRACE_FLAG);
if (S9xMovieOpen(play_smv_filename, TRUE) != SUCCESS)
exit(1);
CPU.Flags |= flags;
}
else
if (record_smv_filename)
{
uint32 flags = CPU.Flags & (DEBUG_MODE_FLAG | TRACE_FLAG);
if (S9xMovieCreate(record_smv_filename, 0xFF, MOVIE_OPT_FROM_RESET, NULL, 0) != SUCCESS)
exit(1);
CPU.Flags |= flags;
}
else
if (snapshot_filename)
{
uint32 flags = CPU.Flags & (DEBUG_MODE_FLAG | TRACE_FLAG);
if (!S9xUnfreezeGame(snapshot_filename))
exit(1);
CPU.Flags |= flags;
}*/
//S9xGraphicsMode();
sprintf(String, "\"%s\" %s: %s", Memory.ROMName, TITLE, VERSION);
//S9xSetTitle(String);
#ifdef JOYSTICK_SUPPORT
uint32 JoypadSkip = 0;
#endif
SILoadRunningStateForGameNamed(rom_filename);
SI_EmulationPaused = 0;
//if(SI_SoundOn)
SIDemuteSound(soundBufferSize);
S9xSetSoundMute(FALSE);
#ifdef NETPLAY_SUPPORT
bool8 NP_Activated = Settings.NetPlay;
#endif
while (1)
{
#ifdef NETPLAY_SUPPORT
if (NP_Activated)
{
if (NetPlay.PendingWait4Sync && !S9xNPWaitForHeartBeatDelay(100))
{
S9xProcessEvents(FALSE);
continue;
}
for (int J = 0; J < 8; J++)
old_joypads[J] = MovieGetJoypad(J);
for (int J = 0; J < 8; J++)
MovieSetJoypad(J, joypads[J]);
if (NetPlay.Connected)
{
if (NetPlay.PendingWait4Sync)
{
NetPlay.PendingWait4Sync = FALSE;
NetPlay.FrameCount++;
S9xNPStepJoypadHistory();
}
}
else
{
fprintf(stderr, "Lost connection to server.\n");
S9xExit();
}
}
#endif
#ifdef DEBUGGER
if (!Settings.Paused || (CPU.Flags & (DEBUG_MODE_FLAG | SINGLE_STEP_FLAG)))
#else
if (!Settings.Paused && !SI_EmulationPaused)
#endif
{
S9xMainLoop();
}
#ifdef NETPLAY_SUPPORT
if (NP_Activated)
{
for (int J = 0; J < 8; J++)
MovieSetJoypad(J, old_joypads[J]);
}
#endif
#ifdef DEBUGGER
if(Settings.Paused || (CPU.Flags & DEBUG_MODE_FLAG))
#else
if(Settings.Paused || SI_EmulationPaused)
#endif
S9xSetSoundMute(TRUE);
#ifdef DEBUGGER
if (CPU.Flags & DEBUG_MODE_FLAG)
S9xDoDebug();
else
#endif
if(Settings.Paused || SI_EmulationPaused || !SI_EmulationRun)
{
SISaveSRAM();
SISaveRunningStateForGameNamed(rom_filename);
SI_EmulationDidPause = 1;
do {
//S9xProcessEvents(FALSE);
if(!SI_EmulationRun)
break;
usleep(100000);
} while (SI_EmulationPaused);
if(!SI_EmulationRun)
{
SISaveSRAM();
SISaveRunningStateForGameNamed(rom_filename);
SIMuteSound();
S9xGraphicsDeinit();
Memory.Deinit();
S9xDeinitAPU();
break;
}
}
#ifdef JOYSTICK_SUPPORT
if (unixSettings.JoystickEnabled && (JoypadSkip++ & 1) == 0)
ReadJoysticks();
#endif
//S9xProcessEvents(FALSE);
#ifdef DEBUGGER
if(!Settings.Paused && !(CPU.Flags & DEBUG_MODE_FLAG))
#else
if(!Settings.Paused && !SI_EmulationPaused)
#endif
S9xSetSoundMute(FALSE);
}
SI_EmulationIsRunning = 0;
return (0);
}
int
S9xOpenROM (const char *rom_filename)
{
uint32 flags;
bool8 loaded;
if (gui_config->rom_loaded)
{
S9xAutoSaveSRAM ();
}
#ifdef NETPLAY_SUPPORT
S9xNetplayDisconnect ();
#endif
flags = CPU.Flags;
loaded = FALSE;
if (Settings.Multi)
loaded = Memory.LoadMultiCart (Settings.CartAName, Settings.CartBName);
else if (rom_filename)
loaded = Memory.LoadROM (rom_filename);
Settings.StopEmulation = !loaded;
if (!loaded && rom_filename)
{
char dir [_MAX_DIR + 1];
char drive [_MAX_DRIVE + 1];
char name [_MAX_FNAME + 1];
char ext [_MAX_EXT + 1];
char fname [_MAX_PATH + 1];
_splitpath (rom_filename, drive, dir, name, ext);
_makepath (fname, drive, dir, name, ext);
strcpy (fname, S9xGetDirectory (ROM_DIR));
strcat (fname, SLASH_STR);
strcat (fname, name);
if (ext [0])
{
strcat (fname, ".");
strcat (fname, ext);
}
_splitpath (fname, drive, dir, name, ext);
_makepath (fname, drive, dir, name, ext);
if ((Settings.StopEmulation = !Memory.LoadROM (fname)))
{
fprintf (stderr, _("Error opening: %s\n"), rom_filename);
loaded = FALSE;
}
else
loaded = TRUE;
}
if (loaded)
{
Memory.LoadSRAM (S9xGetFilename (".srm", SRAM_DIR));
S9xLoadCheatFile (S9xGetFilename (".cht", CHEAT_DIR));
for (unsigned int i = 0; i < Cheat.num_cheats; i++)
{
if (Cheat.c[i].enabled)
{
/* RAM is fresh, so we need to clean out old saved values */
Cheat.c[i].saved = FALSE;
S9xApplyCheat (i);
}
}
}
else
{
S9xReset ();
CPU.Flags = flags;
Settings.Paused = 1;
S9xNoROMLoaded ();
top_level->refresh ();
return 1;
}
CPU.Flags = flags;
S9xROMLoaded ();
return 0;
}
void snes_power()
{
S9xReset();
}
static int ReadOrigSnapshot (STREAM snap)
{
char buffer [_MAX_PATH];
char rom_filename [_MAX_PATH];
int result;
int i;
int j;
int version;
int len = strlen (ORIG_SNAPSHOT_MAGIC) + 1 + 4 + 1;
if (READ_STREAM (buffer, len, snap) != len)
return (WRONG_FORMAT);
if (strncmp (buffer, ORIG_SNAPSHOT_MAGIC, strlen (ORIG_SNAPSHOT_MAGIC)) != 0)
return (WRONG_FORMAT);
if ((version = atoi (&buffer [strlen (SNAPSHOT_MAGIC) + 1])) > ORIG_SNAPSHOT_VERSION)
return (WRONG_VERSION);
if ((result = ReadBlock ("NAM:", rom_filename, _MAX_PATH, snap)) != SUCCESS)
return (result);
if ((result = ReadBlock ("HiR:", buffer, 0x41, snap)) != SUCCESS)
return (result);
if (strcasecmp (rom_filename, Memory.ROMFilename) != 0 &&
strcasecmp (S9xBasename (rom_filename), S9xBasename (Memory.ROMFilename)) != 0)
{
S9xMessage (S9X_WARNING, S9X_FREEZE_ROM_NAME,
"Current loaded ROM image doesn't match that required by freeze-game file.");
}
S9xReset ();
S9xSetSoundMute (TRUE);
if ((result = ReadBlock ("CPU:", &OrigCPU, sizeof (OrigCPU), snap)) != SUCCESS)
return (result);
OrigCPU.FastROMSpeed = OrigCPU.FastROMSpeed_old;
Memory.FixROMSpeed ();
if (version == 3)
{
OrigCPU.Cycles = OrigCPU.Cycles_old;
OrigCPU.NextEvent = OrigCPU.NextEvent_old;
OrigCPU.V_Counter = OrigCPU.V_Counter_old;
OrigCPU.MemSpeed = OrigCPU.MemSpeed_old;
OrigCPU.MemSpeedx2 = OrigCPU.MemSpeedx2_old;
OrigCPU.FastROMSpeed = OrigCPU.FastROMSpeed_old;
}
CPU.Flags = OrigCPU.Flags;
CPU.BranchSkip = OrigCPU.BranchSkip;
CPU.NMIActive = OrigCPU.NMIActive;
CPU.IRQActive = OrigCPU.IRQActive;
CPU.WaitingForInterrupt = OrigCPU.WaitingForInterrupt;
CPU.WhichEvent = OrigCPU.WhichEvent;
CPU.Cycles = OrigCPU.Cycles;
CPU.NextEvent = OrigCPU.NextEvent;
CPU.V_Counter = OrigCPU.V_Counter;
CPU.MemSpeed = OrigCPU.MemSpeed;
CPU.MemSpeedx2 = OrigCPU.MemSpeedx2;
CPU.FastROMSpeed = OrigCPU.FastROMSpeed;
if ((result = ReadBlock ("REG:", &OrigRegisters, sizeof (OrigRegisters), snap)) != SUCCESS)
return (result);
Registers = *(struct SRegisters *) &OrigRegisters;
if ((result = ReadBlock ("PPU:", &OrigPPU, sizeof (OrigPPU), snap)) != SUCCESS)
return (result);
if (version == 2)
{
OrigPPU.OBJNameSelect = OrigPPU.OBJNameSelect_old << 13;
OrigPPU.OBJNameBase <<= 1;
OrigPPU.OBJNameSelect <<= 13;
}
PPU.BGMode = OrigPPU.BGMode;
PPU.BG3Priority = OrigPPU.BG3Priority;
PPU.Brightness = OrigPPU.Brightness;
PPU.VMA.High = OrigPPU.VMA.High;
PPU.VMA.Increment = OrigPPU.VMA.Increment;
PPU.VMA.Address = OrigPPU.VMA.Address;
PPU.VMA.Mask1 = OrigPPU.VMA.Mask1;
PPU.VMA.FullGraphicCount = OrigPPU.VMA.FullGraphicCount;
PPU.VMA.Shift = OrigPPU.VMA.Shift;
for (i = 0; i < 4; i++)
{
PPU.BG[i].SCBase = OrigPPU.BG[i].SCBase;
PPU.BG[i].VOffset = OrigPPU.BG[i].VOffset;
PPU.BG[i].HOffset = OrigPPU.BG[i].HOffset;
PPU.BG[i].BGSize = OrigPPU.BG[i].BGSize;
PPU.BG[i].NameBase = OrigPPU.BG[i].NameBase;
PPU.BG[i].SCSize = OrigPPU.BG[i].SCSize;
}
PPU.CGFLIP = OrigPPU.CGFLIP;
for (i = 0; i < 256; i++)
PPU.CGDATA [i] = OrigPPU.CGDATA [i];
PPU.FirstSprite = OrigPPU.FirstSprite;
for (i = 0; i < 128; i++)
{
PPU.OBJ[i].HPos = OrigPPU.OBJ [i].HPos;
PPU.OBJ[i].VPos = OrigPPU.OBJ [i].VPos;
PPU.OBJ[i].Name = OrigPPU.OBJ [i].Name;
PPU.OBJ[i].VFlip = OrigPPU.OBJ [i].VFlip;
PPU.OBJ[i].HFlip = OrigPPU.OBJ [i].HFlip;
PPU.OBJ[i].Priority = OrigPPU.OBJ [i].Priority;
PPU.OBJ[i].Palette = OrigPPU.OBJ [i].Palette;
PPU.OBJ[i].Size = OrigPPU.OBJ [i].Size;
}
PPU.OAMPriorityRotation = OrigPPU.OAMPriorityRotation;
PPU.OAMAddr = OrigPPU.OAMAddr;
PPU.OAMFlip = OrigPPU.OAMFlip;
PPU.OAMTileAddress = OrigPPU.OAMTileAddress;
PPU.IRQVBeamPos = OrigPPU.IRQVBeamPos;
PPU.IRQHBeamPos = OrigPPU.IRQHBeamPos;
PPU.VBeamPosLatched = OrigPPU.VBeamPosLatched;
PPU.HBeamPosLatched = OrigPPU.HBeamPosLatched;
PPU.HBeamFlip = OrigPPU.HBeamFlip;
PPU.VBeamFlip = OrigPPU.VBeamFlip;
PPU.HVBeamCounterLatched = OrigPPU.HVBeamCounterLatched;
PPU.MatrixA = OrigPPU.MatrixA;
PPU.MatrixB = OrigPPU.MatrixB;
PPU.MatrixC = OrigPPU.MatrixC;
PPU.MatrixD = OrigPPU.MatrixD;
PPU.CentreX = OrigPPU.CentreX;
PPU.CentreY = OrigPPU.CentreY;
PPU.Joypad1ButtonReadPos = OrigPPU.Joypad1ButtonReadPos;
PPU.Joypad2ButtonReadPos = OrigPPU.Joypad2ButtonReadPos;
PPU.Joypad3ButtonReadPos = OrigPPU.Joypad3ButtonReadPos;
PPU.CGADD = OrigPPU.CGADD;
PPU.FixedColourRed = OrigPPU.FixedColourRed;
PPU.FixedColourGreen = OrigPPU.FixedColourGreen;
PPU.FixedColourBlue = OrigPPU.FixedColourBlue;
PPU.SavedOAMAddr = OrigPPU.SavedOAMAddr;
PPU.ScreenHeight = OrigPPU.ScreenHeight;
PPU.WRAM = OrigPPU.WRAM;
PPU.ForcedBlanking = OrigPPU.ForcedBlanking;
PPU.OBJNameSelect = OrigPPU.OBJNameSelect;
PPU.OBJSizeSelect = OrigPPU.OBJSizeSelect;
PPU.OBJNameBase = OrigPPU.OBJNameBase;
PPU.OAMReadFlip = OrigPPU.OAMReadFlip;
memmove (PPU.OAMData, OrigPPU.OAMData, sizeof (PPU.OAMData));
PPU.VTimerEnabled = OrigPPU.VTimerEnabled;
PPU.HTimerEnabled = OrigPPU.HTimerEnabled;
PPU.HTimerPosition = OrigPPU.HTimerPosition;
PPU.Mosaic = OrigPPU.Mosaic;
memmove (PPU.BGMosaic, OrigPPU.BGMosaic, sizeof (PPU.BGMosaic));
PPU.Mode7HFlip = OrigPPU.Mode7HFlip;
PPU.Mode7VFlip = OrigPPU.Mode7VFlip;
PPU.Mode7Repeat = OrigPPU.Mode7Repeat;
PPU.Window1Left = OrigPPU.Window1Left;
PPU.Window1Right = OrigPPU.Window1Right;
PPU.Window2Left = OrigPPU.Window2Left;
PPU.Window2Right = OrigPPU.Window2Right;
for (i = 0; i < 6; i++)
{
PPU.ClipWindowOverlapLogic [i] = OrigPPU.ClipWindowOverlapLogic [i];
PPU.ClipWindow1Enable [i] = OrigPPU.ClipWindow1Enable [i];
PPU.ClipWindow2Enable [i] = OrigPPU.ClipWindow2Enable [i];
PPU.ClipWindow1Inside [i] = OrigPPU.ClipWindow1Inside [i];
PPU.ClipWindow2Inside [i] = OrigPPU.ClipWindow2Inside [i];
}
PPU.CGFLIPRead = OrigPPU.CGFLIPRead;
PPU.Need16x8Mulitply = OrigPPU.Need16x8Mulitply;
IPPU.ColorsChanged = TRUE;
IPPU.OBJChanged = TRUE;
S9xFixColourBrightness ();
IPPU.RenderThisFrame = FALSE;
if ((result = ReadBlock ("DMA:", OrigDMA, sizeof (OrigDMA), snap)) != SUCCESS)
return (result);
for (i = 0; i < 8; i++)
{
DMA[i].TransferDirection = OrigDMA[i].TransferDirection;
DMA[i].AAddressFixed = OrigDMA[i].AAddressFixed;
DMA[i].AAddressDecrement = OrigDMA[i].AAddressDecrement;
DMA[i].TransferMode = OrigDMA[i].TransferMode;
DMA[i].ABank = OrigDMA[i].ABank;
DMA[i].AAddress = OrigDMA[i].AAddress;
DMA[i].Address = OrigDMA[i].Address;
DMA[i].BAddress = OrigDMA[i].BAddress;
DMA[i].TransferBytes = OrigDMA[i].TransferBytes;
DMA[i].HDMAIndirectAddressing = OrigDMA[i].HDMAIndirectAddressing;
DMA[i].IndirectAddress = OrigDMA[i].IndirectAddress;
DMA[i].IndirectBank = OrigDMA[i].IndirectBank;
DMA[i].Repeat = OrigDMA[i].Repeat;
DMA[i].LineCount = OrigDMA[i].LineCount;
DMA[i].FirstLine = OrigDMA[i].FirstLine;
}
if ((result = ReadBlock ("VRA:", Memory.VRAM, 0x10000, snap)) != SUCCESS)
return (result);
if ((result = ReadBlock ("RAM:", Memory.RAM, 0x20000, snap)) != SUCCESS)
return (result);
if ((result = ReadBlock ("SRA:", Memory.SRAM, 0x10000, snap)) != SUCCESS)
return (result);
if ((result = ReadBlock ("FIL:", Memory.FillRAM, 0x8000, snap)) != SUCCESS)
return (result);
if (ReadBlock ("APU:", &OrigAPU, sizeof (OrigAPU), snap) == SUCCESS)
{
APU = *(struct SAPU *) &OrigAPU;
if ((result = ReadBlock ("ARE:", &OrigAPURegisters,
sizeof (OrigAPURegisters), snap)) != SUCCESS)
return (result);
APURegisters = *(struct SAPURegisters *) &OrigAPURegisters;
if ((result = ReadBlock ("ARA:", IAPU.RAM, 0x10000, snap)) != SUCCESS)
return (result);
if ((result = ReadBlock ("SOU:", &OrigSoundData,
sizeof (SOrigSoundData), snap)) != SUCCESS)
return (result);
SoundData.master_volume_left = OrigSoundData.master_volume_left;
SoundData.master_volume_right = OrigSoundData.master_volume_right;
SoundData.echo_volume_left = OrigSoundData.echo_volume_left;
SoundData.echo_volume_right = OrigSoundData.echo_volume_right;
SoundData.echo_enable = OrigSoundData.echo_enable;
SoundData.echo_feedback = OrigSoundData.echo_feedback;
SoundData.echo_ptr = OrigSoundData.echo_ptr;
SoundData.echo_buffer_size = OrigSoundData.echo_buffer_size;
SoundData.echo_write_enabled = OrigSoundData.echo_write_enabled;
SoundData.echo_channel_enable = OrigSoundData.echo_channel_enable;
SoundData.pitch_mod = OrigSoundData.pitch_mod;
for (i = 0; i < 3; i++)
SoundData.dummy [i] = OrigSoundData.dummy [i];
for (i = 0; i < NUM_CHANNELS; i++)
{
SoundData.channels [i].state = OrigSoundData.channels [i].state;
SoundData.channels [i].type = OrigSoundData.channels [i].type;
SoundData.channels [i].volume_left = OrigSoundData.channels [i].volume_left;
SoundData.channels [i].volume_right = OrigSoundData.channels [i].volume_right;
SoundData.channels [i].hertz = OrigSoundData.channels [i].frequency;
SoundData.channels [i].count = OrigSoundData.channels [i].count;
SoundData.channels [i].loop = OrigSoundData.channels [i].loop;
SoundData.channels [i].envx = OrigSoundData.channels [i].envx;
SoundData.channels [i].left_vol_level = OrigSoundData.channels [i].left_vol_level;
SoundData.channels [i].right_vol_level = OrigSoundData.channels [i].right_vol_level;
SoundData.channels [i].envx_target = OrigSoundData.channels [i].envx_target;
SoundData.channels [i].env_error = OrigSoundData.channels [i].env_error;
SoundData.channels [i].erate = OrigSoundData.channels [i].erate;
SoundData.channels [i].direction = OrigSoundData.channels [i].direction;
SoundData.channels [i].attack_rate = OrigSoundData.channels [i].attack_rate;
SoundData.channels [i].decay_rate = OrigSoundData.channels [i].decay_rate;
SoundData.channels [i].sustain_rate = OrigSoundData.channels [i].sustain_rate;
SoundData.channels [i].release_rate = OrigSoundData.channels [i].release_rate;
SoundData.channels [i].sustain_level = OrigSoundData.channels [i].sustain_level;
SoundData.channels [i].sample = OrigSoundData.channels [i].sample;
for (j = 0; j < 16; j++)
SoundData.channels [i].decoded [j] = OrigSoundData.channels [i].decoded [j];
for (j = 0; j < 2; j++)
SoundData.channels [i].previous [j] = OrigSoundData.channels [i].previous [j];
SoundData.channels [i].sample_number = OrigSoundData.channels [i].sample_number;
SoundData.channels [i].last_block = OrigSoundData.channels [i].last_block;
SoundData.channels [i].needs_decode = OrigSoundData.channels [i].needs_decode;
SoundData.channels [i].block_pointer = OrigSoundData.channels [i].block_pointer;
SoundData.channels [i].sample_pointer = OrigSoundData.channels [i].sample_pointer;
SoundData.channels [i].mode = OrigSoundData.channels [i].mode;
}
S9xSetSoundMute (FALSE);
IAPU.PC = IAPU.RAM + APURegisters.PC;
S9xAPUUnpackStatus ();
if (APUCheckDirectPage ())
IAPU.DirectPage = IAPU.RAM + 0x100;
else
IAPU.DirectPage = IAPU.RAM;
Settings.APUEnabled = TRUE;
IAPU.APUExecuting = TRUE;
}
else
{
Settings.APUEnabled = FALSE;
IAPU.APUExecuting = FALSE;
S9xSetSoundMute (TRUE);
}
S9xFixSoundAfterSnapshotLoad (1);
ICPU.ShiftedPB = Registers.PB << 16;
ICPU.ShiftedDB = Registers.DB << 16;
S9xSetPCBase (ICPU.ShiftedPB + Registers.PC);
S9xUnpackStatus ();
S9xFixCycles ();
S9xReschedule ();
return (SUCCESS);
}
int S9xMovieOpen (const char* filename, bool8 read_only, uint8 sync_flags, uint8 sync_flags2)
{
FILE* fd;
STREAM stream;
int result;
int fn;
char movie_filename [_MAX_PATH];
#ifdef WIN32
_fullpath(movie_filename, filename, _MAX_PATH);
#else
strcpy(movie_filename, filename);
#endif
if(!(fd=fopen(movie_filename, "rb+")))
if(!(fd=fopen(movie_filename, "rb")))
return FILE_NOT_FOUND;
else
read_only = TRUE;
const bool8 wasPaused = Settings.Paused;
const uint32 prevFrameTime = Settings.FrameTime;
// stop current movie before opening
change_state(MOVIE_STATE_NONE);
// read header
if((result=read_movie_header(fd, &Movie))!=SUCCESS)
{
fclose(fd);
return result;
}
read_movie_extrarominfo(fd, &Movie);
fn=dup(fileno(fd));
fclose(fd);
// apparently this lseek is necessary
lseek(fn, Movie.SaveStateOffset, SEEK_SET);
if(!(stream=REOPEN_STREAM(fn, "rb")))
return FILE_NOT_FOUND;
// store previous, before changing to the movie's settings
store_previous_settings();
// store default
if (sync_flags & MOVIE_SYNC_DATA_EXISTS)
{
Settings.UseWIPAPUTiming = (sync_flags & MOVIE_SYNC_WIP1TIMING) ? TRUE : FALSE;
Settings.SoundEnvelopeHeightReading = (sync_flags & MOVIE_SYNC_VOLUMEENVX) ? TRUE : FALSE;
Settings.FakeMuteFix = (sync_flags & MOVIE_SYNC_FAKEMUTE) ? TRUE : FALSE;
Settings.UpAndDown = (sync_flags & MOVIE_SYNC_LEFTRIGHT) ? TRUE : FALSE; // doesn't actually affect synchronization
Settings.SoundSync = (sync_flags & MOVIE_SYNC_SYNCSOUND) ? TRUE : FALSE; // doesn't seem to affect synchronization
Settings.InitFastROMSetting = (sync_flags2 & MOVIE_SYNC2_INIT_FASTROM) ? TRUE : FALSE;
//Settings.ShutdownMaster = (sync_flags & MOVIE_SYNC_NOCPUSHUTDOWN) ? FALSE : TRUE;
}
// set from movie
restore_movie_settings();
if(Movie.Opts & MOVIE_OPT_FROM_RESET)
{
Movie.State = MOVIE_STATE_PLAY; // prevent NSRT controller switching (in S9xPostRomInit)
if(!Memory.LoadLastROM())
S9xReset();
Memory.ClearSRAM(false); // in case the SRAM read fails
Movie.State = MOVIE_STATE_NONE;
// save only SRAM for a from-reset snapshot
result=(READ_STREAM(Memory.SRAM, 0x20000, stream) == 0x20000) ? SUCCESS : WRONG_FORMAT;
}
else
{
result=S9xUnfreezeFromStream(stream);
}
CLOSE_STREAM(stream);
if(result!=SUCCESS)
{
return result;
}
if(!(fd=fopen(movie_filename, "rb+")))
if(!(fd=fopen(movie_filename, "rb")))
return FILE_NOT_FOUND;
else
read_only = TRUE;
if(fseek(fd, Movie.ControllerDataOffset, SEEK_SET))
return WRONG_FORMAT;
// read controller data
Movie.File=fd;
Movie.BytesPerFrame=bytes_per_frame();
Movie.InputBufferPtr=Movie.InputBuffer;
uint32 to_read=Movie.BytesPerFrame * (Movie.MaxFrame+1);
reserve_buffer_space(to_read);
fread(Movie.InputBufferPtr, 1, to_read, fd);
// read "baseline" controller data
if(Movie.MaxFrame)
read_frame_controller_data();
strncpy(Movie.Filename, movie_filename, _MAX_PATH);
Movie.Filename[_MAX_PATH-1]='\0';
Movie.CurrentFrame=0;
Movie.ReadOnly=read_only;
change_state(MOVIE_STATE_PLAY);
Settings.Paused = wasPaused;
Settings.FrameTime = prevFrameTime; // restore emulation speed
Movie.RecordedThisSession = false;
S9xUpdateFrameCounter(-1);
Movie.RequiresReset = false;
S9xMessage(S9X_INFO, S9X_MOVIE_INFO, MOVIE_INFO_REPLAY);
return SUCCESS;
}
int mainEntry(int argc, char* argv[])
{
int ref = 0;
s32 event=EVENT_NONE;
sal_Init();
sal_VideoInit(16,SAL_RGB(0,0,0),Memory.ROMFramesPerSecond);
mRomName[0]=0;
if (argc >= 2)
strcpy(mRomName, argv[1]); // Record ROM name
MenuInit(sal_DirectoryGetHome(), &mMenuOptions);
if(SnesInit() == SAL_ERROR)
{
sal_Reset();
return 0;
}
while(1)
{
mInMenu=1;
event=MenuRun(mRomName);
mInMenu=0;
if(event==EVENT_LOAD_ROM)
{
if(mTempState) free(mTempState);
mTempState=NULL;
if(SnesRomLoad() == SAL_ERROR)
{
MenuMessageBox("Failed to load rom",mRomName,"Press any button to continue", MENU_MESSAGE_BOX_MODE_PAUSE);
sal_Reset();
return 0;
}
else
{
event=EVENT_RUN_ROM;
}
}
if(event==EVENT_RESET_ROM)
{
S9xReset();
event=EVENT_RUN_ROM;
}
if(event==EVENT_RUN_ROM)
{
if(mMenuOptions.fullScreen)
{
sal_VideoSetScaling(SNES_WIDTH,SNES_HEIGHT);
}
if(mMenuOptions.transparency) Settings.Transparency = TRUE;
else Settings.Transparency = FALSE;
sal_AudioSetVolume(mMenuOptions.volume,mMenuOptions.volume);
sal_CpuSpeedSet(mMenuOptions.cpuSpeed);
sal_VideoClear(0);
sal_VideoFlip(1);
sal_VideoClear(0);
sal_VideoFlip(1);
if(mMenuOptions.soundEnabled)
RunSound();
else RunNoSound();
event=EVENT_NONE;
}
if(event==EVENT_EXIT_APP) break;
}
if(mTempState) free(mTempState);
mTempState=NULL;
S9xGraphicsDeinit();
S9xDeinitAPU();
Memory.Deinit();
free(GFX.SubZBuffer);
free(GFX.ZBuffer);
free(GFX.SubScreen);
GFX.SubZBuffer=NULL;
GFX.ZBuffer=NULL;
GFX.SubScreen=NULL;
sal_Reset();
return 0;
}
void menu_loop(void)
{
bool8_32 exit_loop = false;
char fname[256], ext[8];
char snapscreen_tmp[17120];
uint8 *keyssnes = 0;
SaveSlotNum_old = -1;
Scale_org = Scale;
highres_current=Settings.SupportHiRes;
capt_screenshot();
memcpy(snapscreen_tmp,snapscreen,17120);
Scale = false;
Settings.SupportHiRes=FALSE;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
menu_dispupdate();
sys_sleep(100000);
SDL_Event event;
do
{
while(SDL_PollEvent(&event)==1)
{
//PANDORA & DINGOO & WIN32 -----------------------------------------------------
keyssnes = SDL_GetKeyState(NULL);
if(keyssnes[sfc_key[UP_1]] == SDL_PRESSED)
cursor--;
else if(keyssnes[sfc_key[DOWN_1]] == SDL_PRESSED)
cursor++;
else if( (keyssnes[sfc_key[A_1]] == SDL_PRESSED) ||
(keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED) ||
(keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED) )
{
switch(cursor)
{
case 2: //exit snes9x
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
S9xExit();
break;
case 3: //reset snes9x
if ((keyssnes[sfc_key[A_1]] == SDL_PRESSED))
{
//make sure the sram is stored before resetting the console
//it should work without, but better safe than sorry...
Memory.SaveSRAM (S9xGetFilename (".srm"));
S9xReset();
exit_loop = TRUE;
}
break;
case 4:
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
ShowCredit();
break;
case 6: //save state
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
{
memcpy(snapscreen,snapscreen_tmp,16050);
show_screenshot();
strcpy(fname," Saving...");
S9xDisplayString (temp, GFX.Screen +320/*280*/, 640,80/*204*/);
S9xDeinitUpdate (320, 240);
sprintf(ext, ".s0%d", SaveSlotNum);
strcpy(fname, S9xGetFilename (ext));
save_screenshot(fname);
sprintf(ext, ".00%d", SaveSlotNum);
strcpy(fname, S9xGetFilename (ext));
S9xFreezeGame (fname);
sync();
exit_loop = TRUE;
}
break;
case 7: //load state
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
{
sprintf(ext, ".00%d", SaveSlotNum);
strcpy(fname, S9xGetFilename (ext));
S9xLoadSnapshot (fname);
exit_loop = TRUE;
}
break;
case 8: //select save state slot
if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED)
{
if ( SaveSlotNum == 0 )
SaveSlotNum = MAX_SAVE_SLOTS-1; // slots start at 0, so 10 slots means slot 0 to 9
else
--SaveSlotNum;
}
else
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
{
if ( SaveSlotNum == MAX_SAVE_SLOTS-1 ) // slots start at 0, so 10 slots means slot 0 to 9
SaveSlotNum = 0;
else
++SaveSlotNum;
}
break;
case 10: // rotate through scalers
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
{
do
{
g_scale = (blit_scaler_e) ( ( g_scale + 1 ) % bs_max );
} while ( ( blit_scalers [ g_scale ].valid == bs_invalid )
|| ( highres_current && !(blit_scalers [ g_scale ].support_hires) ) );
} else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED)
{
do
{
g_scale = (blit_scaler_e) ( g_scale - 1 );
if (g_scale < 1) g_scale = (blit_scaler_e)(bs_max-1);
} while ( ( blit_scalers [ g_scale ].valid == bs_invalid )
|| ( highres_current && !(blit_scalers [ g_scale ].support_hires) ) );
}
// now force update the display, so that the new scaler is directly used (fixes some glitches)
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 11: // set frameskip
if (Settings.SkipFrames == AUTO_FRAMERATE)
Settings.SkipFrames = 10;
if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED)
Settings.SkipFrames--;
else
Settings.SkipFrames++;
if(Settings.SkipFrames<=0 || Settings.SkipFrames==10)
Settings.SkipFrames = AUTO_FRAMERATE;
else if (Settings.SkipFrames>=11)
Settings.SkipFrames = 1;
break;
case 12: // set vsync
if (g_vsync)
g_vsync = 0;
else
g_vsync = 1;
break;
case 13: // set display fps
Settings.DisplayFrameRate = !Settings.DisplayFrameRate;
break;
case 14: // set transparency
Settings.Transparency = !Settings.Transparency;
break;
case 15: // cut lines from top
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_top++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_top>0)
cut_top--;
// now force update the display, so that the new scaler is directly used (fixes some glitches)
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 16: // cut lines from bottom
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_bottom++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_bottom>0)
cut_bottom--;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 17: // cut from the left
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_left++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_left>0)
cut_left--;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 18: // cut from the right
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_right++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_right>0)
cut_right--;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 20:
//offer an option to change to alternative sample decoding
//cf. http://www.gp32x.com/board/index.php?/topic/55378-snes9x4d4p-another-new-build-now-with-hi-res-and-new-rom-picker/page__view__findpost__p__958860
if (Settings.AltSampleDecode)
Settings.AltSampleDecode = 0;
else
Settings.AltSampleDecode = 1;
break;
}
}
if(cursor==1)
cursor=20;
else if(cursor==21)
cursor=2;
if(cursor==5 || cursor==9 || cursor==19) {
if(keyssnes[sfc_key[UP_1]] == SDL_PRESSED)
cursor--;
else if(keyssnes[sfc_key[DOWN_1]] == SDL_PRESSED)
cursor++;
}
menu_dispupdate();
sys_sleep(1000);
break;
}
}
while( exit_loop!=TRUE && keyssnes[sfc_key[B_1]] != SDL_PRESSED );
Scale = Scale_org;
Settings.SupportHiRes=highres_current;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
}
static int Unfreeze()
{
// notaz: overflowing the damn Symbian stack again
char buffer [16];
char rom_filename [512];
int result;
int version;
unsigned int len = strlen(SNAPSHOT_MAGIC) + 1 + 4 + 1;
if (statef_read(buffer, len) != (int)len)
return (WRONG_FORMAT);
if (strncmp(buffer, SNAPSHOT_MAGIC, strlen(SNAPSHOT_MAGIC)) != 0)
return (WRONG_FORMAT);
if ((version = atoi(&buffer [strlen(SNAPSHOT_MAGIC) + 1])) > SNAPSHOT_VERSION)
return (WRONG_VERSION);
if ((result = UnfreezeBlock("NAM", (uint8*) rom_filename, 512)) != SUCCESS)
return (result);
if (strcasecmp(rom_filename, Memory.ROMFilename) != 0 &&
strcasecmp(S9xBasename(rom_filename), S9xBasename(Memory.ROMFilename)) != 0)
{
S9xMessage(S9X_WARNING, S9X_FREEZE_ROM_NAME,
"Current loaded ROM image doesn't match that required by freeze-game file.");
}
uint32 old_flags = CPU.Flags;
#ifdef USE_SA1
uint32 sa1_old_flags = SA1.Flags;
#endif
S9xReset();
S9xSetSoundMute(TRUE);
if ((result = UnfreezeStruct("CPU", &CPU, SnapCPU,
COUNT(SnapCPU))) != SUCCESS)
return (result);
FixROMSpeed();
CPU.Flags |= old_flags & (DEBUG_MODE_FLAG | TRACE_FLAG |
SINGLE_STEP_FLAG | FRAME_ADVANCE_FLAG);
if ((result = UnfreezeStruct("REG", &Registers, SnapRegisters, COUNT(SnapRegisters))) != SUCCESS)
return (result);
if ((result = UnfreezeStruct("PPU", &PPU, SnapPPU, COUNT(SnapPPU))) != SUCCESS)
return (result);
IPPU.ColorsChanged = TRUE;
IPPU.OBJChanged = TRUE;
CPU.InDMA = FALSE;
// Restore colors from PPU
unsigned int i;
for (i = 0; i < 256; i++)
{
IPPU.Red[i] = PPU.CGDATA[i] & 0x1f;
IPPU.Green[i] = (PPU.CGDATA[i] >> 5) & 0x1f;
IPPU.Blue[i] = (PPU.CGDATA[i] >> 10) & 0x1f;
}
S9xFixColourBrightness();
IPPU.RenderThisFrame = FALSE;
if ((result = UnfreezeStruct("DMA", DMA, SnapDMA,
COUNT(SnapDMA))) != SUCCESS)
return (result);
if ((result = UnfreezeBlock("VRA", Memory.VRAM, 0x10000)) != SUCCESS)
return (result);
if ((result = UnfreezeBlock("RAM", Memory.RAM, 0x20000)) != SUCCESS)
return (result);
if ((result = UnfreezeBlock("SRA", SRAM, 0x20000)) != SUCCESS)
return (result);
if ((result = UnfreezeBlock("FIL", Memory.FillRAM, 0x8000)) != SUCCESS)
return (result);
// Restore graphics shadow registers
GFX.r212c_s = Memory.FillRAM[0x212c];
GFX.r212d_s = Memory.FillRAM[0x212d];
GFX.r212e_s = Memory.FillRAM[0x212e];
GFX.r212f_s = Memory.FillRAM[0x212f];
GFX.r2130_s = Memory.FillRAM[0x2130];
GFX.r2131_s = Memory.FillRAM[0x2131];
if (UnfreezeStruct("APU", &APU, SnapAPU, COUNT(SnapAPU)) == SUCCESS)
{
SAPURegisters spcregs;
if ((result = UnfreezeStruct("ARE", &spcregs, SnapAPURegisters,
COUNT(SnapAPURegisters))) != SUCCESS)
return (result);
// reload all SPC700 regs from savestate compatible struct
IAPU.P = spcregs.P;
IAPU.YA.W = spcregs.YA.W;
IAPU.X = spcregs.X;
IAPU.S = spcregs.S;
IAPU.PC = IAPU.RAM + spcregs.PC;
if ((result = UnfreezeBlock("ARA", IAPU.RAM, 0x10000)) != SUCCESS)
return (result);
if ((result = UnfreezeStruct("SOU", &SoundData, SnapSoundData,
COUNT(SnapSoundData))) != SUCCESS)
return (result);
// notaz: just to be sure
int u;
for (u = 0; u < 8; u++)
{
SoundData.channels[u].env_ind_attack &= 0xf;
SoundData.channels[u].env_ind_decay &= 0x7;
SoundData.channels[u].env_ind_sustain &= 0x1f;
}
S9xSetSoundMute(FALSE);
S9xAPUUnpackStatus();
if (APUCheckDirectPage())
IAPU.DirectPage = IAPU.RAM + 0x100;
else
IAPU.DirectPage = IAPU.RAM;
Settings.APUEnabled = TRUE;
/*IAPU.APUExecuting*/CPU.APU_APUExecuting = TRUE;
}
else
{
Settings.APUEnabled = FALSE;
/*IAPU.APUExecuting*/CPU.APU_APUExecuting = FALSE;
S9xSetSoundMute(TRUE);
}
#ifdef USE_SA1
if ((result = UnfreezeStruct("SA1", &SA1, SnapSA1,
COUNT(SnapSA1))) == SUCCESS)
{
if ((result = UnfreezeStruct("SAR", &SA1Registers,
SnapSA1Registers, COUNT(SnapSA1Registers))) != SUCCESS)
return (result);
S9xFixSA1AfterSnapshotLoad();
SA1.Flags |= sa1_old_flags & (TRACE_FLAG);
}
#endif
S9xFixSoundAfterSnapshotLoad();
ICPU.ShiftedPB = Registers.PB << 16;
ICPU.ShiftedDB = Registers.DB << 16;
S9xSetPCBase(ICPU.ShiftedPB + Registers.PC);
#ifndef ASMCPU
S9xUnpackStatus(); // not needed
S9xFixCycles(); // also not needed?
#endif
S9xReschedule();
S9xSRTCPostLoadState();
if (Settings.SDD1) S9xSDD1PostLoadState();
return (SUCCESS);
}
