[mupen64plus-pandora.git] / source / mupen64plus-core / tools / savestate_convert.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   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;
}
Commit	Line	Data
451ab91e	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus - savestate_convert.c *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2008 Richard Goedeken *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	20	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	21
	22	#include <zlib.h>
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26
	27	/* savestate file header: magic number and version number */
	28	const char *savestate_magic = "M64+SAVE";
	29	const int savestate_newest_version = 0x00010000; // 1.0
	30
	31	/* Data field lengths */
	32
	33	#define SIZE_REG_RDRAM 40
	34	#define SIZE_REG_MIPS 36
	35	#define SIZE_REG_PI 52
	36	#define SIZE_REG_SP 52
	37	#define SIZE_REG_RSP 8
	38	#define SIZE_REG_SI 16
	39	#define SIZE_REG_VI 60
	40	#define SIZE_REG_RI 32
	41	#define SIZE_REG_AI 40
	42	#define SIZE_REG_DPC 48
	43	#define SIZE_REG_DPS 16
	44
	45	#define SIZE_FLASHRAM_INFO 24
	46	#define SIZE_TLB_ENTRY 52
	47
	48	#define SIZE_MAX_EVENTQUEUE 1024
	49
	50	/* Arrays and pointers for savestate data */
	51
	52	char rom_md5[32];
	53
	54	char rdram_register[SIZE_REG_RDRAM];
	55	char mips_register[SIZE_REG_MIPS];
	56	char pi_register[SIZE_REG_PI];
	57	char sp_register[SIZE_REG_SP];
	58	char rsp_register[SIZE_REG_RSP];
	59	char si_register[SIZE_REG_SI];
	60	char vi_register[SIZE_REG_VI];
	61	char ri_register[SIZE_REG_RI];
	62	char ai_register[SIZE_REG_AI];
	63	char dpc_register[SIZE_REG_DPC];
	64	char dps_register[SIZE_REG_DPS];
