ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/libmupen64plus/mupen64plus-core/tools/savestate_convert.c

397 lines
11 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Mupen64plus - savestate_convert.c *
* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
* Copyright (C) 2008 Richard Goedeken *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <zlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* savestate file header: magic number and version number */
const char *savestate_magic = "M64+SAVE";
const int savestate_newest_version = 0x00010000; // 1.0
/* Data field lengths */
#define SIZE_REG_RDRAM 40
#define SIZE_REG_MIPS 36
#define SIZE_REG_PI 52
#define SIZE_REG_SP 52
#define SIZE_REG_RSP 8
#define SIZE_REG_SI 16
#define SIZE_REG_VI 60
#define SIZE_REG_RI 32
#define SIZE_REG_AI 40
#define SIZE_REG_DPC 48
#define SIZE_REG_DPS 16
#define SIZE_FLASHRAM_INFO 24
#define SIZE_TLB_ENTRY 52
#define SIZE_MAX_EVENTQUEUE 1024
/* Arrays and pointers for savestate data */
char rom_md5[32];
char rdram_register[SIZE_REG_RDRAM];
char mips_register[SIZE_REG_MIPS];
char pi_register[SIZE_REG_PI];
char sp_register[SIZE_REG_SP];
char rsp_register[SIZE_REG_RSP];
char si_register[SIZE_REG_SI];
char vi_register[SIZE_REG_VI];
char ri_register[SIZE_REG_RI];
char ai_register[SIZE_REG_AI];
char dpc_register[SIZE_REG_DPC];
char dps_register[SIZE_REG_DPS];
char *rdram; /* 0x800000 bytes */
char SP_DMEM[0x1000];
char SP_IMEM[0x1000];
char PIF_RAM[0x40];
char flashram[SIZE_FLASHRAM_INFO];
char *tlb_LUT_r; /* 0x400000 bytes */
char *tlb_LUT_w; /* 0x400000 bytes */
char llbit[4];
char reg[32][8];
char reg_cop0[32][4];
char lo[8];
char hi[8];
char reg_cop1_fgr_64[32][8];
char FCR0[4];
char FCR31[4];
char tlb_e[32][SIZE_TLB_ENTRY];
char PCaddr[4];
char next_interupt[4];
char next_vi[4];
char vi_field[4];
char eventqueue[SIZE_MAX_EVENTQUEUE];
/* savestate data parameters calculated from file contents */
int queuelength = 0;
/* Forward declarations for functions */
void printhelp(const char *progname);
int allocate_memory(void);
void free_memory(void);
int load_original_mupen64(const char *filename);
int save_newest(const char *filename);
/* Main Function - parse arguments, check version, load state file, overwrite state file with new one */
int main(int argc, char *argv[])
{
FILE *pfTest;
gzFile f;
char *filename;
char magictag[8];
unsigned char inbuf[4];
int (*load_function)(const char *) = NULL;
int iVersion;
/* start by parsing the command-line arguments */
if (argc != 2 || strncmp(argv[1], "-h", 2) == 0 || strncmp(argv[1], "--help", 6) == 0)
{
printhelp(argv[0]);
return 1;
}
filename = argv[1];
pfTest = fopen(filename, "rb");
if (pfTest == NULL)
{
printf("Error: cannot open savestate file '%s' for reading.\n", filename);
return 2;
}
fclose(pfTest);
/* try to determine the version of this savestate file */
f = gzopen(filename, "rb");
if (f == NULL)
{
printf("Error: state file '%s' is corrupt\n", filename);
return 3;
}
if (gzread(f, magictag, 8) != 8 || gzread(f, inbuf, 4) != 4)
{
printf("Error: state file '%s' is corrupt: end of savestate file while reading header.\n", filename);
gzclose(f);
return 4;
}
gzclose(f);
iVersion = inbuf[0];
iVersion = (iVersion << 8) | inbuf[1];
iVersion = (iVersion << 8) | inbuf[2];
iVersion = (iVersion << 8) | inbuf[3];
/* determine which type of savestate file to load, based on savestate version */
if (strncmp(magictag, savestate_magic, 8) != 0)
{
printf("Warning: old savestate file format. This is presumed to be from the original Mupen64 or Mupen64Plus version 1.4 or earlier.\n");
load_function = load_original_mupen64;
}
else if (iVersion == savestate_newest_version)
{
printf("This savestate file is already up to date (version %08x)\n", savestate_newest_version);
return 0;
}
else
{
printf("This savestate file uses an unknown version (%08x)\n", iVersion);
return 5;
}
/* allocate memory for savestate data */
if (allocate_memory() != 0)
{
printf("Error: couldn't allocate memory for savestate data storage.\n");
return 6;
}
/* load the savestate file */
if (load_function(filename) != 0)
{
free_memory();
return 7;
}
/* write new updated savestate file */
if (save_newest(filename) != 0)
{
free_memory();
return 8;
}
/* free the memory and return */
printf("Savestate file '%s' successfully converted to latest version (%08x).\n", filename, savestate_newest_version);
free_memory();
return 0;
}
void printhelp(const char *progname)
{
printf("%s - convert older Mupen64Plus savestate files to most recent version.\n\n", progname);
printf("Usage: %s [-h] [--help] <savestatepath>\n\n", progname);
printf(" -h, --help: display this message\n");
printf(" <savestatepath>: full path to savestate file which will be overwritten with latest version.\n");
}
int allocate_memory(void)
{
rdram = malloc(0x800000);
if (rdram == NULL)
return 1;
tlb_LUT_r = malloc(0x400000);
if (tlb_LUT_r == NULL)
{
free_memory();
return 2;
}
tlb_LUT_w = malloc(0x400000);
if (tlb_LUT_w == NULL)
{
free_memory();
return 3;
}
return 0;
}
void free_memory(void)
{
if (rdram != NULL)
{
free(rdram);
rdram = NULL;
}
if (tlb_LUT_r != NULL)
{
free(tlb_LUT_r);
tlb_LUT_r = NULL;
}
if (tlb_LUT_w != NULL)
{
free(tlb_LUT_w);
tlb_LUT_w = NULL;
}
}
/* State Loading Functions */
int load_original_mupen64(const char *filename)
{
char buffer[4];
int i;
gzFile f;
f = gzopen(filename, "rb");
if (f == NULL)
{
printf("Error: savestate file '%s' is corrupt.\n", filename);
return 1;
}
gzread(f, rom_md5, 32);
gzread(f, rdram_register, SIZE_REG_RDRAM);
gzread(f, mips_register, SIZE_REG_MIPS);
gzread(f, pi_register, SIZE_REG_PI);
gzread(f, sp_register, SIZE_REG_SP);
gzread(f, rsp_register, SIZE_REG_RSP);
gzread(f, si_register, SIZE_REG_SI);
gzread(f, vi_register, SIZE_REG_VI);
gzread(f, ri_register, SIZE_REG_RI);
gzread(f, ai_register, SIZE_REG_AI);
gzread(f, dpc_register, SIZE_REG_DPC);
gzread(f, dps_register, SIZE_REG_DPS);
gzread(f, rdram, 0x800000);
gzread(f, SP_DMEM, 0x1000);
gzread(f, SP_IMEM, 0x1000);
gzread(f, PIF_RAM, 0x40);
gzread(f, flashram, SIZE_FLASHRAM_INFO);
memset(tlb_LUT_r, 0, 0x400000);
memset(tlb_LUT_w, 0, 0x400000);
gzread(f, tlb_LUT_r, 0x100000);
gzread(f, tlb_LUT_w, 0x100000);
gzread(f, llbit, 4);
gzread(f, reg, 32*8);
for (i = 0; i < 32; i++)
{
gzread(f, reg_cop0[i], 4);
gzread(f, buffer, 4); /* for compatibility with older versions. */
}
gzread(f, lo, 8);
gzread(f, hi, 8);
gzread(f, reg_cop1_fgr_64[0], 32 * 8);
gzread(f, FCR0, 4);
gzread(f, FCR31, 4);
gzread(f, tlb_e[0], 32 * SIZE_TLB_ENTRY);
gzread(f, PCaddr, 4);
gzread(f, next_interupt, 4);
gzread(f, next_vi, 4);
gzread(f, vi_field, 4);
queuelength = 0;
while(queuelength < SIZE_MAX_EVENTQUEUE)
{
if (gzread(f, eventqueue + queuelength, 4) != 4)
{
printf("Error: savestate file '%s' is corrupt.\n", filename);
return 2;
}
if (*((unsigned int*) &eventqueue[queuelength]) == 0xFFFFFFFF)
{
queuelength += 4;
break;
}
gzread(f, eventqueue + queuelength + 4, 4);
queuelength += 8;
}
if (queuelength >= SIZE_MAX_EVENTQUEUE)
{
printf("Error: savestate file '%s' has event queue larger than %i bytes.\n", filename, SIZE_MAX_EVENTQUEUE);
return 3;
}
gzclose(f);
return 0;
}
/* State Saving Functions */
int save_newest(const char *filename)
{
unsigned char outbuf[4];
gzFile f;
f = gzopen(filename, "wb");
/* write magic number */
gzwrite(f, savestate_magic, 8);
/* write savestate file version in big-endian */
outbuf[0] = (savestate_newest_version >> 24) & 0xff;
outbuf[1] = (savestate_newest_version >> 16) & 0xff;
outbuf[2] = (savestate_newest_version >> 8) & 0xff;
outbuf[3] = (savestate_newest_version >> 0) & 0xff;
gzwrite(f, outbuf, 4);
gzwrite(f, rom_md5, 32);
gzwrite(f, rdram_register, SIZE_REG_RDRAM);
gzwrite(f, mips_register, SIZE_REG_MIPS);
gzwrite(f, pi_register, SIZE_REG_PI);
gzwrite(f, sp_register, SIZE_REG_SP);
gzwrite(f, rsp_register, SIZE_REG_RSP);
gzwrite(f, si_register, SIZE_REG_SI);
gzwrite(f, vi_register, SIZE_REG_VI);
gzwrite(f, ri_register, SIZE_REG_RI);
gzwrite(f, ai_register, SIZE_REG_AI);
gzwrite(f, dpc_register, SIZE_REG_DPC);
gzwrite(f, dps_register, SIZE_REG_DPS);
gzwrite(f, rdram, 0x800000);
gzwrite(f, SP_DMEM, 0x1000);
gzwrite(f, SP_IMEM, 0x1000);
gzwrite(f, PIF_RAM, 0x40);
gzwrite(f, flashram, SIZE_FLASHRAM_INFO);
gzwrite(f, tlb_LUT_r, 0x400000);
gzwrite(f, tlb_LUT_w, 0x400000);
gzwrite(f, llbit, 4);
gzwrite(f, reg[0], 32*8);
gzwrite(f, reg_cop0[0], 32*4);
gzwrite(f, lo, 8);
gzwrite(f, hi, 8);
gzwrite(f, reg_cop1_fgr_64[0], 32*8);
gzwrite(f, FCR0, 4);
gzwrite(f, FCR31, 4);
gzwrite(f, tlb_e[0], 32 * SIZE_TLB_ENTRY);
gzwrite(f, PCaddr, 4);
gzwrite(f, next_interupt, 4);
gzwrite(f, next_vi, 4);
gzwrite(f, vi_field, 4);
gzwrite(f, eventqueue, queuelength);
gzclose(f);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink