void SaveState()
{
LOG_DBG("SaveState()\n");
char * currentsavestate;
currentsavestate = new char [999];
strcpy(currentsavestate, Settings.PS3PathSaveStates.c_str());
LOG_DBG("Settings.PS3PathSaveStates.size() = %d\n", Settings.PS3PathSaveStates.size());
LOG_DBG("Settings.PS3PathSaveStates = %s\n", Settings.PS3PathSaveStates.c_str());
LOG_DBG("Savestate path: %s \n",currentsavestate);
ChangePathAndExt(current_rom,".sav",currentsavestate);
FILE *f = fopen(currentsavestate,"wb");
if (f)
{
LOG("f: %s\n", currentsavestate);
printf("Enter in savestate\n");
uint8 *buf =(uint8 *)memalign(32,STATE_SIZE);
int state_size = state_save(buf);
LOG_DBG("Writing savestate...\n");
fwrite(buf, state_size, 1, f);
LOG_DBG("Writing of savestate done!\n");
fclose(f);
free(buf);
LOG_DBG("Out from savestate\n");
}
}
void save_state(const char *dest) {
FILE *f = fopen(dest, "w+b");
if (f) {
state_save(state_buf);
fwrite(&state_buf, STATE_SIZE, 1, f);
fclose(f);
SYSMenuDisplayString("Saved state to %s", dest);
}
}
bool
cmd_save ( char * const cmd , State * const state )
{
/*
* Try and pull a filename off the command.
*/
char* filename = strtok ( NULL , " \n" );
/*
* Initialize the return value to false, for failure.
*/
bool retval = false;
if ( filename )
{
/*
* If a filename was given, try and save to filename.
*/
/*
* Attempt to open the file. If successful, save the state to
* the file. Close the file.
*/
FILE* savefile = fopen ( filename , "w" );
retval = savefile && state_save ( state , savefile );
fclose ( savefile );
}
else
{
/*
* If no filename was provided, save to stdout.
*/
retval = state_save ( state , stdout );
}
/*
* Return the retval.
*/
return retval;
};
GPGX_EX int gpgx_state_size(void *dest, int size)
{
int actual = 0;
if (size < gpgx_state_max_size())
return -1;
actual = state_save((unsigned char*) dest);
if (actual > size)
// fixme!
return -1;
return actual;
}
void Application::saveState(const int i)
{
char path[MAX_PATH];
makePath(_stateDir, path);
sprintf(path, "%s%d.sav", path, i);
LOGD("SaveState: %s", path);
FILE *f = fopen(path,"wb");
if (f)
{
uint8 *buf =(uint8 *)memalign(32,STATE_SIZE);
int state_size = state_save(buf, 1);
fwrite(buf, state_size, 1, f);
fclose(f);
free(buf);
}
}
//initialize movie data for recording
int movie_record()
{
//get rid of previous data
if(nes->movie.data)
movie_unload();
//initialize the movie struct
nes->movie.mode &= ~7;
nes->movie.mode |= MOVIE_RECORD;
nes->movie.pos = 0;
nes->movie.len = MOVIE_PREALLOC_SIZE;
nes->movie.data = (u8*)mem_alloc(nes->movie.len);
nes->movie.startframe = nes->ppu.frames;
//save state here for loading
nes->movie.state = memfile_create();
state_save(nes->movie.state);
return(0);
}
static int gui_state_save(int slot)
{
if (sshot_img) {
free(sshot_img);
sshot_img = NULL;
}
// Remember which saveslot was accessed last
saveslot = slot;
video_clear();
port_printf(160-(6*8/2), 120-(8/2), "SAVING");
video_flip();
if (state_save(slot) < 0) {
// Error saving
for (;;) {
u32 keys = key_read();
video_clear();
// check keys
if (keys) {
key_reset();
return 0;
}
port_printf(160-(11*8/2), 120-12, "SAVE FAILED");
port_printf(160-(18*8/2), 120+12, "Out of disk space?");
video_flip();
timer_delay(75);
}
}
// Return -1 to gui_StateSave() caller menu, so it knows
// to tell main menu to return back to main menu.
return -1;
}
static int event_key(SDL_KeyboardEvent key, int state)
{
SDL_Keysym k;
k = key.keysym;
if((k.mod & KMOD_CTRL) && (k.mod & KMOD_LGUI) && (k.mod & KMOD_SHIFT)) {
if(k.sym == SDLK_F1) {
screen_set_delay(0);
} else if(k.sym == SDLK_F2) {
screen_set_delay(10000);
} else if(k.sym == SDLK_F3) {
screen_set_delay(20000);
} else if(k.sym == SDLK_F4) {
screen_set_delay(30000);
} else if(k.sym == SDLK_F5) {
screen_set_delay(40000);
} else if(k.sym == SDLK_F6) {
screen_set_delay(50000);
} else if(k.sym == SDLK_F7) {
screen_set_delay(75000);
} else if(k.sym == SDLK_F8) {
screen_set_delay(100000);
} else if(k.sym == SDLK_F9) {
screen_set_delay(150000);
} else if(k.sym == SDLK_F10) {
screen_set_delay(200000);
} else if(k.sym == SDLK_F11) {
screen_set_delay(500000);
} else if(k.sym == SDLK_F12) {
screen_set_delay(1000000);
}
return EVENT_NONE;
}
if((k.sym == ' ') || (k.sym == 27) ||
((k.sym >= '0') && (k.sym <= '9')) ||
((k.sym >= 'a') && (k.sym <= 'z')) ||
(k.sym == '\'') || (k.sym == ',') || (k.sym == '-') || (k.sym == '.') ||
(k.sym == '/') || (k.sym == ';') || (k.sym == '=') || (k.sym == '[') ||
(k.sym == '\\') || (k.sym == ']') || (k.sym == '`') ||
(k.sym == '\r') || (k.sym == '\b') || (k.sym == '\t')
) {
ikbd_queue_key(scancode[k.sym], state);
} else if((k.sym >= SDLK_F1) && (k.sym <= SDLK_F10)) {
ikbd_queue_key(SCAN_F1+k.sym-SDLK_F1, state);
} else if(k.sym == SDLK_F11) {
if(k.mod & KMOD_CTRL && state == EVENT_RELEASE) {
printf("DEBUG: Toggle screen disable\n");
screen_disable(!screen_check_disable());
} else {
if(state == EVENT_RELEASE) {
if(debugger)
return EVENT_DEBUG;
else {
state_save("ostis.state", state_collect());
SDL_Quit();
exit(0);
}
}
}
} else if(k.sym == SDLK_PAUSE) {
if(k.mod & KMOD_CTRL) {
if(state == EVENT_RELEASE) {
screen_toggle_fullscreen();
}
} else {
if(state == EVENT_RELEASE) {
screen_toggle_grab();
}
}
} else if(k.sym == SDLK_PRINTSCREEN) {
if(k.mod & KMOD_ALT) {
if(state == EVENT_RELEASE) {
printf("DEBUG: Start debugger\n");
}
} else {
if(state == EVENT_RELEASE) {
// TODO: toggle this state.
diag_set_module_levels("CPU0:6");
}
}
} else if(k.sym == SDLK_F12) {
if(state == EVENT_RELEASE) {
printf("-------------------------------------------\n");
cpu_print_status(CPU_USE_CURRENT_PC);
printf("- - - - - - - - - - - - - - - - - - - - - -\n");
mfp_print_status();
printf("- - - - - - - - - - - - - - - - - - - - - -\n");
ikbd_print_status();
printf("DEBUG: Speed: %g FPS\n", screen_fps());
printf("-------------------------------------------\n");
}
} else if(k.sym == SDLK_F13) {
if(state == EVENT_RELEASE) {
printf("DEBUG: Collecting state\n");
laststate = state_collect();
}
} else if(k.sym == SDLK_F14) {
if(state == EVENT_RELEASE) {
printf("DEBUG: Restoring state\n");
state_restore(laststate);
}
} else if(k.sym == SDLK_LSHIFT) {
ikbd_queue_key(SCAN_LSHIFT, state);
} else if(k.sym == SDLK_RSHIFT) {
ikbd_queue_key(SCAN_RSHIFT, state);
} else if(k.sym == SDLK_LCTRL) {
ikbd_queue_key(SCAN_CONTROL, state);
} else if(k.sym == SDLK_LALT) {
ikbd_queue_key(SCAN_ALT, state);
} else if(k.sym == SDLK_UP) {
ikbd_queue_key(SCAN_UP, state);
} else if(k.sym == SDLK_DOWN) {
ikbd_queue_key(SCAN_DOWN, state);
} else if(k.sym == SDLK_LEFT) {
ikbd_queue_key(SCAN_LEFT, state);
} else if(k.sym == SDLK_RIGHT) {
ikbd_queue_key(SCAN_RIGHT, state);
} else if(k.sym == SDLK_END) {
ikbd_queue_key(SCAN_INSERT, state);
} else if(k.sym == SDLK_PAGEDOWN) {
ikbd_queue_key(SCAN_DELETE, state);
} else {
printf("Unimplemented key: %d\n", k.sym);
}
return EVENT_NONE;
}
int slot_save(int slot, int device)
{
char filename[MAXPATHLEN];
int filesize, done = 0;
int offset = device ? 2112 : 0;
u8 *savebuffer;
if (slot > 0)
{
/* allocate buffer */
savebuffer = (u8 *)memalign(32,STATE_SIZE);
if (!savebuffer)
{
GUI_WaitPrompt("Error","Unable to allocate memory !");
return 0;
}
GUI_MsgBoxOpen("Information","Saving State ...",1);
filesize = state_save(&savebuffer[offset]);
}
else
{
if (!sram.on)
{
GUI_WaitPrompt("Error","SRAM is disabled !");
return 0;
}
/* allocate buffer */
savebuffer = (u8 *)memalign(32,0x10000+offset);
if (!savebuffer)
{
GUI_WaitPrompt("Error","Unable to allocate memory !");
return 0;
}
GUI_MsgBoxOpen("Information","Saving SRAM ...",1);
memcpy(&savebuffer[offset], sram.sram, 0x10000);
sram.crc = crc32(0, sram.sram, 0x10000);
filesize = 0x10000;
}
if (!device)
{
/* FAT support */
if (slot > 0)
sprintf(filename, "%s/saves/%s.gp%d", DEFAULT_PATH, rom_filename, slot - 1);
else
sprintf(filename, "%s/saves/%s.srm", DEFAULT_PATH, rom_filename);
/* Open file */
FILE *fp = fopen(filename, "wb");
if (!fp)
{
GUI_WaitPrompt("Error","Unable to open file !");
free(savebuffer);
return 0;
}
/* Write from buffer (2k blocks) */
while (filesize > FILECHUNK)
{
fwrite(savebuffer + done, FILECHUNK, 1, fp);
done += FILECHUNK;
filesize -= FILECHUNK;
}
/* Write remaining bytes */
fwrite(savebuffer + done, filesize, 1, fp);
done += filesize;
fclose(fp);
}
else
{
/* Memory Card support */
if (slot > 0)
sprintf(filename, "MD-%04X.gp%d", rominfo.realchecksum, slot - 1);
else
sprintf(filename, "MD-%04X.srm", rominfo.realchecksum);
/* Initialise the CARD system */
char action[64];
memset(&SysArea, 0, CARD_WORKAREA);
CARD_Init("GENP", "00");
/* CARD slot */
device--;
/* Attempt to mount the card */
if (!CardMount(device))
{
GUI_WaitPrompt("Error","Unable to mount memory card");
free(savebuffer);
return 0;
}
/* Retrieve the sector size */
u32 SectorSize = 0;
int CardError = CARD_GetSectorSize(device, &SectorSize);
if (!SectorSize)
{
sprintf(action, "Invalid sector size (%d)", CardError);
GUI_WaitPrompt("Error",action);
CARD_Unmount(device);
free(savebuffer);
return 0;
}
/* Build the output buffer */
char comment[2][32] = { {"Genesis Plus GX"}, {"SRAM Save"} };
strcpy (comment[1], filename);
memcpy (&savebuffer[0], &icon, 2048);
memcpy (&savebuffer[2048], &comment[0], 64);
/* Adjust file size */
filesize += 2112;
if (filesize % SectorSize)
filesize = ((filesize / SectorSize) + 1) * SectorSize;
/* Check if file already exists */
card_file CardFile;
if (CARD_Open(device, filename, &CardFile) == CARD_ERROR_READY)
{
int size = filesize - CardFile.len;
CARD_Close(&CardFile);
memset(&CardFile,0,sizeof(CardFile));
/* Check file new size */
if (size > 0)
{
CardError = CARD_Create(device, "TEMP", size, &CardFile);
if (CardError)
{
sprintf(action, "Unable to increase file size (%d)", CardError);
GUI_WaitPrompt("Error",action);
CARD_Unmount(device);
free(savebuffer);
return 0;
}
/* delete temporary file */
CARD_Close(&CardFile);
memset(&CardFile,0,sizeof(CardFile));
CARD_Delete(device, "TEMP");
}
/* delete previously existing file */
CARD_Delete(device, filename);
}
/* Create a new file */
CardError = CARD_Create(device, filename, filesize, &CardFile);
if (CardError)
{
sprintf(action, "Unable to create file (%d)", CardError);
GUI_WaitPrompt("Error",action);
CARD_Unmount(device);
free(savebuffer);
return 0;
}
/* Update file informations */
time_t rawtime;
time(&rawtime);
card_stat CardStatus;
CARD_GetStatus(device, CardFile.filenum, &CardStatus);
CardStatus.icon_addr = 0x0;
CardStatus.icon_fmt = 2;
CardStatus.icon_speed = 1;
CardStatus.comment_addr = 2048;
CardStatus.time = rawtime;
CARD_SetStatus(device, CardFile.filenum, &CardStatus);
/* Write file sectors */
while (filesize > 0)
{
CARD_Write(&CardFile, &savebuffer[done], SectorSize, done);
filesize -= SectorSize;
done += SectorSize;
}
/* Close file */
CARD_Close(&CardFile);
CARD_Unmount(device);
}
GUI_MsgBoxClose();
free(savebuffer);
/* Save screenshot */
if (slot && !device)
{
sprintf(filename,"%s/saves/%s__%d.png", DEFAULT_PATH, rom_filename, slot - 1);
gxSaveScreenshot(filename);
}
return 1;
}
GPGX_EX int gpgx_state_save(void *dest, int size)
{
return state_save((unsigned char*) dest) == size;
}
static int cmd_savestate(int argc, char **argv)
{
state_save(argc > 1 ? atoi(argv[1]) : -1);
return 0;
}
void emulator_save_state()
{
state_save();
}
