source/mupen64plus-core/src/main/savestates.c

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  *   Mupen64plus - savestates.c                                            *
   3  *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
   4  *   Copyright (C) 2012 CasualJames                                        *
   5  *   Copyright (C) 2009 Olejl Tillin9                                      *
   6  *   Copyright (C) 2008 Richard42 Tillin9                                  *
   7  *   Copyright (C) 2002 Hacktarux                                          *
   8  *                                                                         *
   9  *   This program is free software; you can redistribute it and/or modify  *
  10  *   it under the terms of the GNU General Public License as published by  *
  11  *   the Free Software Foundation; either version 2 of the License, or     *
  12  *   (at your option) any later version.                                   *
  13  *                                                                         *
  14  *   This program is distributed in the hope that it will be useful,       *
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  17  *   GNU General Public License for more details.                          *
  18  *                                                                         *
  19  *   You should have received a copy of the GNU General Public License     *
  20  *   along with this program; if not, write to the                         *
  21  *   Free Software Foundation, Inc.,                                       *
  22  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
  23  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <SDL_thread.h>
  28
  29 #define M64P_CORE_PROTOTYPES 1
  30 #include "api/m64p_types.h"
  31 #include "api/callbacks.h"
  32 #include "api/m64p_config.h"
  33 #include "api/config.h"
  34
  35 #include "savestates.h"
  36 #include "main.h"
  37 #include "rom.h"
  38 #include "util.h"
  39 #include "workqueue.h"
  40
  41 #include "memory/memory.h"
  42 #include "memory/flashram.h"
  43 #include "memory/tlb.h"
  44 #include "r4300/macros.h"
  45 #include "r4300/r4300.h"
  46 #include "r4300/interupt.h"
  47 #include "osal/preproc.h"
  48 #include "osd/osd.h"
  49 #include "r4300/new_dynarec/new_dynarec.h"
  50
  51 #ifdef LIBMINIZIP
  52     #include <unzip.h>
  53     #include <zip.h>
  54 #else
  55     #include "main/zip/unzip.h"
  56     #include "main/zip/zip.h"
  57 #endif
  58
  59 static const char* savestate_magic = "M64+SAVE";
  60 static const int savestate_latest_version = 0x00010000;  /* 1.0 */
  61 static const unsigned char pj64_magic[4] = { 0xC8, 0xA6, 0xD8, 0x23 };
  62
  63 static savestates_job job = savestates_job_nothing;
  64 static savestates_type type = savestates_type_unknown;
  65 static char *fname = NULL;
  66
  67 static unsigned int slot = 0;
  68 static int autoinc_save_slot = 0;
  69
  70 static SDL_mutex *savestates_lock;
  71
  72 struct savestate_work {
  73     char *filepath;
  74     char *data;
  75     size_t size;
  76     struct work_struct work;
  77 };
  78
  79 /* Returns the malloc'd full path of the currently selected savestate. */
  80 static char *savestates_generate_path(savestates_type type)
  81 {
  82     if(fname != NULL) /* A specific path was given. */
  83     {
  84         return strdup(fname);
  85     }
  86     else /* Use the selected savestate slot */
  87     {
  88         char *filename;
  89         switch (type)
  90         {
  91             case savestates_type_m64p:
  92                 filename = formatstr("%s.st%d", ROM_SETTINGS.goodname, slot);
  93                 break;
  94             case savestates_type_pj64_zip:
  95                 filename = formatstr("%s.pj%d.zip", ROM_PARAMS.headername, slot);
  96                 break;
  97             case savestates_type_pj64_unc:
  98                 filename = formatstr("%s.pj%d", ROM_PARAMS.headername, slot);
  99                 break;
 100             default:
 101                 filename = NULL;
 102                 break;
 103         }
 104
 105         if (filename != NULL)
 106         {
 107             char *filepath = formatstr("%s%s", get_savestatepath(), filename);
 108             free(filename);
 109             return filepath;
 110         }
 111         else
 112             return NULL;
 113     }
 114 }
 115
 116 void savestates_select_slot(unsigned int s)
 117 {
 118     if(s>9||s==slot)
 119         return;
 120     slot = s;
 121     ConfigSetParameter(g_CoreConfig, "CurrentSaveSlot", M64TYPE_INT, &s);
 122     StateChanged(M64CORE_SAVESTATE_SLOT, slot);
 123
 124     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Selected state slot: %d", slot);
 125 }
 126
 127 /* Returns the currently selected save slot. */
 128 unsigned int savestates_get_slot(void)
 129 {
 130     return slot;
 131 }
 132
 133 /* Sets save state slot autoincrement on or off. */
 134 void savestates_set_autoinc_slot(int b)
 135 {
 136     autoinc_save_slot = b;
 137 }
 138
 139 void savestates_inc_slot(void)
 140 {
 141     if(++slot>9)
 142         slot = 0;
 143     StateChanged(M64CORE_SAVESTATE_SLOT, slot);
 144 }
 145
 146 savestates_job savestates_get_job(void)
 147 {
 148     return job;
 149 }
 150
 151 void savestates_set_job(savestates_job j, savestates_type t, const char *fn)
 152 {
 153     if (fname != NULL)
 154     {
 155         free(fname);
 156         fname = NULL;
 157     }
 158
 159     job = j;
 160     type = t;
 161     if (fn != NULL)
 162         fname = strdup(fn);
 163 }
 164
 165 static void savestates_clear_job(void)
 166 {
 167     savestates_set_job(savestates_job_nothing, savestates_type_unknown, NULL);
 168 }
 169
 170 #define GETARRAY(buff, type, count) \
 171     (to_little_endian_buffer(buff, sizeof(type),count), \
 172      buff += count*sizeof(type), \
 173      (type *)(buff-count*sizeof(type)))
 174 #define COPYARRAY(dst, buff, type, count) \
 175     memcpy(dst, GETARRAY(buff, type, count), sizeof(type)*count)
 176 #define GETDATA(buff, type) *GETARRAY(buff, type, 1)
 177
 178 #define PUTARRAY(src, buff, type, count) \
 179     memcpy(buff, src, sizeof(type)*count); \
 180     to_little_endian_buffer(buff, sizeof(type), count); \
 181     buff += count*sizeof(type);
 182
 183 #define PUTDATA(buff, type, value) \
 184     do { type x = value; PUTARRAY(&x, buff, type, 1); } while(0)
 185
 186 static int savestates_load_m64p(char *filepath)
 187 {
 188     unsigned char header[44];
 189     gzFile f;
 190     int version;
 191     int i;
 192
 193     size_t savestateSize;
 194     unsigned char *savestateData, *curr;
 195     char queue[1024];
 196
 197     SDL_LockMutex(savestates_lock);
 198
 199     f = gzopen(filepath, "rb");
 200     if(f==NULL)
 201     {
 202         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not open state file: %s", filepath);
 203         SDL_UnlockMutex(savestates_lock);
 204         return 0;
 205     }
 206
 207     /* Read and check Mupen64Plus magic number. */
 208     if (gzread(f, header, 44) != 44)
 209     {
 210         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not read header from state file %s", filepath);
 211         gzclose(f);
 212         SDL_UnlockMutex(savestates_lock);
 213         return 0;
 214     }
 215     curr = header;
 216
 217     if(strncmp((char *)curr, savestate_magic, 8)!=0)
 218     {
 219         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State file: %s is not a valid Mupen64plus savestate.", filepath);
 220         gzclose(f);
 221         SDL_UnlockMutex(savestates_lock);
 222         return 0;
 223     }
 224     curr += 8;
 225
 226     version = *curr++;
 227     version = (version << 8) | *curr++;
 228     version = (version << 8) | *curr++;
 229     version = (version << 8) | *curr++;
 230     if(version != 0x00010000)
 231     {
 232         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State version (%08x) isn't compatible. Please update Mupen64Plus.", version);
 233         gzclose(f);
 234         SDL_UnlockMutex(savestates_lock);
 235         return 0;
 236     }
 237
 238     if(memcmp((char *)curr, ROM_SETTINGS.MD5, 32))
 239     {
 240         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State ROM MD5 does not match current ROM.");
 241         gzclose(f);
 242         SDL_UnlockMutex(savestates_lock);
 243         return 0;
 244     }
 245     curr += 32;
 246
 247     /* Read the rest of the savestate */
 248     savestateSize = 16788244;
 249     savestateData = curr = (unsigned char *)malloc(savestateSize);
 250     if (savestateData == NULL)
 251     {
 252         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Insufficient memory to load state.");
 253         gzclose(f);
 254         SDL_UnlockMutex(savestates_lock);
 255         return 0;
 256     }
 257     if (gzread(f, savestateData, savestateSize) != savestateSize ||
 258         (gzread(f, queue, sizeof(queue)) % 4) != 0)
 259     {
 260         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not read Mupen64Plus savestate data from %s", filepath);
 261         free(savestateData);
 262         gzclose(f);
 263         SDL_UnlockMutex(savestates_lock);
 264         return 0;
 265     }
 266
 267     gzclose(f);
 268     SDL_UnlockMutex(savestates_lock);
 269
 270     // Parse savestate
 271     rdram_register.rdram_config = GETDATA(curr, unsigned int);
 272     rdram_register.rdram_device_id = GETDATA(curr, unsigned int);
 273     rdram_register.rdram_delay = GETDATA(curr, unsigned int);
 274     rdram_register.rdram_mode = GETDATA(curr, unsigned int);
 275     rdram_register.rdram_ref_interval = GETDATA(curr, unsigned int);
 276     rdram_register.rdram_ref_row = GETDATA(curr, unsigned int);
 277     rdram_register.rdram_ras_interval = GETDATA(curr, unsigned int);
 278     rdram_register.rdram_min_interval = GETDATA(curr, unsigned int);
 279     rdram_register.rdram_addr_select = GETDATA(curr, unsigned int);
 280     rdram_register.rdram_device_manuf = GETDATA(curr, unsigned int);
 281
 282     MI_register.w_mi_init_mode_reg = GETDATA(curr, unsigned int);
 283     MI_register.mi_init_mode_reg = GETDATA(curr, unsigned int);
 284     curr += 4; // Duplicate MI init mode flags from old implementation
 285     MI_register.mi_version_reg = GETDATA(curr, unsigned int);
 286     MI_register.mi_intr_reg = GETDATA(curr, unsigned int);
 287     MI_register.mi_intr_mask_reg = GETDATA(curr, unsigned int);
 288     MI_register.w_mi_intr_mask_reg = GETDATA(curr, unsigned int);
 289     curr += 8; // Duplicated MI intr flags and padding from old implementation
 290
 291     pi_register.pi_dram_addr_reg = GETDATA(curr, unsigned int);
 292     pi_register.pi_cart_addr_reg = GETDATA(curr, unsigned int);
 293     pi_register.pi_rd_len_reg = GETDATA(curr, unsigned int);
 294     pi_register.pi_wr_len_reg = GETDATA(curr, unsigned int);
 295     pi_register.read_pi_status_reg = GETDATA(curr, unsigned int);
 296     pi_register.pi_bsd_dom1_lat_reg = GETDATA(curr, unsigned int);
 297     pi_register.pi_bsd_dom1_pwd_reg = GETDATA(curr, unsigned int);
 298     pi_register.pi_bsd_dom1_pgs_reg = GETDATA(curr, unsigned int);
 299     pi_register.pi_bsd_dom1_rls_reg = GETDATA(curr, unsigned int);
 300     pi_register.pi_bsd_dom2_lat_reg = GETDATA(curr, unsigned int);
 301     pi_register.pi_bsd_dom2_pwd_reg = GETDATA(curr, unsigned int);
 302     pi_register.pi_bsd_dom2_pgs_reg = GETDATA(curr, unsigned int);
 303     pi_register.pi_bsd_dom2_rls_reg = GETDATA(curr, unsigned int);
 304
 305     sp_register.sp_mem_addr_reg = GETDATA(curr, unsigned int);
 306     sp_register.sp_dram_addr_reg = GETDATA(curr, unsigned int);
 307     sp_register.sp_rd_len_reg = GETDATA(curr, unsigned int);
 308     sp_register.sp_wr_len_reg = GETDATA(curr, unsigned int);
 309     sp_register.w_sp_status_reg = GETDATA(curr, unsigned int);
 310     sp_register.sp_status_reg = GETDATA(curr, unsigned int);
 311     curr += 16; // Duplicated SP flags and padding from old implementation
 312     sp_register.sp_dma_full_reg = GETDATA(curr, unsigned int);
 313     sp_register.sp_dma_busy_reg = GETDATA(curr, unsigned int);
 314     sp_register.sp_semaphore_reg = GETDATA(curr, unsigned int);
 315
 316     rsp_register.rsp_pc = GETDATA(curr, unsigned int);
 317     rsp_register.rsp_ibist = GETDATA(curr, unsigned int);
 318
 319     si_register.si_dram_addr = GETDATA(curr, unsigned int);
 320     si_register.si_pif_addr_rd64b = GETDATA(curr, unsigned int);
 321     si_register.si_pif_addr_wr64b = GETDATA(curr, unsigned int);
 322     si_register.si_stat = GETDATA(curr, unsigned int);
 323
 324     vi_register.vi_status = GETDATA(curr, unsigned int);
 325     vi_register.vi_origin = GETDATA(curr, unsigned int);
 326     vi_register.vi_width = GETDATA(curr, unsigned int);
 327     vi_register.vi_v_intr = GETDATA(curr, unsigned int);
 328     vi_register.vi_current = GETDATA(curr, unsigned int);
 329     vi_register.vi_burst = GETDATA(curr, unsigned int);
 330     vi_register.vi_v_sync = GETDATA(curr, unsigned int);
 331     vi_register.vi_h_sync = GETDATA(curr, unsigned int);
 332     vi_register.vi_leap = GETDATA(curr, unsigned int);
 333     vi_register.vi_h_start = GETDATA(curr, unsigned int);
 334     vi_register.vi_v_start = GETDATA(curr, unsigned int);
 335     vi_register.vi_v_burst = GETDATA(curr, unsigned int);
 336     vi_register.vi_x_scale = GETDATA(curr, unsigned int);
 337     vi_register.vi_y_scale = GETDATA(curr, unsigned int);
 338     vi_register.vi_delay = GETDATA(curr, unsigned int);
 339     update_vi_status(vi_register.vi_status);
 340     update_vi_width(vi_register.vi_width);
 341
 342     ri_register.ri_mode = GETDATA(curr, unsigned int);
 343     ri_register.ri_config = GETDATA(curr, unsigned int);
 344     ri_register.ri_current_load = GETDATA(curr, unsigned int);
 345     ri_register.ri_select = GETDATA(curr, unsigned int);
 346     ri_register.ri_refresh = GETDATA(curr, unsigned int);
 347     ri_register.ri_latency = GETDATA(curr, unsigned int);
 348     ri_register.ri_error = GETDATA(curr, unsigned int);
 349     ri_register.ri_werror = GETDATA(curr, unsigned int);
 350
 351     ai_register.ai_dram_addr = GETDATA(curr, unsigned int);
 352     ai_register.ai_len = GETDATA(curr, unsigned int);
 353     ai_register.ai_control = GETDATA(curr, unsigned int);
 354     ai_register.ai_status = GETDATA(curr, unsigned int);
 355     ai_register.ai_dacrate = GETDATA(curr, unsigned int);
 356     ai_register.ai_bitrate = GETDATA(curr, unsigned int);
 357     ai_register.next_delay = GETDATA(curr, unsigned int);
 358     ai_register.next_len = GETDATA(curr, unsigned int);
 359     ai_register.current_delay = GETDATA(curr, unsigned int);
 360     ai_register.current_len = GETDATA(curr, unsigned int);
 361     update_ai_dacrate(ai_register.ai_dacrate);
 362
 363     dpc_register.dpc_start = GETDATA(curr, unsigned int);
 364     dpc_register.dpc_end = GETDATA(curr, unsigned int);
 365     dpc_register.dpc_current = GETDATA(curr, unsigned int);
 366     dpc_register.w_dpc_status = GETDATA(curr, unsigned int);
 367     dpc_register.dpc_status = GETDATA(curr, unsigned int);
 368     curr += 12; // Duplicated DPC flags and padding from old implementation
 369     dpc_register.dpc_clock = GETDATA(curr, unsigned int);
 370     dpc_register.dpc_bufbusy = GETDATA(curr, unsigned int);
 371     dpc_register.dpc_pipebusy = GETDATA(curr, unsigned int);
 372     dpc_register.dpc_tmem = GETDATA(curr, unsigned int);
 373
 374     dps_register.dps_tbist = GETDATA(curr, unsigned int);
 375     dps_register.dps_test_mode = GETDATA(curr, unsigned int);
 376     dps_register.dps_buftest_addr = GETDATA(curr, unsigned int);
 377     dps_register.dps_buftest_data = GETDATA(curr, unsigned int);
 378
 379     COPYARRAY(rdram, curr, unsigned int, 0x800000/4);
 380     COPYARRAY(SP_DMEM, curr, unsigned int, 0x1000/4);
 381     COPYARRAY(SP_IMEM, curr, unsigned int, 0x1000/4);
 382     COPYARRAY(PIF_RAM, curr, unsigned char, 0x40);
 383
 384     flashram_info.use_flashram = GETDATA(curr, int);
 385     flashram_info.mode = GETDATA(curr, int);
 386     flashram_info.status = GETDATA(curr, unsigned long long);
 387     flashram_info.erase_offset = GETDATA(curr, unsigned int);
 388     flashram_info.write_pointer = GETDATA(curr, unsigned int);
 389
 390     COPYARRAY(tlb_LUT_r, curr, unsigned int, 0x100000);
 391     COPYARRAY(tlb_LUT_w, curr, unsigned int, 0x100000);
 392
 393     llbit = GETDATA(curr, unsigned int);
 394     COPYARRAY(reg, curr, long long int, 32);
 395     COPYARRAY(reg_cop0, curr, unsigned int, 32);
 396     set_fpr_pointers(Status);  // Status is reg_cop0[12]
 397     lo = GETDATA(curr, long long int);
 398     hi = GETDATA(curr, long long int);
 399     COPYARRAY(reg_cop1_fgr_64, curr, long long int, 32);
 400     if ((Status & 0x04000000) == 0)  // 32-bit FPR mode requires data shuffling because 64-bit layout is always stored in savestate file
 401         shuffle_fpr_data(0x04000000, 0);
 402     FCR0 = GETDATA(curr, int);
 403     FCR31 = GETDATA(curr, int);
 404
 405     for (i = 0; i < 32; i++)
 406     {
 407         tlb_e[i].mask = GETDATA(curr, short);
 408         curr += 2;
 409         tlb_e[i].vpn2 = GETDATA(curr, int);
 410         tlb_e[i].g = GETDATA(curr, char);
 411         tlb_e[i].asid = GETDATA(curr, unsigned char);
 412         curr += 2;
 413         tlb_e[i].pfn_even = GETDATA(curr, int);
 414         tlb_e[i].c_even = GETDATA(curr, char);
 415         tlb_e[i].d_even = GETDATA(curr, char);
 416         tlb_e[i].v_even = GETDATA(curr, char);
 417         curr++;
 418         tlb_e[i].pfn_odd = GETDATA(curr, int);
 419         tlb_e[i].c_odd = GETDATA(curr, char);
 420         tlb_e[i].d_odd = GETDATA(curr, char);
 421         tlb_e[i].v_odd = GETDATA(curr, char);
 422         tlb_e[i].r = GETDATA(curr, char);
 423
 424         tlb_e[i].start_even = GETDATA(curr, unsigned int);
 425         tlb_e[i].end_even = GETDATA(curr, unsigned int);
 426         tlb_e[i].phys_even = GETDATA(curr, unsigned int);
 427         tlb_e[i].start_odd = GETDATA(curr, unsigned int);
 428         tlb_e[i].end_odd = GETDATA(curr, unsigned int);
 429         tlb_e[i].phys_odd = GETDATA(curr, unsigned int);
 430     }
 431
 432 #ifdef NEW_DYNAREC
 433     if (r4300emu == CORE_DYNAREC) {
 434         pcaddr = GETDATA(curr, unsigned int);
 435         pending_exception = 1;
 436         invalidate_all_pages();
 437     } else {
 438         if(r4300emu != CORE_PURE_INTERPRETER)
 439         {
 440             for (i = 0; i < 0x100000; i++)
 441                 invalid_code[i] = 1;
 442         }
 443         generic_jump_to(GETDATA(curr, unsigned int)); // PC
 444     }
 445 #else
 446     if(r4300emu != CORE_PURE_INTERPRETER)
 447     {
 448         for (i = 0; i < 0x100000; i++)
 449             invalid_code[i] = 1;
 450     }
 451     generic_jump_to(GETDATA(curr, unsigned int)); // PC
 452 #endif
 453
 454     next_interupt = GETDATA(curr, unsigned int);
 455     next_vi = GETDATA(curr, unsigned int);
 456     vi_field = GETDATA(curr, unsigned int);
 457
 458     // assert(savestateData+savestateSize == curr)
 459
 460     to_little_endian_buffer(queue, 4, 256);
 461     load_eventqueue_infos(queue);
 462
 463 #ifdef NEW_DYNAREC
 464     if (r4300emu == CORE_DYNAREC)
 465         last_addr = pcaddr;
 466     else
 467         last_addr = PC->addr;
 468 #else
 469     last_addr = PC->addr;
 470 #endif
 471
 472     free(savestateData);
 473     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State loaded from: %s", namefrompath(filepath));
 474     return 1;
 475 }
 476
 477 static int savestates_load_pj64(char *filepath, void *handle,
 478                                 int (*read_func)(void *, void *, size_t))
 479 {
 480     char buffer[1024];
 481     unsigned int vi_timer, SaveRDRAMSize;
 482     int i;
 483
 484     unsigned char header[8];
 485     unsigned char RomHeader[0x40];
 486
 487     size_t savestateSize;
 488     unsigned char *savestateData, *curr;
 489
 490     /* Read and check Project64 magic number. */
 491     if (!read_func(handle, header, 8))
 492     {
 493         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not read header from Project64 savestate %s", filepath);
 494         return 0;
 495     }
 496
 497     curr = header;
 498     if (memcmp(curr, pj64_magic, 4) != 0)
 499     {
 500         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State file: %s is not a valid Project64 savestate. Unrecognized file format.", filepath);
 501         return 0;
 502     }
 503     curr += 4;
 504
 505     SaveRDRAMSize = GETDATA(curr, unsigned int);
 506
 507     /* Read the rest of the savestate into memory. */
 508     savestateSize = SaveRDRAMSize + 0x2754;
 509     savestateData = curr = (unsigned char *)malloc(savestateSize);
 510     if (savestateData == NULL)
 511     {
 512         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Insufficient memory to load state.");
 513         return 0;
 514     }
 515     if (!read_func(handle, savestateData, savestateSize))
 516     {
 517         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not read savestate data from Project64 savestate %s", filepath);
 518         free(savestateData);
 519         return 0;
 520     }
 521
 522     // check ROM header
 523     COPYARRAY(RomHeader, curr, unsigned int, 0x40/4);
 524     if(memcmp(RomHeader, rom, 0x40) != 0)
 525     {
 526         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State ROM header does not match current ROM.");
 527         free(savestateData);
 528         return 0;
 529     }
 530
 531     // vi_timer
 532     vi_timer = GETDATA(curr, unsigned int);
 533
 534     // Program Counter
 535     last_addr = GETDATA(curr, unsigned int);
 536
 537     // GPR
 538     COPYARRAY(reg, curr, long long int, 32);
 539
 540     // FPR
 541     COPYARRAY(reg_cop1_fgr_64, curr, long long int, 32);
 542
 543     // CP0
 544     COPYARRAY(reg_cop0, curr, unsigned int, 32);
 545
 546     set_fpr_pointers(Status);  // Status is reg_cop0[12]
 547     if ((Status & 0x04000000) == 0) // TODO not sure how pj64 handles this
 548         shuffle_fpr_data(0x04000000, 0);
 549
 550     // Initialze the interupts
 551     vi_timer += reg_cop0[9]; // Add current Count
 552     next_interupt = (Compare < vi_timer) ? Compare : vi_timer;
 553     next_vi = vi_timer;
 554     vi_field = 0;
 555     *((unsigned int*)&buffer[0]) = VI_INT;
 556     *((unsigned int*)&buffer[4]) = vi_timer;
 557     *((unsigned int*)&buffer[8]) = COMPARE_INT;
 558     *((unsigned int*)&buffer[12]) = Compare;
 559     *((unsigned int*)&buffer[16]) = 0xFFFFFFFF;
 560
 561     load_eventqueue_infos(buffer);
 562
 563     // FPCR
 564     FCR0 = GETDATA(curr, int);
 565     curr += 30 * 4; // FCR1...FCR30 not supported
 566     FCR31 = GETDATA(curr, int);
 567
 568     // hi / lo
 569     hi = GETDATA(curr, long long int);
 570     lo = GETDATA(curr, long long int);
 571
 572     // rdram register
 573     rdram_register.rdram_config = GETDATA(curr, unsigned int);
 574     rdram_register.rdram_device_id = GETDATA(curr, unsigned int);
 575     rdram_register.rdram_delay = GETDATA(curr, unsigned int);
 576     rdram_register.rdram_mode = GETDATA(curr, unsigned int);
 577     rdram_register.rdram_ref_interval = GETDATA(curr, unsigned int);
 578     rdram_register.rdram_ref_row = GETDATA(curr, unsigned int);
 579     rdram_register.rdram_ras_interval = GETDATA(curr, unsigned int);
 580     rdram_register.rdram_min_interval = GETDATA(curr, unsigned int);
 581     rdram_register.rdram_addr_select = GETDATA(curr, unsigned int);
 582     rdram_register.rdram_device_manuf = GETDATA(curr, unsigned int);
 583
 584     // sp_register
 585     sp_register.sp_mem_addr_reg = GETDATA(curr, unsigned int);
 586     sp_register.sp_dram_addr_reg = GETDATA(curr, unsigned int);
 587     sp_register.sp_rd_len_reg = GETDATA(curr, unsigned int);
 588     sp_register.sp_wr_len_reg = GETDATA(curr, unsigned int);
 589     sp_register.sp_status_reg = GETDATA(curr, unsigned int);
 590     sp_register.sp_dma_full_reg = GETDATA(curr, unsigned int);
 591     sp_register.sp_dma_busy_reg = GETDATA(curr, unsigned int);
 592     sp_register.sp_semaphore_reg = GETDATA(curr, unsigned int);
 593     rsp_register.rsp_pc = GETDATA(curr, unsigned int);
 594     rsp_register.rsp_ibist = GETDATA(curr, unsigned int);
 595
 596     make_w_sp_status_reg();
 597
 598     // dpc_register
 599     dpc_register.dpc_start = GETDATA(curr, unsigned int);
 600     dpc_register.dpc_end = GETDATA(curr, unsigned int);
 601     dpc_register.dpc_current = GETDATA(curr, unsigned int);
 602     dpc_register.dpc_status = GETDATA(curr, unsigned int);
 603     dpc_register.dpc_clock = GETDATA(curr, unsigned int);
 604     dpc_register.dpc_bufbusy = GETDATA(curr, unsigned int);
 605     dpc_register.dpc_pipebusy = GETDATA(curr, unsigned int);
 606     dpc_register.dpc_tmem = GETDATA(curr, unsigned int);
 607     (void)GETDATA(curr, unsigned int); // Dummy read
 608     (void)GETDATA(curr, unsigned int); // Dummy read
 609
 610     make_w_dpc_status();
 611
 612     // mi_register
 613     MI_register.mi_init_mode_reg = GETDATA(curr, unsigned int);
 614     MI_register.mi_version_reg = GETDATA(curr, unsigned int);
 615     MI_register.mi_intr_reg = GETDATA(curr, unsigned int);
 616     MI_register.mi_intr_mask_reg = GETDATA(curr, unsigned int);
 617
 618     make_w_mi_init_mode_reg();
 619     make_w_mi_intr_mask_reg();
 620
 621     // vi_register
 622     vi_register.vi_status = GETDATA(curr, unsigned int);
 623     vi_register.vi_origin = GETDATA(curr, unsigned int);
 624     vi_register.vi_width = GETDATA(curr, unsigned int);
 625     vi_register.vi_v_intr = GETDATA(curr, unsigned int);
 626     vi_register.vi_current = GETDATA(curr, unsigned int);
 627     vi_register.vi_burst = GETDATA(curr, unsigned int);
 628     vi_register.vi_v_sync = GETDATA(curr, unsigned int);
 629     vi_register.vi_h_sync = GETDATA(curr, unsigned int);
 630     vi_register.vi_leap = GETDATA(curr, unsigned int);
 631     vi_register.vi_h_start = GETDATA(curr, unsigned int);
 632     vi_register.vi_v_start = GETDATA(curr, unsigned int);
 633     vi_register.vi_v_burst = GETDATA(curr, unsigned int);
 634     vi_register.vi_x_scale = GETDATA(curr, unsigned int);
 635     vi_register.vi_y_scale = GETDATA(curr, unsigned int);
 636     // TODO vi delay?
 637     update_vi_status(vi_register.vi_status);
 638     update_vi_width(vi_register.vi_width);
 639
 640     // ai_register
 641     ai_register.ai_dram_addr = GETDATA(curr, unsigned int);
 642     ai_register.ai_len = GETDATA(curr, unsigned int);
 643     ai_register.ai_control = GETDATA(curr, unsigned int);
 644     ai_register.ai_status = GETDATA(curr, unsigned int);
 645     ai_register.ai_dacrate = GETDATA(curr, unsigned int);
 646     ai_register.ai_bitrate = GETDATA(curr, unsigned int);
 647     update_ai_dacrate(ai_register.ai_dacrate);
 648
 649     // pi_register
 650     pi_register.pi_dram_addr_reg = GETDATA(curr, unsigned int);
 651     pi_register.pi_cart_addr_reg = GETDATA(curr, unsigned int);
 652     pi_register.pi_rd_len_reg = GETDATA(curr, unsigned int);
 653     pi_register.pi_wr_len_reg = GETDATA(curr, unsigned int);
 654     pi_register.read_pi_status_reg = GETDATA(curr, unsigned int);
 655     pi_register.pi_bsd_dom1_lat_reg = GETDATA(curr, unsigned int);
 656     pi_register.pi_bsd_dom1_pwd_reg = GETDATA(curr, unsigned int);
 657     pi_register.pi_bsd_dom1_pgs_reg = GETDATA(curr, unsigned int);
 658     pi_register.pi_bsd_dom1_rls_reg = GETDATA(curr, unsigned int);
 659     pi_register.pi_bsd_dom2_lat_reg = GETDATA(curr, unsigned int);
 660     pi_register.pi_bsd_dom2_pwd_reg = GETDATA(curr, unsigned int);
 661     pi_register.pi_bsd_dom2_pgs_reg = GETDATA(curr, unsigned int);
 662     pi_register.pi_bsd_dom2_rls_reg = GETDATA(curr, unsigned int);
 663     read_func(handle, &pi_register, sizeof(PI_register));
 664
 665     // ri_register
 666     ri_register.ri_mode = GETDATA(curr, unsigned int);
 667     ri_register.ri_config = GETDATA(curr, unsigned int);
 668     ri_register.ri_current_load = GETDATA(curr, unsigned int);
 669     ri_register.ri_select = GETDATA(curr, unsigned int);
 670     ri_register.ri_refresh = GETDATA(curr, unsigned int);
 671     ri_register.ri_latency = GETDATA(curr, unsigned int);
 672     ri_register.ri_error = GETDATA(curr, unsigned int);
 673     ri_register.ri_werror = GETDATA(curr, unsigned int);
 674
 675     // si_register
 676     si_register.si_dram_addr = GETDATA(curr, unsigned int);
 677     si_register.si_pif_addr_rd64b = GETDATA(curr, unsigned int);
 678     si_register.si_pif_addr_wr64b = GETDATA(curr, unsigned int);
 679     si_register.si_stat = GETDATA(curr, unsigned int);
 680
 681     // tlb
 682     memset(tlb_LUT_r, 0, 0x400000);
 683     memset(tlb_LUT_w, 0, 0x400000);
 684     for (i=0; i < 32; i++)
 685     {
 686         unsigned int MyPageMask, MyEntryHi, MyEntryLo0, MyEntryLo1;
 687
 688         (void)GETDATA(curr, unsigned int); // Dummy read - EntryDefined
 689         MyPageMask = GETDATA(curr, unsigned int);
 690         MyEntryHi = GETDATA(curr, unsigned int);
 691         MyEntryLo0 = GETDATA(curr, unsigned int);
 692         MyEntryLo1 = GETDATA(curr, unsigned int);
 693
 694         // This is copied from TLBWI instruction
 695         tlb_e[i].g = (MyEntryLo0 & MyEntryLo1 & 1);
 696         tlb_e[i].pfn_even = (MyEntryLo0 & 0x3FFFFFC0) >> 6;
 697         tlb_e[i].pfn_odd = (MyEntryLo1 & 0x3FFFFFC0) >> 6;
 698         tlb_e[i].c_even = (MyEntryLo0 & 0x38) >> 3;
 699         tlb_e[i].c_odd = (MyEntryLo1 & 0x38) >> 3;
 700         tlb_e[i].d_even = (MyEntryLo0 & 0x4) >> 2;
 701         tlb_e[i].d_odd = (MyEntryLo1 & 0x4) >> 2;
 702         tlb_e[i].v_even = (MyEntryLo0 & 0x2) >> 1;
 703         tlb_e[i].v_odd = (MyEntryLo1 & 0x2) >> 1;
 704         tlb_e[i].asid = (MyEntryHi & 0xFF);
 705         tlb_e[i].vpn2 = (MyEntryHi & 0xFFFFE000) >> 13;
 706         //tlb_e[i].r = (MyEntryHi & 0xC000000000000000LL) >> 62;
 707         tlb_e[i].mask = (MyPageMask & 0x1FFE000) >> 13;
 708
 709         tlb_e[i].start_even = tlb_e[i].vpn2 << 13;
 710         tlb_e[i].end_even = tlb_e[i].start_even+
 711           (tlb_e[i].mask << 12) + 0xFFF;
 712         tlb_e[i].phys_even = tlb_e[i].pfn_even << 12;
 713
 714         tlb_e[i].start_odd = tlb_e[i].end_even+1;
 715         tlb_e[i].end_odd = tlb_e[i].start_odd+
 716           (tlb_e[i].mask << 12) + 0xFFF;
 717         tlb_e[i].phys_odd = tlb_e[i].pfn_odd << 12;
 718
 719         tlb_map(&tlb_e[i]);
 720     }
 721
 722     // pif ram
 723     COPYARRAY(PIF_RAM, curr, unsigned char, 0x40);
 724
 725     // RDRAM
 726     memset(rdram, 0, 0x800000);
 727     COPYARRAY(rdram, curr, unsigned int, SaveRDRAMSize/4);
 728
 729     // DMEM
 730     COPYARRAY(SP_DMEM, curr, unsigned int, 0x1000/4);
 731
 732     // IMEM
 733     COPYARRAY(SP_IMEM, curr, unsigned int, 0x1000/4);
 734
 735     // The following values should not matter because we don't have any AI interrupt
 736     // ai_register.next_delay = 0; ai_register.next_len = 0;
 737     // ai_register.current_delay = 0; ai_register.current_len = 0;
 738
 739     // The following is not available in PJ64 savestate. Keep the values as is.
 740     // dps_register.dps_tbist = 0; dps_register.dps_test_mode = 0;
 741     // dps_register.dps_buftest_addr = 0; dps_register.dps_buftest_data = 0; llbit = 0;
 742
 743     // No flashram info in pj64 savestate.
 744     init_flashram();
 745
 746 #ifdef NEW_DYNAREC
 747     if (r4300emu == CORE_DYNAREC) {
 748         pcaddr = GETDATA(curr, unsigned int);
 749         pending_exception = 1;
 750         invalidate_all_pages();
 751     } else {
 752         if(r4300emu != CORE_PURE_INTERPRETER)
 753         {
 754             for (i = 0; i < 0x100000; i++)
 755                 invalid_code[i] = 1;
 756         }
 757         generic_jump_to(last_addr);
 758     }
 759 #else
 760     if(r4300emu != CORE_PURE_INTERPRETER)
 761     {
 762         for (i = 0; i < 0x100000; i++)
 763             invalid_code[i] = 1;
 764     }
 765     generic_jump_to(last_addr);
 766 #endif
 767
 768     // assert(savestateData+savestateSize == curr)
 769
 770     free(savestateData);
 771     return 1;
 772 }
 773
 774 static int read_data_from_zip(void *zip, void *buffer, size_t length)
 775 {
 776     return unzReadCurrentFile((unzFile)zip, buffer, (unsigned)length) == length;
 777 }
 778
 779 static int savestates_load_pj64_zip(char *filepath)
 780 {
 781     char szFileName[256], szExtraField[256], szComment[256];
 782     unzFile zipstatefile = NULL;
 783     unz_file_info fileinfo;
 784     int ret = 0;
 785
 786     /* Open the .zip file. */
 787     zipstatefile = unzOpen(filepath);
 788     if (zipstatefile == NULL ||
 789         unzGoToFirstFile(zipstatefile) != UNZ_OK ||
 790         unzGetCurrentFileInfo(zipstatefile, &fileinfo, szFileName, 255, szExtraField, 255, szComment, 255) != UNZ_OK ||
 791         unzOpenCurrentFile(zipstatefile) != UNZ_OK)
 792     {
 793         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Zip error. Could not open state file: %s", filepath);
 794         goto clean_and_exit;
 795     }
 796
 797     if (!savestates_load_pj64(filepath, zipstatefile, read_data_from_zip))
 798         goto clean_and_exit;
 799
 800     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State loaded from: %s", namefrompath(filepath));
 801     ret = 1;
 802
 803     clean_and_exit:
 804         if (zipstatefile != NULL)
 805             unzClose(zipstatefile);
 806         return ret;
 807 }
 808
 809 static int read_data_from_file(void *file, void *buffer, size_t length)
 810 {
 811     return fread(buffer, 1, length, file) == length;
 812 }
 813
 814 static int savestates_load_pj64_unc(char *filepath)
 815 {
 816     FILE *f;
 817
 818     /* Open the file. */
 819     f = fopen(filepath, "rb");
 820     if (f == NULL)
 821     {
 822         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not open state file: %s", filepath);
 823         return 0;
 824     }
 825
 826     if (!savestates_load_pj64(filepath, f, read_data_from_file))
 827     {
 828         fclose(f);
 829         return 0;
 830     }
 831
 832     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "State loaded from: %s", namefrompath(filepath));
 833     fclose(f);
 834     return 1;
 835 }
 836
 837 static savestates_type savestates_detect_type(char *filepath)
 838 {
 839     unsigned char magic[4];
 840     FILE *f = fopen(filepath, "rb");
 841     if (f == NULL)
 842     {
 843         DebugMessage(M64MSG_STATUS, "Could not open state file %s\n", filepath);
 844         return savestates_type_unknown;
 845     }
 846
 847     if (fread(magic, 1, 4, f) != 4)
 848     {
 849         fclose(f);
 850         DebugMessage(M64MSG_STATUS, "Could not read from state file %s\n", filepath);
 851         return savestates_type_unknown;
 852     }
 853
 854     fclose(f);
 855
 856     if (magic[0] == 0x1f && magic[1] == 0x8b) // GZIP header
 857         return savestates_type_m64p;
 858     else if (memcmp(magic, "PK\x03\x04", 4) == 0) // ZIP header
 859         return savestates_type_pj64_zip;
 860     else if (memcmp(magic, pj64_magic, 4) == 0) // PJ64 header
 861         return savestates_type_pj64_unc;
 862     else
 863     {
 864         DebugMessage(M64MSG_STATUS, "Unknown state file type %s\n", filepath);
 865         return savestates_type_unknown;
 866     }
 867 }
 868
 869 int savestates_load(void)
 870 {
 871     FILE *fPtr = NULL;
 872     char *filepath = NULL;
 873     int ret = 0;
 874
 875     if (fname == NULL) // For slots, autodetect the savestate type
 876     {
 877         // try M64P type first
 878         type = savestates_type_m64p;
 879         filepath = savestates_generate_path(type);
 880         fPtr = fopen(filepath, "rb"); // can I open this?
 881         if (fPtr == NULL)
 882         {
 883             free(filepath);
 884             // try PJ64 zipped type second
 885             type = savestates_type_pj64_zip;
 886             filepath = savestates_generate_path(type);
 887             fPtr = fopen(filepath, "rb"); // can I open this?
 888             if (fPtr == NULL)
 889             {
 890                 free(filepath);
 891                 // finally, try PJ64 uncompressed
 892                 type = savestates_type_pj64_unc;
 893                 filepath = savestates_generate_path(type);
 894                 fPtr = fopen(filepath, "rb"); // can I open this?
 895                 if (fPtr == NULL)
 896                 {
 897                     free(filepath);
 898                     filepath = NULL;
 899                     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "No Mupen64Plus/PJ64 state file found for slot %i", slot);
 900                     type = savestates_type_unknown;
 901                 }
 902             }
 903         }
 904     }
 905     else // filename of state file to load was set explicitly in 'fname'
 906     {
 907         // detect type if unknown
 908         if (type == savestates_type_unknown)
 909         {
 910             type = savestates_detect_type(fname);
 911         }
 912         filepath = savestates_generate_path(type);
 913         if (filepath != NULL)
 914             fPtr = fopen(filepath, "rb"); // can I open this?
 915         if (fPtr == NULL)
 916         {
 917             if (filepath != NULL)
 918                 free(filepath);
 919             filepath = NULL;
 920             main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Failed to open savestate file %s", filepath);
 921         }
 922     }
 923     if (fPtr != NULL)
 924         fclose(fPtr);
 925
 926     if (filepath != NULL)
 927     {
 928         switch (type)
 929         {
 930             case savestates_type_m64p: ret = savestates_load_m64p(filepath); break;
 931             case savestates_type_pj64_zip: ret = savestates_load_pj64_zip(filepath); break;
 932             case savestates_type_pj64_unc: ret = savestates_load_pj64_unc(filepath); break;
 933             default: ret = 0; break;
 934         }
 935         free(filepath);
 936         filepath = NULL;
 937     }
 938
 939     // deliver callback to indicate completion of state loading operation
 940     StateChanged(M64CORE_STATE_LOADCOMPLETE, ret);
 941
 942     savestates_clear_job();
 943
 944     return ret;
 945 }
 946
 947 static void savestates_save_m64p_work(struct work_struct *work)
 948 {
 949     gzFile f;
 950     struct savestate_work *save = container_of(work, struct savestate_work, work);
 951
 952     SDL_LockMutex(savestates_lock);
 953
 954     // Write the state to a GZIP file
 955     f = gzopen(save->filepath, "wb");
 956
 957     if (f==NULL)
 958     {
 959         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not open state file: %s", save->filepath);
 960         free(save->data);
 961         return;
 962     }
 963
 964     if (gzwrite(f, save->data, save->size) != save->size)
 965     {
 966         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not write data to state file: %s", save->filepath);
 967         gzclose(f);
 968         free(save->data);
 969         return;
 970     }
 971
 972     gzclose(f);
 973     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Saved state to: %s", namefrompath(save->filepath));
 974     free(save->data);
 975     free(save->filepath);
 976     free(save);
 977
 978     SDL_UnlockMutex(savestates_lock);
 979 }
 980
 981 static int savestates_save_m64p(char *filepath)
 982 {
 983     unsigned char outbuf[4];
 984     int i;
 985
 986     char queue[1024];
 987     int queuelength;
 988
 989     struct savestate_work *save;
 990     char *curr;
 991
 992     save = malloc(sizeof(*save));
 993     if (!save) {
 994         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Insufficient memory to save state.");
 995         return 0;
 996     }
 997
 998     save->filepath = strdup(filepath);
 999
1000     if(autoinc_save_slot)
1001         savestates_inc_slot();
1002
1003     queuelength = save_eventqueue_infos(queue);
1004
1005     // Allocate memory for the save state data
1006     save->size = 16788288 + queuelength;
1007     save->data = curr = malloc(save->size);
1008     if (save->data == NULL)
1009     {
1010         free(save->filepath);
1011         free(save);
1012         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Insufficient memory to save state.");
1013         return 0;
1014     }
1015
1016     // Write the save state data to memory
1017     PUTARRAY(savestate_magic, curr, unsigned char, 8);
1018
1019     outbuf[0] = (savestate_latest_version >> 24) & 0xff;
1020     outbuf[1] = (savestate_latest_version >> 16) & 0xff;
1021     outbuf[2] = (savestate_latest_version >>  8) & 0xff;
1022     outbuf[3] = (savestate_latest_version >>  0) & 0xff;
1023     PUTARRAY(outbuf, curr, unsigned char, 4);
1024
1025     PUTARRAY(ROM_SETTINGS.MD5, curr, char, 32);
1026
1027     PUTDATA(curr, unsigned int, rdram_register.rdram_config);
1028     PUTDATA(curr, unsigned int, rdram_register.rdram_device_id);
1029     PUTDATA(curr, unsigned int, rdram_register.rdram_delay);
1030     PUTDATA(curr, unsigned int, rdram_register.rdram_mode);
1031     PUTDATA(curr, unsigned int, rdram_register.rdram_ref_interval);
1032     PUTDATA(curr, unsigned int, rdram_register.rdram_ref_row);
1033     PUTDATA(curr, unsigned int, rdram_register.rdram_ras_interval);
1034     PUTDATA(curr, unsigned int, rdram_register.rdram_min_interval);
1035     PUTDATA(curr, unsigned int, rdram_register.rdram_addr_select);
1036     PUTDATA(curr, unsigned int, rdram_register.rdram_device_manuf);
1037
1038     PUTDATA(curr, unsigned int, MI_register.w_mi_init_mode_reg);
1039     PUTDATA(curr, unsigned int, MI_register.mi_init_mode_reg);
1040     PUTDATA(curr, unsigned char, MI_register.mi_init_mode_reg & 0x7F);
1041     PUTDATA(curr, unsigned char, (MI_register.mi_init_mode_reg & 0x80) != 0);
1042     PUTDATA(curr, unsigned char, (MI_register.mi_init_mode_reg & 0x100) != 0);
1043     PUTDATA(curr, unsigned char, (MI_register.mi_init_mode_reg & 0x200) != 0);
1044     PUTDATA(curr, unsigned int, MI_register.mi_version_reg);
1045     PUTDATA(curr, unsigned int, MI_register.mi_intr_reg);
1046     PUTDATA(curr, unsigned int, MI_register.mi_intr_mask_reg);
1047     PUTDATA(curr, unsigned int, MI_register.w_mi_intr_mask_reg);
1048     PUTDATA(curr, unsigned char, (MI_register.mi_intr_mask_reg & 0x1) != 0);
1049     PUTDATA(curr, unsigned char, (MI_register.mi_intr_mask_reg & 0x2) != 0);
1050     PUTDATA(curr, unsigned char, (MI_register.mi_intr_mask_reg & 0x4) != 0);
1051     PUTDATA(curr, unsigned char, (MI_register.mi_intr_mask_reg & 0x8) != 0);
1052     PUTDATA(curr, unsigned char, (MI_register.mi_intr_mask_reg & 0x10) != 0);
1053     PUTDATA(curr, unsigned char, (MI_register.mi_intr_mask_reg & 0x20) != 0);
1054     PUTDATA(curr, unsigned short, 0); // Padding from old implementation
1055
1056     PUTDATA(curr, unsigned int, pi_register.pi_dram_addr_reg);
1057     PUTDATA(curr, unsigned int, pi_register.pi_cart_addr_reg);
1058     PUTDATA(curr, unsigned int, pi_register.pi_rd_len_reg);
1059     PUTDATA(curr, unsigned int, pi_register.pi_wr_len_reg);
1060     PUTDATA(curr, unsigned int, pi_register.read_pi_status_reg);
1061     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_lat_reg);
1062     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_pwd_reg);
1063     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_pgs_reg);
1064     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_rls_reg);
1065     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_lat_reg);
1066     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_pwd_reg);
1067     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_pgs_reg);
1068     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_rls_reg);
1069
1070     PUTDATA(curr, unsigned int, sp_register.sp_mem_addr_reg);
1071     PUTDATA(curr, unsigned int, sp_register.sp_dram_addr_reg);
1072     PUTDATA(curr, unsigned int, sp_register.sp_rd_len_reg);
1073     PUTDATA(curr, unsigned int, sp_register.sp_wr_len_reg);
1074     PUTDATA(curr, unsigned int, sp_register.w_sp_status_reg);
1075     PUTDATA(curr, unsigned int, sp_register.sp_status_reg);
1076     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x1) != 0);
1077     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x2) != 0);
1078     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x4) != 0);
1079     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x8) != 0);
1080     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x10) != 0);
1081     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x20) != 0);
1082     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x40) != 0);
1083     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x80) != 0);
1084     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x100) != 0);
1085     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x200) != 0);
1086     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x400) != 0);
1087     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x800) != 0);
1088     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x1000) != 0);
1089     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x2000) != 0);
1090     PUTDATA(curr, unsigned char, (sp_register.sp_status_reg & 0x4000) != 0);
1091     PUTDATA(curr, unsigned char, 0);
1092     PUTDATA(curr, unsigned int, sp_register.sp_dma_full_reg);
1093     PUTDATA(curr, unsigned int, sp_register.sp_dma_busy_reg);
1094     PUTDATA(curr, unsigned int, sp_register.sp_semaphore_reg);
1095
1096     PUTDATA(curr, unsigned int, rsp_register.rsp_pc);
1097     PUTDATA(curr, unsigned int, rsp_register.rsp_ibist);
1098
1099     PUTDATA(curr, unsigned int, si_register.si_dram_addr);
1100     PUTDATA(curr, unsigned int, si_register.si_pif_addr_rd64b);
1101     PUTDATA(curr, unsigned int, si_register.si_pif_addr_wr64b);
1102     PUTDATA(curr, unsigned int, si_register.si_stat);
1103
1104     PUTDATA(curr, unsigned int, vi_register.vi_status);
1105     PUTDATA(curr, unsigned int, vi_register.vi_origin);
1106     PUTDATA(curr, unsigned int, vi_register.vi_width);
1107     PUTDATA(curr, unsigned int, vi_register.vi_v_intr);
1108     PUTDATA(curr, unsigned int, vi_register.vi_current);
1109     PUTDATA(curr, unsigned int, vi_register.vi_burst);
1110     PUTDATA(curr, unsigned int, vi_register.vi_v_sync);
1111     PUTDATA(curr, unsigned int, vi_register.vi_h_sync);
1112     PUTDATA(curr, unsigned int, vi_register.vi_leap);
1113     PUTDATA(curr, unsigned int, vi_register.vi_h_start);
1114     PUTDATA(curr, unsigned int, vi_register.vi_v_start);
1115     PUTDATA(curr, unsigned int, vi_register.vi_v_burst);
1116     PUTDATA(curr, unsigned int, vi_register.vi_x_scale);
1117     PUTDATA(curr, unsigned int, vi_register.vi_y_scale);
1118     PUTDATA(curr, unsigned int, vi_register.vi_delay);
1119
1120     PUTDATA(curr, unsigned int, ri_register.ri_mode);
1121     PUTDATA(curr, unsigned int, ri_register.ri_config);
1122     PUTDATA(curr, unsigned int, ri_register.ri_current_load);
1123     PUTDATA(curr, unsigned int, ri_register.ri_select);
1124     PUTDATA(curr, unsigned int, ri_register.ri_refresh);
1125     PUTDATA(curr, unsigned int, ri_register.ri_latency);
1126     PUTDATA(curr, unsigned int, ri_register.ri_error);
1127     PUTDATA(curr, unsigned int, ri_register.ri_werror);
1128
1129     PUTDATA(curr, unsigned int, ai_register.ai_dram_addr);
1130     PUTDATA(curr, unsigned int, ai_register.ai_len);
1131     PUTDATA(curr, unsigned int, ai_register.ai_control);
1132     PUTDATA(curr, unsigned int, ai_register.ai_status);
1133     PUTDATA(curr, unsigned int, ai_register.ai_dacrate);
1134     PUTDATA(curr, unsigned int, ai_register.ai_bitrate);
1135     PUTDATA(curr, unsigned int, ai_register.next_delay);
1136     PUTDATA(curr, unsigned int, ai_register.next_len);
1137     PUTDATA(curr, unsigned int, ai_register.current_delay);
1138     PUTDATA(curr, unsigned int, ai_register.current_len);
1139
1140     PUTDATA(curr, unsigned int, dpc_register.dpc_start);
1141     PUTDATA(curr, unsigned int, dpc_register.dpc_end);
1142     PUTDATA(curr, unsigned int, dpc_register.dpc_current);
1143     PUTDATA(curr, unsigned int, dpc_register.w_dpc_status);
1144     PUTDATA(curr, unsigned int, dpc_register.dpc_status);
1145     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x1) != 0);
1146     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x2) != 0);
1147     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x4) != 0);
1148     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x8) != 0);
1149     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x10) != 0);
1150     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x20) != 0);
1151     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x40) != 0);
1152     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x80) != 0);
1153     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x100) != 0);
1154     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x200) != 0);
1155     PUTDATA(curr, unsigned char, (dpc_register.dpc_status & 0x400) != 0);
1156     PUTDATA(curr, unsigned char, 0);
1157     PUTDATA(curr, unsigned int, dpc_register.dpc_clock);
1158     PUTDATA(curr, unsigned int, dpc_register.dpc_bufbusy);
1159     PUTDATA(curr, unsigned int, dpc_register.dpc_pipebusy);
1160     PUTDATA(curr, unsigned int, dpc_register.dpc_tmem);
1161
1162     PUTDATA(curr, unsigned int, dps_register.dps_tbist);
1163     PUTDATA(curr, unsigned int, dps_register.dps_test_mode);
1164     PUTDATA(curr, unsigned int, dps_register.dps_buftest_addr);
1165     PUTDATA(curr, unsigned int, dps_register.dps_buftest_data);
1166
1167     PUTARRAY(rdram, curr, unsigned int, 0x800000/4);
1168     PUTARRAY(SP_DMEM, curr, unsigned int, 0x1000/4);
1169     PUTARRAY(SP_IMEM, curr, unsigned int, 0x1000/4);
1170     PUTARRAY(PIF_RAM, curr, unsigned char, 0x40);
1171
1172     PUTDATA(curr, int, flashram_info.use_flashram);
1173     PUTDATA(curr, int, flashram_info.mode);
1174     PUTDATA(curr, unsigned long long, flashram_info.status);
1175     PUTDATA(curr, unsigned int, flashram_info.erase_offset);
1176     PUTDATA(curr, unsigned int, flashram_info.write_pointer);
1177
1178     PUTARRAY(tlb_LUT_r, curr, unsigned int, 0x100000);
1179     PUTARRAY(tlb_LUT_w, curr, unsigned int, 0x100000);
1180
1181     PUTDATA(curr, unsigned int, llbit);
1182     PUTARRAY(reg, curr, long long int, 32);
1183     PUTARRAY(reg_cop0, curr, unsigned int, 32);
1184     PUTDATA(curr, long long int, lo);
1185     PUTDATA(curr, long long int, hi);
1186
1187     if ((Status & 0x04000000) == 0) // FR bit == 0 means 32-bit (MIPS I) FGR mode
1188         shuffle_fpr_data(0, 0x04000000);  // shuffle data into 64-bit register format for storage
1189     PUTARRAY(reg_cop1_fgr_64, curr, long long int, 32);
1190     if ((Status & 0x04000000) == 0)
1191         shuffle_fpr_data(0x04000000, 0);  // put it back in 32-bit mode
1192
1193     PUTDATA(curr, int, FCR0);
1194     PUTDATA(curr, int, FCR31);
1195     for (i = 0; i < 32; i++)
1196     {
1197         PUTDATA(curr, short, tlb_e[i].mask);
1198         PUTDATA(curr, short, 0);
1199         PUTDATA(curr, int, tlb_e[i].vpn2);
1200         PUTDATA(curr, char, tlb_e[i].g);
1201         PUTDATA(curr, unsigned char, tlb_e[i].asid);
1202         PUTDATA(curr, short, 0);
1203         PUTDATA(curr, int, tlb_e[i].pfn_even);
1204         PUTDATA(curr, char, tlb_e[i].c_even);
1205         PUTDATA(curr, char, tlb_e[i].d_even);
1206         PUTDATA(curr, char, tlb_e[i].v_even);
1207         PUTDATA(curr, char, 0);
1208         PUTDATA(curr, int, tlb_e[i].pfn_odd);
1209         PUTDATA(curr, char, tlb_e[i].c_odd);
1210         PUTDATA(curr, char, tlb_e[i].d_odd);
1211         PUTDATA(curr, char, tlb_e[i].v_odd);
1212         PUTDATA(curr, char, tlb_e[i].r);
1213
1214         PUTDATA(curr, unsigned int, tlb_e[i].start_even);
1215         PUTDATA(curr, unsigned int, tlb_e[i].end_even);
1216         PUTDATA(curr, unsigned int, tlb_e[i].phys_even);
1217         PUTDATA(curr, unsigned int, tlb_e[i].start_odd);
1218         PUTDATA(curr, unsigned int, tlb_e[i].end_odd);
1219         PUTDATA(curr, unsigned int, tlb_e[i].phys_odd);
1220     }
1221 #ifdef NEW_DYNAREC
1222     if (r4300emu == CORE_DYNAREC)
1223         PUTDATA(curr, unsigned int, pcaddr);
1224     else
1225         PUTDATA(curr, unsigned int, PC->addr);
1226 #else
1227     PUTDATA(curr, unsigned int, PC->addr);
1228 #endif
1229
1230     PUTDATA(curr, unsigned int, next_interupt);
1231     PUTDATA(curr, unsigned int, next_vi);
1232     PUTDATA(curr, unsigned int, vi_field);
1233
1234     to_little_endian_buffer(queue, 4, queuelength/4);
1235     PUTARRAY(queue, curr, char, queuelength);
1236
1237     // assert(curr == save->data + save->size)
1238
1239     init_work(&save->work, savestates_save_m64p_work);
1240     queue_work(&save->work);
1241
1242     return 1;
1243 }
1244
1245 static int savestates_save_pj64(char *filepath, void *handle,
1246                                 int (*write_func)(void *, const void *, size_t))
1247 {
1248     unsigned int i;
1249     unsigned int SaveRDRAMSize = 0x800000;
1250
1251     size_t savestateSize;
1252     unsigned char *savestateData, *curr;
1253
1254     // Allocate memory for the save state data
1255     savestateSize = 8 + SaveRDRAMSize + 0x2754;
1256     savestateData = curr = (unsigned char *)malloc(savestateSize);
1257     if (savestateData == NULL)
1258     {
1259         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Insufficient memory to save state.");
1260         return 0;
1261     }
1262
1263     // Write the save state data in memory
1264     PUTARRAY(pj64_magic, curr, unsigned char, 4);
1265     PUTDATA(curr, unsigned int, SaveRDRAMSize);
1266     PUTARRAY(rom, curr, unsigned int, 0x40/4);
1267     PUTDATA(curr, unsigned int, get_event(VI_INT) - reg_cop0[9]); // vi_timer
1268 #ifdef NEW_DYNAREC
1269     if (r4300emu == CORE_DYNAREC)
1270         PUTDATA(curr, unsigned int, pcaddr);
1271     else
1272         PUTDATA(curr, unsigned int, PC->addr);
1273 #else
1274     PUTDATA(curr, unsigned int, PC->addr);
1275 #endif
1276     PUTARRAY(reg, curr, long long int, 32);
1277     if ((Status & 0x04000000) == 0) // TODO not sure how pj64 handles this
1278         shuffle_fpr_data(0x04000000, 0);
1279     PUTARRAY(reg_cop1_fgr_64, curr, long long int, 32);
1280     if ((Status & 0x04000000) == 0) // TODO not sure how pj64 handles this
1281         shuffle_fpr_data(0x04000000, 0);
1282     PUTARRAY(reg_cop0, curr, unsigned int, 32);
1283     PUTDATA(curr, int, FCR0);
1284     for (i = 0; i < 30; i++)
1285         PUTDATA(curr, int, 0); // FCR1-30 not implemented
1286     PUTDATA(curr, int, FCR31);
1287     PUTDATA(curr, long long int, hi);
1288     PUTDATA(curr, long long int, lo);
1289
1290     PUTDATA(curr, unsigned int, rdram_register.rdram_config);
1291     PUTDATA(curr, unsigned int, rdram_register.rdram_device_id);
1292     PUTDATA(curr, unsigned int, rdram_register.rdram_delay);
1293     PUTDATA(curr, unsigned int, rdram_register.rdram_mode);
1294     PUTDATA(curr, unsigned int, rdram_register.rdram_ref_interval);
1295     PUTDATA(curr, unsigned int, rdram_register.rdram_ref_row);
1296     PUTDATA(curr, unsigned int, rdram_register.rdram_ras_interval);
1297     PUTDATA(curr, unsigned int, rdram_register.rdram_min_interval);
1298     PUTDATA(curr, unsigned int, rdram_register.rdram_addr_select);
1299     PUTDATA(curr, unsigned int, rdram_register.rdram_device_manuf);
1300
1301     PUTDATA(curr, unsigned int, sp_register.sp_mem_addr_reg);
1302     PUTDATA(curr, unsigned int, sp_register.sp_dram_addr_reg);
1303     PUTDATA(curr, unsigned int, sp_register.sp_rd_len_reg);
1304     PUTDATA(curr, unsigned int, sp_register.sp_wr_len_reg);
1305     PUTDATA(curr, unsigned int, sp_register.sp_status_reg);
1306     PUTDATA(curr, unsigned int, sp_register.sp_dma_full_reg);
1307     PUTDATA(curr, unsigned int, sp_register.sp_dma_busy_reg);
1308     PUTDATA(curr, unsigned int, sp_register.sp_semaphore_reg);
1309
1310     PUTDATA(curr, unsigned int, rsp_register.rsp_pc);
1311     PUTDATA(curr, unsigned int, rsp_register.rsp_ibist);
1312
1313     PUTDATA(curr, unsigned int, dpc_register.dpc_start);
1314     PUTDATA(curr, unsigned int, dpc_register.dpc_end);
1315     PUTDATA(curr, unsigned int, dpc_register.dpc_current);
1316     PUTDATA(curr, unsigned int, dpc_register.dpc_status);
1317     PUTDATA(curr, unsigned int, dpc_register.dpc_clock);
1318     PUTDATA(curr, unsigned int, dpc_register.dpc_bufbusy);
1319     PUTDATA(curr, unsigned int, dpc_register.dpc_pipebusy);
1320     PUTDATA(curr, unsigned int, dpc_register.dpc_tmem);
1321     PUTDATA(curr, unsigned int, 0); // ?
1322     PUTDATA(curr, unsigned int, 0); // ?
1323
1324     PUTDATA(curr, unsigned int, MI_register.mi_init_mode_reg); //TODO Secial handling in pj64
1325     PUTDATA(curr, unsigned int, MI_register.mi_version_reg);
1326     PUTDATA(curr, unsigned int, MI_register.mi_intr_reg);
1327     PUTDATA(curr, unsigned int, MI_register.mi_intr_mask_reg);
1328
1329     PUTDATA(curr, unsigned int, vi_register.vi_status);
1330     PUTDATA(curr, unsigned int, vi_register.vi_origin);
1331     PUTDATA(curr, unsigned int, vi_register.vi_width);
1332     PUTDATA(curr, unsigned int, vi_register.vi_v_intr);
1333     PUTDATA(curr, unsigned int, vi_register.vi_current);
1334     PUTDATA(curr, unsigned int, vi_register.vi_burst);
1335     PUTDATA(curr, unsigned int, vi_register.vi_v_sync);
1336     PUTDATA(curr, unsigned int, vi_register.vi_h_sync);
1337     PUTDATA(curr, unsigned int, vi_register.vi_leap);
1338     PUTDATA(curr, unsigned int, vi_register.vi_h_start);
1339     PUTDATA(curr, unsigned int, vi_register.vi_v_start);
1340     PUTDATA(curr, unsigned int, vi_register.vi_v_burst);
1341     PUTDATA(curr, unsigned int, vi_register.vi_x_scale);
1342     PUTDATA(curr, unsigned int, vi_register.vi_y_scale);
1343
1344     PUTDATA(curr, unsigned int, ai_register.ai_dram_addr);
1345     PUTDATA(curr, unsigned int, ai_register.ai_len);
1346     PUTDATA(curr, unsigned int, ai_register.ai_control);
1347     PUTDATA(curr, unsigned int, ai_register.ai_status);
1348     PUTDATA(curr, unsigned int, ai_register.ai_dacrate);
1349     PUTDATA(curr, unsigned int, ai_register.ai_bitrate);
1350
1351     PUTDATA(curr, unsigned int, pi_register.pi_dram_addr_reg);
1352     PUTDATA(curr, unsigned int, pi_register.pi_cart_addr_reg);
1353     PUTDATA(curr, unsigned int, pi_register.pi_rd_len_reg);
1354     PUTDATA(curr, unsigned int, pi_register.pi_wr_len_reg);
1355     PUTDATA(curr, unsigned int, pi_register.read_pi_status_reg);
1356     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_lat_reg);
1357     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_pwd_reg);
1358     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_pgs_reg);
1359     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom1_rls_reg);
1360     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_lat_reg);
1361     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_pwd_reg);
1362     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_pgs_reg);
1363     PUTDATA(curr, unsigned int, pi_register.pi_bsd_dom2_rls_reg);
1364
1365     PUTDATA(curr, unsigned int, ri_register.ri_mode);
1366     PUTDATA(curr, unsigned int, ri_register.ri_config);
1367     PUTDATA(curr, unsigned int, ri_register.ri_current_load);
1368     PUTDATA(curr, unsigned int, ri_register.ri_select);
1369     PUTDATA(curr, unsigned int, ri_register.ri_refresh);
1370     PUTDATA(curr, unsigned int, ri_register.ri_latency);
1371     PUTDATA(curr, unsigned int, ri_register.ri_error);
1372     PUTDATA(curr, unsigned int, ri_register.ri_werror);
1373
1374     PUTDATA(curr, unsigned int, si_register.si_dram_addr);
1375     PUTDATA(curr, unsigned int, si_register.si_pif_addr_rd64b);
1376     PUTDATA(curr, unsigned int, si_register.si_pif_addr_wr64b);
1377     PUTDATA(curr, unsigned int, si_register.si_stat);
1378
1379     for (i=0; i < 32;i++)
1380     {
1381         // From TLBR
1382         unsigned int EntryDefined, MyPageMask, MyEntryHi, MyEntryLo0, MyEntryLo1;
1383         EntryDefined = tlb_e[i].v_even || tlb_e[i].v_odd;
1384         MyPageMask = tlb_e[i].mask << 13;
1385         MyEntryHi = ((tlb_e[i].vpn2 << 13) | tlb_e[i].asid);
1386         MyEntryLo0 = (tlb_e[i].pfn_even << 6) | (tlb_e[i].c_even << 3)
1387          | (tlb_e[i].d_even << 2) | (tlb_e[i].v_even << 1)
1388            | tlb_e[i].g;
1389         MyEntryLo1 = (tlb_e[i].pfn_odd << 6) | (tlb_e[i].c_odd << 3)
1390          | (tlb_e[i].d_odd << 2) | (tlb_e[i].v_odd << 1)
1391            | tlb_e[i].g;
1392
1393         PUTDATA(curr, unsigned int, EntryDefined);
1394         PUTDATA(curr, unsigned int, MyPageMask);
1395         PUTDATA(curr, unsigned int, MyEntryHi);
1396         PUTDATA(curr, unsigned int, MyEntryLo0);
1397         PUTDATA(curr, unsigned int, MyEntryLo1);
1398     }
1399
1400     PUTARRAY(PIF_RAM, curr, unsigned char, 0x40);
1401
1402     PUTARRAY(rdram, curr, unsigned int, SaveRDRAMSize/4);
1403     PUTARRAY(SP_DMEM, curr, unsigned int, 0x1000/4);
1404     PUTARRAY(SP_IMEM, curr, unsigned int, 0x1000/4);
1405
1406     // Write the save state data to the output
1407     if (!write_func(handle, savestateData, savestateSize))
1408     {
1409         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Couldn't write data to Project64 state file %s.", filepath);
1410         free(savestateData);
1411         return 0;
1412     }
1413
1414     // assert(savestateData+savestateSize == curr)
1415     free(savestateData);
1416     return 1;
1417 }
1418
1419 static int write_data_to_zip(void *zip, const void *buffer, size_t length)
1420 {
1421     return zipWriteInFileInZip((zipFile)zip, buffer, (unsigned)length) == ZIP_OK;
1422 }
1423
1424 static int savestates_save_pj64_zip(char *filepath)
1425 {
1426     int retval;
1427     zipFile zipfile = NULL;
1428
1429     zipfile = zipOpen(filepath, APPEND_STATUS_CREATE);
1430     if(zipfile == NULL)
1431     {
1432         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not create PJ64 state file: %s", filepath);
1433         goto clean_and_exit;
1434     }
1435
1436     retval = zipOpenNewFileInZip(zipfile, namefrompath(filepath), NULL, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION);
1437     if(retval != ZIP_OK)
1438     {
1439         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Zip error. Could not create state file: %s", filepath);
1440         goto clean_and_exit;
1441     }
1442
1443     if (!savestates_save_pj64(filepath, zipfile, write_data_to_zip))
1444         goto clean_and_exit;
1445
1446     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Saved state to: %s", namefrompath(filepath));
1447
1448     clean_and_exit:
1449         if (zipfile != NULL)
1450         {
1451             zipCloseFileInZip(zipfile); // This may fail, but we don't care
1452             zipClose(zipfile, "");
1453         }
1454         return 1;
1455 }
1456
1457 static int write_data_to_file(void *file, const void *buffer, size_t length)
1458 {
1459     return fwrite(buffer, 1, length, (FILE *)file) == length;
1460 }
1461
1462 static int savestates_save_pj64_unc(char *filepath)
1463 {
1464     FILE *f;
1465
1466     f = fopen(filepath, "wb");
1467     if (f == NULL)
1468     {
1469         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Could not create PJ64 state file: %s", filepath);
1470         return 0;
1471     }
1472
1473     if (!savestates_save_pj64(filepath, f, write_data_to_file))
1474     {
1475         fclose(f);
1476         return 0;
1477     }
1478
1479     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "Saved state to: %s", namefrompath(filepath));
1480     fclose(f);
1481     return 1;
1482 }
1483
1484 int savestates_save(void)
1485 {
1486     char *filepath;
1487     int ret = 0;
1488
1489     /* Can only save PJ64 savestates on VI / COMPARE interrupt.
1490        Otherwise try again in a little while. */
1491     if ((type == savestates_type_pj64_zip ||
1492          type == savestates_type_pj64_unc) &&
1493         get_next_event_type() > COMPARE_INT)
1494         return 0;
1495
1496     if (fname != NULL && type == savestates_type_unknown)
1497         type = savestates_type_m64p;
1498     else if (fname == NULL) // Always save slots in M64P format
1499         type = savestates_type_m64p;
1500
1501     filepath = savestates_generate_path(type);
1502     if (filepath != NULL)
1503     {
1504         switch (type)
1505         {
1506             case savestates_type_m64p: ret = savestates_save_m64p(filepath); break;
1507             case savestates_type_pj64_zip: ret = savestates_save_pj64_zip(filepath); break;
1508             case savestates_type_pj64_unc: ret = savestates_save_pj64_unc(filepath); break;
1509             default: ret = 0; break;
1510         }
1511         free(filepath);
1512     }
1513
1514     // deliver callback to indicate completion of state saving operation
1515     StateChanged(M64CORE_STATE_SAVECOMPLETE, ret);
1516
1517     savestates_clear_job();
1518     return ret;
1519 }
1520
1521 void savestates_init(void)
1522 {
1523     savestates_lock = SDL_CreateMutex();
1524     if (!savestates_lock) {
1525         DebugMessage(M64MSG_ERROR, "Could not create savestates list lock");
1526         return;
1527     }
1528 }
1529
1530 void savestates_deinit(void)
1531 {
1532     SDL_DestroyMutex(savestates_lock);
1533     savestates_clear_job();
1534 }