65
66	char rdram; / 0x800000 bytes */
67	char SP_DMEM[0x1000];
68	char SP_IMEM[0x1000];
69	char PIF_RAM[0x40];
70
71	char flashram[SIZE_FLASHRAM_INFO];
72
73	char tlb_LUT_r; / 0x400000 bytes */
74	char tlb_LUT_w; / 0x400000 bytes */
75
76	char llbit[4];
77	char reg[32][8];
78	char reg_cop0[32][4];
79	char lo[8];
80	char hi[8];
81	char reg_cop1_fgr_64[32][8];
82	char FCR0[4];
83	char FCR31[4];
84	char tlb_e[32][SIZE_TLB_ENTRY];
85	char PCaddr[4];
86
87	char next_interupt[4];
88	char next_vi[4];
89	char vi_field[4];
90
91	char eventqueue[SIZE_MAX_EVENTQUEUE];
92
93	/* savestate data parameters calculated from file contents */
94	int queuelength = 0;
95
96	/* Forward declarations for functions */
97	void printhelp(const char *progname);
98
99	int allocate_memory(void);
100	void free_memory(void);
101
102	int load_original_mupen64(const char *filename);
103	int save_newest(const char *filename);
104
105	/* Main Function - parse arguments, check version, load state file, overwrite state file with new one */
106	int main(int argc, char *argv[])
107	{
108	FILE *pfTest;
109	gzFile f;
110	char *filename;
111	char magictag[8];
112	unsigned char inbuf[4];
113	int (load_function)(const char ) = NULL;
114	int iVersion;
115
116	/* start by parsing the command-line arguments */
117	if (argc != 2 \|\| strncmp(argv[1], "-h", 2) == 0 \|\| strncmp(argv[1], "--help", 6) == 0)
118	{
119	printhelp(argv[0]);
120	return 1;
121	}
122	filename = argv[1];
123	pfTest = fopen(filename, "rb");
124	if (pfTest == NULL)
125	{
126	printf("Error: cannot open savestate file '%s' for reading.\n", filename);
127	return 2;
128	}
129	fclose(pfTest);
130
131	/* try to determine the version of this savestate file */
132	f = gzopen(filename, "rb");
133	if (f == NULL)
134	{
135	printf("Error: state file '%s' is corrupt\n", filename);
136	return 3;
137	}
138	if (gzread(f, magictag, 8) != 8 \|\| gzread(f, inbuf, 4) != 4)
139	{
140	printf("Error: state file '%s' is corrupt: end of savestate file while reading header.\n", filename);
141	gzclose(f);
142	return 4;
143	}
144	gzclose(f);
145	iVersion = inbuf[0];
146	iVersion = (iVersion << 8) \| inbuf[1];
147	iVersion = (iVersion << 8) \| inbuf[2];
148	iVersion = (iVersion << 8) \| inbuf[3];
149
150	/* determine which type of savestate file to load, based on savestate version */
151	if (strncmp(magictag, savestate_magic, 8) != 0)
152	{
153	printf("Warning: old savestate file format. This is presumed to be from the original Mupen64 or Mupen64Plus version 1.4 or earlier.\n");
154	load_function = load_original_mupen64;
155	}
156	else if (iVersion == savestate_newest_version)
157	{
158	printf("This savestate file is already up to date (version %08x)\n", savestate_newest_version);
159	return 0;
160	}
161	else
162	{
163	printf("This savestate file uses an unknown version (%08x)\n", iVersion);
164	return 5;
165	}
166
167	/* allocate memory for savestate data */
168	if (allocate_memory() != 0)
169	{
170	printf("Error: couldn't allocate memory for savestate data storage.\n");
171	return 6;
172	}
173
174	/* load the savestate file */
175	if (load_function(filename) != 0)
176	{
177	free_memory();
178	return 7;
179	}
180
181	/* write new updated savestate file */
182	if (save_newest(filename) != 0)
183	{
184	free_memory();
185	return 8;
186	}
187
188	/* free the memory and return */
189	printf("Savestate file '%s' successfully converted to latest version (%08x).\n", filename, savestate_newest_version);
190	free_memory();
191	return 0;
192	}
193
194	void printhelp(const char *progname)
195	{
196	printf("%s - convert older Mupen64Plus savestate files to most recent version.\n\n", progname);
197	printf("Usage: %s [-h] [--help] <savestatepath>\n\n", progname);
198	printf(" -h, --help: display this message\n");
199	printf(" <savestatepath>: full path to savestate file which will be overwritten with latest version.\n");
200	}
201
202	int allocate_memory(void)
203	{
204	rdram = malloc(0x800000);
205	if (rdram == NULL)
206	return 1;
207
208	tlb_LUT_r = malloc(0x400000);
209	if (tlb_LUT_r == NULL)
210	{
211	free_memory();
212	return 2;
213	}
214
215	tlb_LUT_w = malloc(0x400000);
216	if (tlb_LUT_w == NULL)
217	{
218	free_memory();
219	return 3;
220	}
221
222	return 0;
223	}
224
225	void free_memory(void)
226	{
227	if (rdram != NULL)
228	{
229	free(rdram);
230	rdram = NULL;
231	}
232
233	if (tlb_LUT_r != NULL)
234	{
235	free(tlb_LUT_r);
236	tlb_LUT_r = NULL;
237	}
238
239	if (tlb_LUT_w != NULL)
240	{
241	free(tlb_LUT_w);
242	tlb_LUT_w = NULL;
243	}
244	}
245
246	/* State Loading Functions */
247	int load_original_mupen64(const char *filename)
248	{
249	char buffer[4];
250	int i;
251	gzFile f;
252
253	f = gzopen(filename, "rb");
254
255	if (f == NULL)
256	{
257	printf("Error: savestate file '%s' is corrupt.\n", filename);
258	return 1;
259	}
260
261	gzread(f, rom_md5, 32);
262
263	gzread(f, rdram_register, SIZE_REG_RDRAM);
264	gzread(f, mips_register, SIZE_REG_MIPS);
265	gzread(f, pi_register, SIZE_REG_PI);
266	gzread(f, sp_register, SIZE_REG_SP);
267	gzread(f, rsp_register, SIZE_REG_RSP);
268	gzread(f, si_register, SIZE_REG_SI);
269	gzread(f, vi_register, SIZE_REG_VI);
270	gzread(f, ri_register, SIZE_REG_RI);
271	gzread(f, ai_register, SIZE_REG_AI);
272	gzread(f, dpc_register, SIZE_REG_DPC);
273	gzread(f, dps_register, SIZE_REG_DPS);
274
275	gzread(f, rdram, 0x800000);
276	gzread(f, SP_DMEM, 0x1000);
277	gzread(f, SP_IMEM, 0x1000);
278	gzread(f, PIF_RAM, 0x40);
279
280	gzread(f, flashram, SIZE_FLASHRAM_INFO);
281
282	memset(tlb_LUT_r, 0, 0x400000);
283	memset(tlb_LUT_w, 0, 0x400000);
284	gzread(f, tlb_LUT_r, 0x100000);
285	gzread(f, tlb_LUT_w, 0x100000);
286
287	gzread(f, llbit, 4);
288	gzread(f, reg, 32*8);
289	for (i = 0; i < 32; i++)
290	{
291	gzread(f, reg_cop0[i], 4);
292	gzread(f, buffer, 4); /* for compatibility with older versions. */
293	}
294	gzread(f, lo, 8);
295	gzread(f, hi, 8);
296	gzread(f, reg_cop1_fgr_64[0], 32 * 8);
297	gzread(f, FCR0, 4);
298	gzread(f, FCR31, 4);
299	gzread(f, tlb_e[0], 32 * SIZE_TLB_ENTRY);
300	gzread(f, PCaddr, 4);
301
302	gzread(f, next_interupt, 4);
303	gzread(f, next_vi, 4);
304	gzread(f, vi_field, 4);
305
306	queuelength = 0;
307	while(queuelength < SIZE_MAX_EVENTQUEUE)
308	{
309	if (gzread(f, eventqueue + queuelength, 4) != 4)
310	{
311	printf("Error: savestate file '%s' is corrupt.\n", filename);
312	return 2;
313	}
314	if (((unsigned int) &eventqueue[queuelength]) == 0xFFFFFFFF)
315	{
316	queuelength += 4;
317	break;
318	}
319	gzread(f, eventqueue + queuelength + 4, 4);
320	queuelength += 8;
321	}
322
323	if (queuelength >= SIZE_MAX_EVENTQUEUE)
324	{
325	printf("Error: savestate file '%s' has event queue larger than %i bytes.\n", filename, SIZE_MAX_EVENTQUEUE);
326	return 3;
327	}
328
329	gzclose(f);
330	return 0;
331	}
332
333	/* State Saving Functions */
334
335	int save_newest(const char *filename)
336	{
337	unsigned char outbuf[4];
338	gzFile f;
339
340	f = gzopen(filename, "wb");
341
342	/* write magic number */
343	gzwrite(f, savestate_magic, 8);
344
345	/* write savestate file version in big-endian */
346	outbuf[0] = (savestate_newest_version >> 24) & 0xff;
347	outbuf[1] = (savestate_newest_version >> 16) & 0xff;
348	outbuf[2] = (savestate_newest_version >> 8) & 0xff;
349	outbuf[3] = (savestate_newest_version >> 0) & 0xff;
350	gzwrite(f, outbuf, 4);
351
352	gzwrite(f, rom_md5, 32);
353
354	gzwrite(f, rdram_register, SIZE_REG_RDRAM);
355	gzwrite(f, mips_register, SIZE_REG_MIPS);
356	gzwrite(f, pi_register, SIZE_REG_PI);
357	gzwrite(f, sp_register, SIZE_REG_SP);
358	gzwrite(f, rsp_register, SIZE_REG_RSP);
359	gzwrite(f, si_register, SIZE_REG_SI);
360	gzwrite(f, vi_register, SIZE_REG_VI);
361	gzwrite(f, ri_register, SIZE_REG_RI);
362	gzwrite(f, ai_register, SIZE_REG_AI);
363	gzwrite(f, dpc_register, SIZE_REG_DPC);
364	gzwrite(f, dps_register, SIZE_REG_DPS);
365
366	gzwrite(f, rdram, 0x800000);
367	gzwrite(f, SP_DMEM, 0x1000);
368	gzwrite(f, SP_IMEM, 0x1000);
369	gzwrite(f, PIF_RAM, 0x40);
370
371	gzwrite(f, flashram, SIZE_FLASHRAM_INFO);
372
373	gzwrite(f, tlb_LUT_r, 0x400000);
374	gzwrite(f, tlb_LUT_w, 0x400000);
375
376	gzwrite(f, llbit, 4);
377	gzwrite(f, reg[0], 32*8);
378	gzwrite(f, reg_cop0[0], 32*4);
379	gzwrite(f, lo, 8);
380	gzwrite(f, hi, 8);
381	gzwrite(f, reg_cop1_fgr_64[0], 32*8);
382	gzwrite(f, FCR0, 4);
383	gzwrite(f, FCR31, 4);
384	gzwrite(f, tlb_e[0], 32 * SIZE_TLB_ENTRY);
385	gzwrite(f, PCaddr, 4);
386
387	gzwrite(f, next_interupt, 4);
388	gzwrite(f, next_vi, 4);
389	gzwrite(f, vi_field, 4);
390
391	gzwrite(f, eventqueue, queuelength);
392
393	gzclose(f);
394	return 0;
395	}
396