int SaveState(const 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 *)PcsxrHeader, 32);
gzwrite(f, (void *)&SaveVersion, sizeof(u32));
gzwrite(f, (void *)&Config.HLE, sizeof(boolean));
pMem = (unsigned char *)malloc(128 * 96 * 3);
if (pMem == NULL) return -1;
GPU_getScreenPic(pMem);
gzwrite(f, pMem, 128 * 96 * 3);
free(pMem);
if (Config.HLE)
psxBiosFreeze(1);
gzwrite(f, psxM, 0x00200000);
gzwrite(f, psxR, 0x00080000);
gzwrite(f, psxH, 0x00010000);
gzwrite(f, (void *)&psxRegs, sizeof(psxRegs));
// 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(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;
}
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;
#ifdef NEW_DYNAREC
new_dyna_before_save();
#endif
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);
#ifdef NEW_DYNAREC
new_dyna_freeze(f, 1);
#endif
SaveFuncs.close(f);
#ifdef NEW_DYNAREC
new_dyna_after_save();
#endif
return 0;
}
int LoadStateEmbed(char *file) {
GPUFreeze_t *gpufP;
int Size;
char header[32];
FILE* fp;
FILE* fp2;
uint8 * embSaveTmp;
size_t blockSize = Movie.memoryCard1Offset-Movie.saveStateOffset;
embSaveTmp = (uint8*)malloc(blockSize);
fp = fopen(file,"rb");
fp2 = fopen("embsave.tmp","wb");
fseek(fp, Movie.saveStateOffset, SEEK_SET);
fread(embSaveTmp, 1, blockSize, fp);
fwrite(embSaveTmp, 1, blockSize, fp2);
fclose(fp);
fclose(fp2);
EMUFILE_FILE ef("embsave.tmp", "rb");
if (ef.fail()) return -1;
EMUFILE *f = &ef;
psxCpu->Reset();
gzread(f, header, 32);
if (strncmp("STv3 PSXjin", header, 9)) { return -1; }
exceptionPatches.clear();
int tag;
gzread(f, &tag, 4);
if (tag == 'ExPs') {
gzread(f, &Size, 4);
while (Size--) {
u32 addr, val;
gzread(f, &addr, 4);
gzread(f, &val, 4);
exceptionPatches.push_back(std::make_pair(addr, val));
}
gzseek(f, 128*96*3-4-4-exceptionPatches.size()*4*2, SEEK_CUR);
}
else
gzseek(f, 128*96*3-4, SEEK_CUR);
gzread(f, psxM, 0x00200000);
gzread(f, psxP, 0x00010000);
gzread(f, psxR, 0x00080000);
gzread(f, psxH, 0x00010000);
gzread(f, (void*)&psxRegs, sizeof(psxRegs));
if (Config.HLE) //adelikat: TODO: remove all references to Config.HLE, we will not be using that BIOS, ever
psxBiosFreeze(0);
// gpu
gpufP = (GPUFreeze_t *) malloc (sizeof(GPUFreeze_t));
gzread(f, gpufP, sizeof(GPUFreeze_t));
gpufP->extraData = malloc(gpufP->extraDataSize);
gzread(f, gpufP->extraData, gpufP->extraDataSize);
GPUfreeze(0, gpufP);
free(gpufP->extraData);
free(gpufP);
sioFreeze(f, 0);
cdrFreeze(f, 0);
psxHwFreeze(f, 0);
CDRisoFreeze(f,0);
psxRcntFreeze(f, 0);
mdecFreeze(f, 0);
//TODO - no movie state? are you sure?
// spu
gzread(f, &Size, 4);
EMUFILE_MEMORY memfile;
memfile.truncate(Size);
gzread(f, memfile.buf(), Size);
bool ok = SPUunfreeze_new(&memfile);
if(!ok) return 1;
remove("embsave.tmp");
return 0;
}
int SaveStateEmbed(char *file) {
GPUFreeze_t *gpufP;
int Size;
unsigned char *pMem;
EMUFILE_FILE ef(file, "ab");
if (ef.fail()) return -1;
EMUFILE *f = &ef;
gzwrite(f, (void*)PSXjinHeader, 32);
pMem = (unsigned char *) malloc(128*96*3);
if (pMem == NULL) return -1;
//GPU_getScreenPic(pMem);
memset(pMem,0,128*96*3);
int tag = 'ExPs';
gzwrite(f, &tag, 4);
Size = exceptionPatches.size();
gzwrite(f, &Size, 4);
for (int i = 0; i < Size; i++) {
gzwrite(f, &exceptionPatches[i].first, 4);
gzwrite(f, &exceptionPatches[i].second, 4);
}
gzwrite(f, pMem, 128*96*3-4-4-Size*4*2);
free(pMem);
gzwrite(f, psxM, 0x00200000);
gzwrite(f, psxP, 0x00010000);
gzwrite(f, psxR, 0x00080000);
gzwrite(f, psxH, 0x00010000);
gzwrite(f, (void*)&psxRegs, sizeof(psxRegs));
if (Config.HLE)
psxBiosFreeze(1);
// gpu
gpufP = (GPUFreeze_t *) malloc(sizeof(GPUFreeze_t));
gpufP->ulFreezeVersion = 1;
GPUfreeze(1, gpufP);
void* temp = gpufP->extraData;
gpufP->extraData = 0;
gzwrite(f, gpufP, sizeof(GPUFreeze_t));
gzwrite(f, temp, gpufP->extraDataSize);
GPUfreeze(3, gpufP);
free(gpufP);
sioFreeze(f, 1);
cdrFreeze(f, 1);
psxHwFreeze(f, 1);
CDRisoFreeze(f,1);
psxRcntFreeze(f, 1);
mdecFreeze(f, 1);
//TODO - no movie state? are you sure?
// spu
EMUFILE_MEMORY memfile;
SPUfreeze_new(&memfile);
Size = memfile.size();
gzwrite(f, &Size, 4);
gzwrite(f, memfile.buf(),Size);
return 0;
}
int LoadStateEmufile(EMUFILE *f) {
GPUFreeze_t *gpufP;
int Size;
char header[32];
printf("loadstate---\n");
psxCpu->Reset();
gzread(f, header, 32);
if (strncmp("STv3 PSXjin", header, 9)) { return -1; }
exceptionPatches.clear();
int tag;
gzread(f, &tag, 4);
if (tag == 'ExPs') {
gzread(f, &Size, 4);
while (Size--) {
u32 addr, val;
gzread(f, &addr, 4);
gzread(f, &val, 4);
exceptionPatches.push_back(std::make_pair(addr, val));
}
gzseek(f, 128*96*3-4-4-exceptionPatches.size()*4*2, SEEK_CUR);
}
else
gzseek(f, 128*96*3-4, SEEK_CUR);
gzread(f, psxM, 0x00200000);
gzread(f, psxP, 0x00010000);
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));
gpufP->extraData = malloc(gpufP->extraDataSize);
gzread(f, gpufP->extraData, gpufP->extraDataSize);
GPUfreeze(0, gpufP);
free(gpufP->extraData);
free(gpufP);
sioFreeze(f, 0);
cdrFreeze(f, 0);
psxHwFreeze(f, 0);
CDRisoFreeze(f,0);
psxRcntFreeze(f, 0);
mdecFreeze(f, 0);
PadFreeze(f, 0);
MovieFreeze(f, 0);
// spu
gzread(f, &Size, 4);
EMUFILE_MEMORY memfile;
memfile.truncate(Size);
gzread(f, memfile.buf(), Size);
bool ok = SPUunfreeze_new(&memfile);
if(!ok) return 1;
return 0;
}
int SaveStateEmufile(EMUFILE *f) {
GPUFreeze_t *gpufP;
int Size;
unsigned char *pMem;
gzwrite(f, (void*)PSXjinHeader, 32);
pMem = (unsigned char *) malloc(128*96*3);
if (pMem == NULL) return -1;
memset(pMem,0,128*96*3);
// Ugh. We need to store this information, but in a backwards-compatible fashion. Do this
// by (ab)using the gap previously occupied by GPU_getScreenPic. The data is tagged so it
// can be detected on savestate load
int tag = 'ExPs';
gzwrite(f, &tag, 4);
Size = exceptionPatches.size();
gzwrite(f, &Size, 4);
for (int i = 0; i < Size; i++) {
gzwrite(f, &exceptionPatches[i].first, 4);
gzwrite(f, &exceptionPatches[i].second, 4);
}
gzwrite(f, pMem, 128*96*3-4-4-Size*4*2);
free(pMem);
gzwrite(f, psxM, 0x00200000);
gzwrite(f, psxP, 0x00010000);
gzwrite(f, psxR, 0x00080000);
gzwrite(f, psxH, 0x00010000);
gzwrite(f, (void*)&psxRegs, sizeof(psxRegs));
if (Config.HLE)
psxBiosFreeze(1);
// gpu
gpufP = (GPUFreeze_t *) malloc(sizeof(GPUFreeze_t));
gpufP->ulFreezeVersion = 1;
GPUfreeze(1, gpufP);
void* temp = gpufP->extraData;
gpufP->extraData = 0;
gzwrite(f, gpufP, sizeof(GPUFreeze_t));
gzwrite(f, temp, gpufP->extraDataSize);
GPUfreeze(3, gpufP);
free(gpufP);
sioFreeze(f, 1);
cdrFreeze(f, 1);
psxHwFreeze(f, 1);
CDRisoFreeze(f,1);
psxRcntFreeze(f, 1);
mdecFreeze(f, 1);
PadFreeze(f, 1);
MovieFreeze(f, 1);
EMUFILE_MEMORY memfile;
SPUfreeze_new(&memfile);
Size = memfile.size();
gzwrite(f, &Size, 4);
gzwrite(f, memfile.buf(),Size);
return 0;
}