int SaveStateGz(gzFile f, long* gzsize) { int Size; unsigned char pMemGpuPic[SZ_GPUPIC]; //if (f == NULL) return -1; gzwrite(f, (void *)PcsxrHeader, sizeof(PcsxrHeader)); gzwrite(f, (void *)&SaveVersion, sizeof(u32)); gzwrite(f, (void *)&Config.HLE, sizeof(boolean)); if (gzsize)GPU_getScreenPic(pMemGpuPic); // Not necessary with ephemeral saves gzwrite(f, pMemGpuPic, SZ_GPUPIC); if (Config.HLE) psxBiosFreeze(1); gzwrite(f, psxM, 0x00200000); gzwrite(f, psxR, 0x00080000); gzwrite(f, psxH, 0x00010000); gzwrite(f, (void *)&psxRegs, sizeof(psxRegs)); // gpu if (!gpufP)gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t)); gpufP->ulFreezeVersion = 1; GPU_freeze(1, gpufP); gzwrite(f, gpufP, sizeof(GPUFreeze_t)); // SPU Plugin cannot change during run, so we query size info just once per session if (!spufP) { spufP = (SPUFreeze_t *)malloc(offsetof(SPUFreeze_t, SPUPorts)); // only first 3 elements (up to Size) SPU_freeze(2, spufP); Size = spufP->Size; SysPrintf("SPUFreezeSize %i/(%i)\n", Size, offsetof(SPUFreeze_t, SPUPorts)); free(spufP); spufP = (SPUFreeze_t *) malloc(Size); spufP->Size = Size; if (spufP->Size <= 0) { gzclose(f); free(spufP); spufP = NULL; return 1; // error } } // spu gzwrite(f, &(spufP->Size), 4); SPU_freeze(1, spufP); gzwrite(f, spufP, spufP->Size); sioFreeze(f, 1); cdrFreeze(f, 1); psxHwFreeze(f, 1); psxRcntFreeze(f, 1); mdecFreeze(f, 1); if(gzsize)*gzsize = gztell(f); gzclose(f); return 0; }
int SaveState(const char *file) { void *f; GPUFreeze_t *gpufP; SPUFreeze_t *spufP; int Size; unsigned char *pMem; f = SaveFuncs.open(file, "wb"); if (f == NULL) return -1; new_dyna_before_save(); SaveFuncs.write(f, (void *)PcsxHeader, 32); SaveFuncs.write(f, (void *)&SaveVersion, sizeof(u32)); SaveFuncs.write(f, (void *)&Config.HLE, sizeof(boolean)); pMem = (unsigned char *)malloc(128 * 96 * 3); if (pMem == NULL) return -1; GPU_getScreenPic(pMem); SaveFuncs.write(f, pMem, 128 * 96 * 3); free(pMem); if (Config.HLE) psxBiosFreeze(1); SaveFuncs.write(f, psxM, 0x00200000); SaveFuncs.write(f, psxR, 0x00080000); SaveFuncs.write(f, psxH, 0x00010000); SaveFuncs.write(f, (void *)&psxRegs, sizeof(psxRegs)); // gpu gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t)); gpufP->ulFreezeVersion = 1; GPU_freeze(1, gpufP); SaveFuncs.write(f, gpufP, sizeof(GPUFreeze_t)); free(gpufP); // spu spufP = (SPUFreeze_t *) malloc(16); SPU_freeze(2, spufP, psxRegs.cycle); Size = spufP->Size; SaveFuncs.write(f, &Size, 4); free(spufP); spufP = (SPUFreeze_t *) malloc(Size); SPU_freeze(1, spufP, psxRegs.cycle); SaveFuncs.write(f, spufP, Size); free(spufP); sioFreeze(f, 1); cdrFreeze(f, 1); psxHwFreeze(f, 1); psxRcntFreeze(f, 1); mdecFreeze(f, 1); new_dyna_freeze(f, 1); SaveFuncs.close(f); new_dyna_after_save(); return 0; }
int SaveState(char *file) { gzFile f; GPUFreeze_t *gpufP; SPUFreeze_t *spufP; int Size; unsigned char *pMem; f = gzopen(file, "wb"); if (f == NULL) return -1; gzwrite(f, (void*)PcsxHeader, 32); pMem = (unsigned char *) malloc(128*96*3); if (pMem == NULL) return -1; GPU_getScreenPic(pMem); gzwrite(f, pMem, 128*96*3); free(pMem); gzwrite(f, psxM, 0x00200000); gzwrite(f, psxR, 0x00080000); gzwrite(f, psxH, 0x00010000); gzwrite(f, (void*)&psxRegs, sizeof(psxRegs)); //AgemoTrace("sizeof(psxRegs) %X", sizeof(psxRegs)); //AgemoTrace("sizeof(psxGPRRegs) %X", sizeof(psxGPRRegs)); //AgemoTrace("sizeof(psxCP0Regs) %X", sizeof(psxCP0Regs)); //AgemoTrace("sizeof(psxCP2Data) %X", sizeof(psxCP2Data)); //AgemoTrace("sizeof(psxCP2Ctrl) %X", sizeof(psxCP2Ctrl)); // gpu gpufP = (GPUFreeze_t *) malloc(sizeof(GPUFreeze_t)); gpufP->ulFreezeVersion = 1; GPU_freeze(1, gpufP); gzwrite(f, gpufP, sizeof(GPUFreeze_t)); free(gpufP); // spu spufP = (SPUFreeze_t *) malloc(16); SPU_freeze(2, spufP); Size = spufP->Size; gzwrite(f, &Size, 4); free(spufP); spufP = (SPUFreeze_t *) malloc(Size); SPU_freeze(1, spufP); gzwrite(f, spufP, Size); free(spufP); sioFreeze(f, 1); cdrFreeze(f, 1); psxHwFreeze(f, 1); psxRcntFreeze(f, 1); mdecFreeze(f, 1); gzclose(f); return 0; }
int LoadState(const char *file) { gzFile f; GPUFreeze_t *gpufP; SPUFreeze_t *spufP; int Size; char header[32]; u32 version; boolean hle; f = gzopen(file, "rb"); if (f == NULL) return -1; gzread(f, header, sizeof(header)); gzread(f, &version, sizeof(u32)); gzread(f, &hle, sizeof(boolean)); if (strncmp("STv4 PCSXR", header, 10) != 0 || version != SaveVersion || hle != Config.HLE) { gzclose(f); return -1; } psxCpu->Reset(); gzseek(f, 128 * 96 * 3, SEEK_CUR); gzread(f, psxM, 0x00200000); gzread(f, psxR, 0x00080000); gzread(f, psxH, 0x00010000); gzread(f, (void *)&psxRegs, sizeof(psxRegs)); if (Config.HLE) psxBiosFreeze(0); // gpu gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t)); gzread(f, gpufP, sizeof(GPUFreeze_t)); GPU_freeze(0, gpufP); free(gpufP); // spu gzread(f, &Size, 4); spufP = (SPUFreeze_t *)malloc(Size); gzread(f, spufP, Size); SPU_freeze(0, spufP); free(spufP); sioFreeze(f, 0); cdrFreeze(f, 0); psxHwFreeze(f, 0); psxRcntFreeze(f, 0); mdecFreeze(f, 0); gzclose(f); return 0; }
int LoadState(char *file) { gzFile f; GPUFreeze_t *gpufP; SPUFreeze_t *spufP; int Size; char header[32]; f = gzopen(file, "rb"); if (f == NULL) return -1; psxCpu->Reset(); agemo_flag_pause_cpu = 1; agemo_ops_total_exec = 0; agemo_ops_break = -1; __agemo_update_cpu_button_state(); __agemo_update_total_op(); gzread(f, header, 32); if (strncmp("STv3 PCSX", header, 9)) { gzclose(f); return -1; } gzseek(f, 128*96*3, SEEK_CUR); gzread(f, psxM, 0x00200000); gzread(f, psxR, 0x00080000); gzread(f, psxH, 0x00010000); gzread(f, (void*)&psxRegs, sizeof(psxRegs)); // gpu gpufP = (GPUFreeze_t *) malloc (sizeof(GPUFreeze_t)); gzread(f, gpufP, sizeof(GPUFreeze_t)); GPU_freeze(0, gpufP); free(gpufP); // spu gzread(f, &Size, 4); spufP = (SPUFreeze_t *) malloc (Size); gzread(f, spufP, Size); SPU_freeze(0, spufP); free(spufP); sioFreeze(f, 0); cdrFreeze(f, 0); psxHwFreeze(f, 0); psxRcntFreeze(f, 0); mdecFreeze(f, 0); gzclose(f); return 0; }
int LoadStateGz(gzFile f) { SPUFreeze_t *_spufP; int Size; char header[sizeof(PcsxrHeader)]; u32 version; boolean hle; if (f == NULL) return -1; gzread(f, header, sizeof(header)); gzread(f, &version, sizeof(u32)); gzread(f, &hle, sizeof(boolean)); // Compare header only "STv4 PCSXR" part no version if (strncmp(PcsxrHeader, header, PCSXR_HEADER_SZ) != 0 || version != SaveVersion || hle != Config.HLE) { gzclose(f); return -1; } psxCpu->Reset(); gzseek(f, SZ_GPUPIC, SEEK_CUR); gzread(f, psxM, 0x00200000); gzread(f, psxR, 0x00080000); gzread(f, psxH, 0x00010000); gzread(f, (void *)&psxRegs, sizeof(psxRegs)); if (Config.HLE) psxBiosFreeze(0); // gpu if (!gpufP)gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t)); gzread(f, gpufP, sizeof(GPUFreeze_t)); GPU_freeze(0, gpufP); // spu gzread(f, &Size, 4); _spufP = (SPUFreeze_t *)malloc(Size); gzread(f, _spufP, Size); SPU_freeze(0, _spufP); free(_spufP); sioFreeze(f, 0); cdrFreeze(f, 0); psxHwFreeze(f, 0); psxRcntFreeze(f, 0); mdecFreeze(f, 0); gzclose(f); return 0; }
int LoadState(const char *file) { void *f; GPUFreeze_t *gpufP; SPUFreeze_t *spufP; int Size; char header[32]; u32 version; boolean hle; f = SaveFuncs.open(file, "rb"); if (f == NULL) return -1; SaveFuncs.read(f, header, sizeof(header)); SaveFuncs.read(f, &version, sizeof(u32)); SaveFuncs.read(f, &hle, sizeof(boolean)); if (strncmp("STv4 PCSX", header, 9) != 0 || version != SaveVersion) { SaveFuncs.close(f); return -1; } Config.HLE = hle; if (Config.HLE) psxBiosInit(); psxCpu->Reset(); SaveFuncs.seek(f, 128 * 96 * 3, SEEK_CUR); SaveFuncs.read(f, psxM, 0x00200000); SaveFuncs.read(f, psxR, 0x00080000); SaveFuncs.read(f, psxH, 0x00010000); SaveFuncs.read(f, (void *)&psxRegs, sizeof(psxRegs)); if (Config.HLE) psxBiosFreeze(0); // gpu gpufP = (GPUFreeze_t *)malloc(sizeof(GPUFreeze_t)); SaveFuncs.read(f, gpufP, sizeof(GPUFreeze_t)); GPU_freeze(0, gpufP); free(gpufP); if (HW_GPU_STATUS == 0) HW_GPU_STATUS = GPU_readStatus(); // spu SaveFuncs.read(f, &Size, 4); spufP = (SPUFreeze_t *)malloc(Size); SaveFuncs.read(f, spufP, Size); SPU_freeze(0, spufP); free(spufP); sioFreeze(f, 0); cdrFreeze(f, 0); psxHwFreeze(f, 0); psxRcntFreeze(f, 0); mdecFreeze(f, 0); SaveFuncs.close(f); new_dyna_restore(); return 0; }
s32 LoadState(s8 *file) { DEBUG_STATES("starting %s", __FUNCTION__); gzFile f; GPUFreeze *gpufP; SPUFreeze_t *spufP; s32 Size; u8 header[32]; u8 filePath[256]; sprintf((char *)filePath, "%s", file); DEBUG_STATES("opening state"); f = gzopen((char *)filePath, "rb"); if (f == NULL) return -1; DEBUG_STATES("resetting CPU"); psxCpu->Reset(); DEBUG_STATES("reading header"); gzread(f, header, 32); if (strncmp("PSX STATE", (char *)header, 9)) { gzclose(f); return -1; } DEBUG_STATES("reading pointless memory"); #if 0 /* doesn't seem to work */ gzseek(f, 128*96*3, SEEK_CUR); #else u8 *pMem = (u8 *) malloc(128*96*3); if (pMem == NULL) return -1; gzread(f, pMem, 128*96*3); free(pMem); #endif DEBUG_STATES("reading real memory"); gzread(f, psxM, 0x00200000); gzread(f, psxR, 0x00080000); gzread(f, psxH, 0x00010000); DEBUG_STATES("reading registers"); gzread(f, (void*)psxRegs, sizeof(psxRegisters)); // gpu DEBUG_STATES("allocating GPUFreeze"); gpufP = (GPUFreeze *) malloc (sizeof(GPUFreeze)); if (!gpufP) { DEBUG_STATES("out of memory"); return -1; } DEBUG_STATES("reading GPU state"); gzread(f, gpufP, sizeof(GPUFreeze)); GPU_freeze(0, gpufP); free(gpufP); // spu gzread(f, &Size, 4); DEBUG_STATES("reading SPU state at %d, size %d", gztell(f), Size); spufP = (SPUFreeze_t *) malloc (Size); gzread(f, spufP, Size); SPU_freeze(0, spufP); free(spufP); DEBUG_STATES("unfreezing stuff"); sioFreeze(f, 0); cdrFreeze(f, 0); psxHwFreeze(f, 0); psxRcntFreeze(f, 0); mdecFreeze(f, 0); DEBUG_STATES("closing state"); gzclose(f); DEBUG_STATES("ending %s", __FUNCTION__); return 0; }
s32 SaveState(s8 *file) { DEBUG_STATES("starting %s", __FUNCTION__); gzFile f; //GPUFREEZE *gpufP; GPUFreeze* gpufP; SPUFreeze_t* spufP; s32 Size; u8* pMem; s8 filePath[256]; sprintf(filePath, "%s", file); DEBUG_STATES("opening file"); f = gzopen(filePath, "wb"); if (f == NULL) return -1; DEBUG_STATES("writing header"); gzwrite(f, (void*)PsxHeader, 32); DEBUG_STATES("allocating useless memory"); pMem = (u8 *) malloc(128*96*3); if (pMem == NULL) return -1; //GPU_getScreenPic(pMem); gzwrite(f, pMem, 128*96*3); free(pMem); DEBUG_STATES("writing memory state"); gzwrite(f, psxM, 0x00200000); gzwrite(f, psxR, 0x00080000); gzwrite(f, psxH, 0x00010000); DEBUG_STATES("writing registers"); gzwrite(f, (void*)psxRegs, sizeof(psxRegisters)); // gpu DEBUG_STATES("allocating GPU memory"); gpufP = (GPUFreeze *) malloc(sizeof(GPUFreeze)); if (!gpufP) { DEBUG_STATES("out of memory"); return -1; } gpufP->Version = 1; GPU_freeze(1, gpufP); DEBUG_STATES("writing GPU memory"); gzwrite(f, gpufP, sizeof(GPUFreeze)); free(gpufP); // spu DEBUG_STATES("writing SPU"); spufP = (SPUFreeze_t *) malloc(16); SPU_freeze(2, spufP); Size = spufP->ulFreezeSize; gzwrite(f, &Size, 4); DEBUG_STATES("SPU size %d, writing at %d", Size, gztell(f)); free(spufP); spufP = (SPUFreeze_t *) malloc(Size); SPU_freeze(1, spufP); gzwrite(f, spufP, Size); free(spufP); sioFreeze(f, 1); cdrFreeze(f, 1); psxHwFreeze(f, 1); psxRcntFreeze(f, 1); mdecFreeze(f, 1); DEBUG_STATES("closing file"); gzclose(f); DEBUG_STATES("ending %s", __FUNCTION__); return 0; }