dbed8b9b229ef3f0fa59758dc17b8c2dd852f378
[picodrive.git] / state.c
1 // (c) Copyright 2004 Dave, All rights reserved.\r
2 // (c) Copyright 2006-2010 notaz, All rights reserved.\r
3 // Free for non-commercial use.\r
4 \r
5 // For commercial use, separate licencing terms must be obtained.\r
6 \r
7 \r
8 #include "pico_int.h"\r
9 #include <zlib/zlib.h>\r
10 \r
11 #include "../cpu/sh2/sh2.h"\r
12 #include "sound/ym2612.h"\r
13 \r
14 // sn76496\r
15 extern int *sn76496_regs;\r
16 \r
17 typedef size_t (arearw)(void *p, size_t _size, size_t _n, void *file);\r
18 typedef size_t (areaeof)(void *file);\r
19 typedef int    (areaseek)(void *file, long offset, int whence);\r
20 typedef int    (areaclose)(void *file);\r
21 \r
22 static arearw    *areaRead;\r
23 static arearw    *areaWrite;\r
24 static areaeof   *areaEof;\r
25 static areaseek  *areaSeek;\r
26 static areaclose *areaClose;\r
27 \r
28 carthw_state_chunk *carthw_chunks;\r
29 void (*PicoStateProgressCB)(const char *str);\r
30 void (*PicoLoadStateHook)(void);\r
31 \r
32 \r
33 /* I/O functions */\r
34 static size_t gzRead2(void *p, size_t _size, size_t _n, void *file)\r
35 {\r
36   return gzread(file, p, _size * _n);\r
37 }\r
38 \r
39 static size_t gzWrite2(void *p, size_t _size, size_t _n, void *file)\r
40 {\r
41   return gzwrite(file, p, _size * _n);\r
42 }\r
43 \r
44 static void set_cbs(int gz)\r
45 {\r
46   if (gz) {\r
47     areaRead  = gzRead2;\r
48     areaWrite = gzWrite2;\r
49     areaEof   = (areaeof *) gzeof;\r
50     areaSeek  = (areaseek *) gzseek;\r
51     areaClose = (areaclose *) gzclose;\r
52   } else {\r
53     areaRead  = (arearw *) fread;\r
54     areaWrite = (arearw *) fwrite;\r
55     areaEof   = (areaeof *) feof;\r
56     areaSeek  = (areaseek *) fseek;\r
57     areaClose = (areaclose *) fclose;\r
58   }\r
59 }\r
60 \r
61 static void *open_save_file(const char *fname, int is_save)\r
62 {\r
63   int len = strlen(fname);\r
64   void *afile = NULL;\r
65 \r
66   if (len > 3 && strcmp(fname + len - 3, ".gz") == 0)\r
67   {\r
68     if ( (afile = gzopen(fname, is_save ? "wb" : "rb")) ) {\r
69       set_cbs(1);\r
70       if (is_save)\r
71         gzsetparams(afile, 9, Z_DEFAULT_STRATEGY);\r
72     }\r
73   }\r
74   else\r
75   {\r
76     if ( (afile = fopen(fname, is_save ? "wb" : "rb")) ) {\r
77       set_cbs(0);\r
78     }\r
79   }\r
80 \r
81   return afile;\r
82 }\r
83 \r
84 // legacy savestate loading\r
85 #define SCANP(f, x) areaRead(&Pico.x, sizeof(Pico.x), 1, f)\r
86 \r
87 static int state_load_legacy(void *file)\r
88 {\r
89   unsigned char head[32];\r
90   unsigned char cpu[0x60];\r
91   unsigned char cpu_z80[Z80_STATE_SIZE];\r
92   void *ym2612_regs;\r
93   int ok;\r
94 \r
95   memset(&cpu,0,sizeof(cpu));\r
96   memset(&cpu_z80,0,sizeof(cpu_z80));\r
97 \r
98   memset(head, 0, sizeof(head));\r
99   areaRead(head, sizeof(head), 1, file);\r
100   if (strcmp((char *)head, "Pico") != 0)\r
101     return -1;\r
102 \r
103   elprintf(EL_STATUS, "legacy savestate");\r
104 \r
105   // Scan all the memory areas:\r
106   SCANP(file, ram);\r
107   SCANP(file, vram);\r
108   SCANP(file, zram);\r
109   SCANP(file, cram);\r
110   SCANP(file, vsram);\r
111 \r
112   // Pack, scan and unpack the cpu data:\r
113   areaRead(cpu, sizeof(cpu), 1, file);\r
114   SekUnpackCpu(cpu, 0);\r
115 \r
116   SCANP(file, m);\r
117   SCANP(file, video);\r
118 \r
119   ok = areaRead(cpu_z80, sizeof(cpu_z80), 1, file) == sizeof(cpu_z80);\r
120   // do not unpack if we fail to load z80 state\r
121   if (!ok) z80_reset();\r
122   else     z80_unpack(cpu_z80);\r
123 \r
124   ym2612_regs = YM2612GetRegs();\r
125   areaRead(sn76496_regs, 28*4, 1, file);\r
126   areaRead(ym2612_regs, 0x200+4, 1, file);\r
127   ym2612_unpack_state();\r
128 \r
129   return 0;\r
130 }\r
131 \r
132 // ---------------------------------------------------------------------------\r
133 \r
134 typedef enum {\r
135   CHUNK_M68K = 1,\r
136   CHUNK_RAM,\r
137   CHUNK_VRAM,\r
138   CHUNK_ZRAM,\r
139   CHUNK_CRAM,    // 5\r
140   CHUNK_VSRAM,\r
141   CHUNK_MISC,\r
142   CHUNK_VIDEO,\r
143   CHUNK_Z80,\r
144   CHUNK_PSG,     // 10\r
145   CHUNK_FM,\r
146   // CD stuff\r
147   CHUNK_S68K,\r
148   CHUNK_PRG_RAM,\r
149   CHUNK_WORD_RAM,\r
150   CHUNK_PCM_RAM, // 15\r
151   CHUNK_BRAM,\r
152   CHUNK_GA_REGS,\r
153   CHUNK_PCM,\r
154   CHUNK_CDC,\r
155   CHUNK_CDD,     // 20\r
156   CHUNK_SCD,\r
157   CHUNK_RC,\r
158   CHUNK_MISC_CD,\r
159   //\r
160   CHUNK_IOPORTS, // versions < 1.70 did not save that..\r
161   CHUNK_SMS,     // 25\r
162   // 32x\r
163   CHUNK_MSH2,\r
164   CHUNK_MSH2_DATA,\r
165   CHUNK_MSH2_PERI,\r
166   CHUNK_SSH2,\r
167   CHUNK_SSH2_DATA, // 30\r
168   CHUNK_SSH2_PERI,\r
169   CHUNK_32XSYS,\r
170   CHUNK_M68K_BIOS,\r
171   CHUNK_MSH2_BIOS,\r
172   CHUNK_SSH2_BIOS, // 35\r
173   CHUNK_SDRAM,\r
174   CHUNK_DRAM,\r
175   CHUNK_32XPAL,\r
176   //\r
177   CHUNK_DEFAULT_COUNT,\r
178   CHUNK_CARTHW_ = CHUNK_CARTHW,  // defined in PicoInt\r
179 } chunk_name_e;\r
180 \r
181 static const char * const chunk_names[] = {\r
182   "INVALID!",\r
183   "M68K state",\r
184   "RAM",\r
185   "VRAM",\r
186   "ZRAM",\r
187   "CRAM",      // 5\r
188   "VSRAM",\r
189   "emu state",\r
190   "VIDEO",\r
191   "Z80 state",\r
192   "PSG",       // 10\r
193   "FM",\r
194   // CD stuff\r
195   "S68K state",\r
196   "PRG_RAM",\r
197   "WORD_RAM",\r
198   "PCM_RAM",   // 15\r
199   "BRAM",\r
200   "GATE ARRAY regs",\r
201   "PCM state",\r
202   "CDC",\r
203   "CDD",       // 20\r
204   "SCD",\r
205   "GFX chip",\r
206   "MCD state",\r
207   //\r
208   "IO",\r
209   "SMS state", // 25\r
210   // 32x\r
211   "MSH2",\r
212   "MSH2 data",\r
213   "MSH2 peri",\r
214   "SSH2",\r
215   "SSH2 data", // 30\r
216   "SSH2 peri",\r
217   "32X system regs",\r
218   "M68K BIOS",\r
219   "MSH2 BIOS",\r
220   "SSH2 BIOS", // 35\r
221   "SDRAM",\r
222   "DRAM",\r
223   "PAL",\r
224 };\r
225 \r
226 static int write_chunk(chunk_name_e name, int len, void *data, void *file)\r
227 {\r
228   size_t bwritten = 0;\r
229   bwritten += areaWrite(&name, 1, 1, file);\r
230   bwritten += areaWrite(&len, 1, 4, file);\r
231   bwritten += areaWrite(data, 1, len, file);\r
232 \r
233   return (bwritten == len + 4 + 1);\r
234 }\r
235 \r
236 #define CHECKED_WRITE(name,len,data) { \\r
237   if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT) { \\r
238     strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff) - 9); \\r
239     PicoStateProgressCB(sbuff); \\r
240   } \\r
241   if (!write_chunk(name, len, data, file)) return 1; \\r
242 }\r
243 \r
244 #define CHECKED_WRITE_BUFF(name,buff) { \\r
245   if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT) { \\r
246     strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff) - 9); \\r
247     PicoStateProgressCB(sbuff); \\r
248   } \\r
249   if (!write_chunk(name, sizeof(buff), &buff, file)) return 1; \\r
250 }\r
251 \r
252 static int state_save(void *file)\r
253 {\r
254   char sbuff[32] = "Saving.. ";\r
255   unsigned char buff[0x60], buff_z80[Z80_STATE_SIZE];\r
256   void *ym2612_regs = YM2612GetRegs();\r
257   int ver = 0x0170; // not really used..\r
258 \r
259   areaWrite("PicoSEXT", 1, 8, file);\r
260   areaWrite(&ver, 1, 4, file);\r
261 \r
262   if (!(PicoAHW & PAHW_SMS)) {\r
263     memset(buff, 0, sizeof(buff));\r
264     SekPackCpu(buff, 0);\r
265     CHECKED_WRITE_BUFF(CHUNK_M68K,  buff);\r
266     CHECKED_WRITE_BUFF(CHUNK_RAM,   Pico.ram);\r
267     CHECKED_WRITE_BUFF(CHUNK_VSRAM, Pico.vsram);\r
268     CHECKED_WRITE_BUFF(CHUNK_IOPORTS, Pico.ioports);\r
269     ym2612_pack_state();\r
270     CHECKED_WRITE(CHUNK_FM, 0x200+4, ym2612_regs);\r
271   }\r
272   else {\r
273     CHECKED_WRITE_BUFF(CHUNK_SMS, Pico.ms);\r
274   }\r
275 \r
276   CHECKED_WRITE_BUFF(CHUNK_VRAM,  Pico.vram);\r
277   CHECKED_WRITE_BUFF(CHUNK_ZRAM,  Pico.zram);\r
278   CHECKED_WRITE_BUFF(CHUNK_CRAM,  Pico.cram);\r
279   CHECKED_WRITE_BUFF(CHUNK_MISC,  Pico.m);\r
280   CHECKED_WRITE_BUFF(CHUNK_VIDEO, Pico.video);\r
281 \r
282   z80_pack(buff_z80);\r
283   CHECKED_WRITE_BUFF(CHUNK_Z80, buff_z80);\r
284   CHECKED_WRITE(CHUNK_PSG, 28*4, sn76496_regs);\r
285 \r
286   if (PicoAHW & PAHW_MCD)\r
287   {\r
288     memset(buff, 0, sizeof(buff));\r
289     SekPackCpu(buff, 1);\r
290     if (Pico_mcd->s68k_regs[3] & 4) // 1M mode?\r
291       wram_1M_to_2M(Pico_mcd->word_ram2M);\r
292     Pico_mcd->m.hint_vector = *(unsigned short *)(Pico_mcd->bios + 0x72);\r
293 \r
294     CHECKED_WRITE_BUFF(CHUNK_S68K,     buff);\r
295     CHECKED_WRITE_BUFF(CHUNK_PRG_RAM,  Pico_mcd->prg_ram);\r
296     CHECKED_WRITE_BUFF(CHUNK_WORD_RAM, Pico_mcd->word_ram2M); // in 2M format\r
297     CHECKED_WRITE_BUFF(CHUNK_PCM_RAM,  Pico_mcd->pcm_ram);\r
298     CHECKED_WRITE_BUFF(CHUNK_BRAM,     Pico_mcd->bram);\r
299     CHECKED_WRITE_BUFF(CHUNK_GA_REGS,  Pico_mcd->s68k_regs); // GA regs, not CPU regs\r
300     CHECKED_WRITE_BUFF(CHUNK_PCM,      Pico_mcd->pcm);\r
301     CHECKED_WRITE_BUFF(CHUNK_CDD,      Pico_mcd->cdd);\r
302     CHECKED_WRITE_BUFF(CHUNK_CDC,      Pico_mcd->cdc);\r
303     CHECKED_WRITE_BUFF(CHUNK_SCD,      Pico_mcd->scd);\r
304     CHECKED_WRITE_BUFF(CHUNK_RC,       Pico_mcd->rot_comp);\r
305     CHECKED_WRITE_BUFF(CHUNK_MISC_CD,  Pico_mcd->m);\r
306 \r
307     if (Pico_mcd->s68k_regs[3] & 4) // convert back\r
308       wram_2M_to_1M(Pico_mcd->word_ram2M);\r
309   }\r
310 \r
311 #ifndef NO_32X\r
312   if (PicoAHW & PAHW_32X)\r
313   {\r
314     unsigned char cpubuff[SH2_STATE_SIZE];\r
315 \r
316     memset(cpubuff, 0, sizeof(cpubuff));\r
317 \r
318     sh2_pack(&sh2s[0], cpubuff);\r
319     CHECKED_WRITE_BUFF(CHUNK_MSH2,      cpubuff);\r
320     CHECKED_WRITE_BUFF(CHUNK_MSH2_DATA, Pico32xMem->data_array[0]);\r
321     CHECKED_WRITE_BUFF(CHUNK_MSH2_PERI, Pico32xMem->sh2_peri_regs[0]);\r
322 \r
323     sh2_pack(&sh2s[1], cpubuff);\r
324     CHECKED_WRITE_BUFF(CHUNK_SSH2,      cpubuff);\r
325     CHECKED_WRITE_BUFF(CHUNK_SSH2_DATA, Pico32xMem->data_array[1]);\r
326     CHECKED_WRITE_BUFF(CHUNK_SSH2_PERI, Pico32xMem->sh2_peri_regs[1]);\r
327 \r
328     CHECKED_WRITE_BUFF(CHUNK_32XSYS,    Pico32x);\r
329     CHECKED_WRITE_BUFF(CHUNK_M68K_BIOS, Pico32xMem->m68k_rom);\r
330     CHECKED_WRITE_BUFF(CHUNK_MSH2_BIOS, Pico32xMem->sh2_rom_m);\r
331     CHECKED_WRITE_BUFF(CHUNK_SSH2_BIOS, Pico32xMem->sh2_rom_s);\r
332     CHECKED_WRITE_BUFF(CHUNK_SDRAM,     Pico32xMem->sdram);\r
333     CHECKED_WRITE_BUFF(CHUNK_DRAM,      Pico32xMem->dram);\r
334     CHECKED_WRITE_BUFF(CHUNK_32XPAL,    Pico32xMem->pal);\r
335   }\r
336 #endif\r
337 \r
338   if (carthw_chunks != NULL)\r
339   {\r
340     carthw_state_chunk *chwc;\r
341     if (PicoStateProgressCB)\r
342       PicoStateProgressCB("Saving.. cart hw state");\r
343     for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++)\r
344       CHECKED_WRITE(chwc->chunk, chwc->size, chwc->ptr);\r
345   }\r
346 \r
347   return 0;\r
348 }\r
349 \r
350 static int g_read_offs = 0;\r
351 \r
352 #define R_ERROR_RETURN(error) \\r
353 { \\r
354   elprintf(EL_STATUS, "load_state @ %x: " error, g_read_offs); \\r
355   return 1; \\r
356 }\r
357 \r
358 // when is eof really set?\r
359 #define CHECKED_READ(len,data) { \\r
360   if (areaRead(data, 1, len, file) != len) { \\r
361     if (len == 1 && areaEof(file)) goto readend; \\r
362     R_ERROR_RETURN("areaRead: premature EOF\n"); \\r
363     return 1; \\r
364   } \\r
365   g_read_offs += len; \\r
366 }\r
367 \r
368 #define CHECKED_READ2(len2,data) { \\r
369   if (len2 != len) { \\r
370     elprintf(EL_STATUS, "unexpected len %i, wanted %i (%s)", len, len2, #len2); \\r
371     if (len > len2) R_ERROR_RETURN("failed."); \\r
372     /* else read anyway and hope for the best.. */ \\r
373   } \\r
374   CHECKED_READ(len, data); \\r
375 }\r
376 \r
377 #define CHECKED_READ_BUFF(buff) CHECKED_READ2(sizeof(buff), &buff);\r
378 \r
379 static int state_load(void *file)\r
380 {\r
381   unsigned char buff_m68k[0x60], buff_s68k[0x60];\r
382   unsigned char buff_z80[Z80_STATE_SIZE];\r
383   unsigned char buff_sh2[SH2_STATE_SIZE];\r
384   unsigned char chunk;\r
385   void *ym2612_regs;\r
386   char header[8];\r
387   int ver, len;\r
388 \r
389   memset(buff_m68k, 0, sizeof(buff_m68k));\r
390   memset(buff_s68k, 0, sizeof(buff_s68k));\r
391   memset(buff_z80, 0, sizeof(buff_z80));\r
392 \r
393   g_read_offs = 0;\r
394   CHECKED_READ(8, header);\r
395   if (strncmp(header, "PicoSMCD", 8) && strncmp(header, "PicoSEXT", 8))\r
396     R_ERROR_RETURN("bad header");\r
397   CHECKED_READ(4, &ver);\r
398 \r
399   while (!areaEof(file))\r
400   {\r
401     CHECKED_READ(1, &chunk);\r
402     CHECKED_READ(4, &len);\r
403     if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");\r
404     if (CHUNK_S68K <= chunk && chunk <= CHUNK_MISC_CD && !(PicoAHW & PAHW_MCD))\r
405       R_ERROR_RETURN("cd chunk in non CD state?");\r
406     if (CHUNK_MSH2 <= chunk && chunk <= CHUNK_32XPAL && !(PicoAHW & PAHW_32X))\r
407       R_ERROR_RETURN("32x chunk in non 32x state?");\r
408 \r
409     switch (chunk)\r
410     {\r
411       case CHUNK_M68K:\r
412         CHECKED_READ_BUFF(buff_m68k);\r
413         break;\r
414 \r
415       case CHUNK_Z80:\r
416         CHECKED_READ_BUFF(buff_z80);\r
417         break;\r
418 \r
419       case CHUNK_RAM:     CHECKED_READ_BUFF(Pico.ram); break;\r
420       case CHUNK_VRAM:    CHECKED_READ_BUFF(Pico.vram); break;\r
421       case CHUNK_ZRAM:    CHECKED_READ_BUFF(Pico.zram); break;\r
422       case CHUNK_CRAM:    CHECKED_READ_BUFF(Pico.cram); break;\r
423       case CHUNK_VSRAM:   CHECKED_READ_BUFF(Pico.vsram); break;\r
424       case CHUNK_MISC:    CHECKED_READ_BUFF(Pico.m); break;\r
425       case CHUNK_VIDEO:   CHECKED_READ_BUFF(Pico.video); break;\r
426       case CHUNK_IOPORTS: CHECKED_READ_BUFF(Pico.ioports); break;\r
427       case CHUNK_PSG:     CHECKED_READ2(28*4, sn76496_regs); break;\r
428       case CHUNK_FM:\r
429         ym2612_regs = YM2612GetRegs();\r
430         CHECKED_READ2(0x200+4, ym2612_regs);\r
431         ym2612_unpack_state();\r
432         break;\r
433 \r
434       case CHUNK_SMS:\r
435         CHECKED_READ_BUFF(Pico.ms);\r
436         break;\r
437 \r
438       // cd stuff\r
439       case CHUNK_S68K:\r
440         CHECKED_READ_BUFF(buff_s68k);\r
441         break;\r
442 \r
443       case CHUNK_PRG_RAM:  CHECKED_READ_BUFF(Pico_mcd->prg_ram); break;\r
444       case CHUNK_WORD_RAM: CHECKED_READ_BUFF(Pico_mcd->word_ram2M); break;\r
445       case CHUNK_PCM_RAM:  CHECKED_READ_BUFF(Pico_mcd->pcm_ram); break;\r
446       case CHUNK_BRAM:     CHECKED_READ_BUFF(Pico_mcd->bram); break;\r
447       case CHUNK_GA_REGS:  CHECKED_READ_BUFF(Pico_mcd->s68k_regs); break;\r
448       case CHUNK_PCM:      CHECKED_READ_BUFF(Pico_mcd->pcm); break;\r
449       case CHUNK_CDD:      CHECKED_READ_BUFF(Pico_mcd->cdd); break;\r
450       case CHUNK_CDC:      CHECKED_READ_BUFF(Pico_mcd->cdc); break;\r
451       case CHUNK_SCD:      CHECKED_READ_BUFF(Pico_mcd->scd); break;\r
452       case CHUNK_RC:       CHECKED_READ_BUFF(Pico_mcd->rot_comp); break;\r
453       case CHUNK_MISC_CD:  CHECKED_READ_BUFF(Pico_mcd->m); break;\r
454 \r
455       // 32x stuff\r
456 #ifndef NO_32X\r
457       case CHUNK_MSH2:\r
458         CHECKED_READ_BUFF(buff_sh2);\r
459         sh2_unpack(&sh2s[0], buff_sh2);\r
460         break;\r
461 \r
462       case CHUNK_SSH2:\r
463         CHECKED_READ_BUFF(buff_sh2);\r
464         sh2_unpack(&sh2s[1], buff_sh2);\r
465         break;\r
466 \r
467       case CHUNK_MSH2_DATA:   CHECKED_READ_BUFF(Pico32xMem->data_array[0]); break;\r
468       case CHUNK_MSH2_PERI:   CHECKED_READ_BUFF(Pico32xMem->sh2_peri_regs[0]); break;\r
469       case CHUNK_SSH2_DATA:   CHECKED_READ_BUFF(Pico32xMem->data_array[1]); break;\r
470       case CHUNK_SSH2_PERI:   CHECKED_READ_BUFF(Pico32xMem->sh2_peri_regs[1]); break;\r
471       case CHUNK_32XSYS:      CHECKED_READ_BUFF(Pico32x); break;\r
472       case CHUNK_M68K_BIOS:   CHECKED_READ_BUFF(Pico32xMem->m68k_rom); break;\r
473       case CHUNK_MSH2_BIOS:   CHECKED_READ_BUFF(Pico32xMem->sh2_rom_m); break;\r
474       case CHUNK_SSH2_BIOS:   CHECKED_READ_BUFF(Pico32xMem->sh2_rom_s); break;\r
475       case CHUNK_SDRAM:       CHECKED_READ_BUFF(Pico32xMem->sdram); break;\r
476       case CHUNK_DRAM:        CHECKED_READ_BUFF(Pico32xMem->dram); break;\r
477       case CHUNK_32XPAL:      CHECKED_READ_BUFF(Pico32xMem->pal); break;\r
478 #endif\r
479       default:\r
480         if (carthw_chunks != NULL)\r
481         {\r
482           carthw_state_chunk *chwc;\r
483           for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++) {\r
484             if (chwc->chunk == chunk) {\r
485               CHECKED_READ2(chwc->size, chwc->ptr);\r
486               goto breakswitch;\r
487             }\r
488           }\r
489         }\r
490         elprintf(EL_STATUS, "load_state: skipping unknown chunk %i of size %i", chunk, len);\r
491         areaSeek(file, len, SEEK_CUR);\r
492         break;\r
493     }\r
494 breakswitch:;\r
495   }\r
496 \r
497 readend:\r
498   if (PicoAHW & PAHW_SMS)\r
499     PicoStateLoadedMS();\r
500 \r
501   if (PicoAHW & PAHW_MCD)\r
502   {\r
503     PicoMemStateLoaded();\r
504 \r
505     if (!(Pico_mcd->s68k_regs[0x36] & 1) && (Pico_mcd->scd.Status_CDC & 1))\r
506       cdda_start_play();\r
507 \r
508     SekUnpackCpu(buff_s68k, 1);\r
509   }\r
510 \r
511   // must unpack 68k and z80 after banks are set up\r
512   if (!(PicoAHW & PAHW_SMS))\r
513     SekUnpackCpu(buff_m68k, 0);\r
514 \r
515   z80_unpack(buff_z80);\r
516 \r
517   if (PicoAHW & PAHW_32X)\r
518     Pico32xStateLoaded();\r
519 \r
520   return 0;\r
521 }\r
522 \r
523 static int state_load_gfx(void *file)\r
524 {\r
525   int ver, len, found = 0, to_find = 4;\r
526   char buff[8];\r
527 \r
528   if (PicoAHW & PAHW_32X)\r
529     to_find += 2;\r
530 \r
531   g_read_offs = 0;\r
532   CHECKED_READ(8, buff);\r
533   if (strncmp((char *)buff, "PicoSMCD", 8) && strncmp((char *)buff, "PicoSEXT", 8))\r
534     R_ERROR_RETURN("bad header");\r
535   CHECKED_READ(4, &ver);\r
536 \r
537   while (!areaEof(file) && found < to_find)\r
538   {\r
539     CHECKED_READ(1, buff);\r
540     CHECKED_READ(4, &len);\r
541     if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");\r
542     if (buff[0] > CHUNK_FM && buff[0] <= CHUNK_MISC_CD && !(PicoAHW & PAHW_MCD))\r
543       R_ERROR_RETURN("cd chunk in non CD state?");\r
544 \r
545     switch (buff[0])\r
546     {\r
547       case CHUNK_VRAM:  CHECKED_READ_BUFF(Pico.vram);  found++; break;\r
548       case CHUNK_CRAM:  CHECKED_READ_BUFF(Pico.cram);  found++; break;\r
549       case CHUNK_VSRAM: CHECKED_READ_BUFF(Pico.vsram); found++; break;\r
550       case CHUNK_VIDEO: CHECKED_READ_BUFF(Pico.video); found++; break;\r
551 \r
552 #ifndef NO_32X\r
553       case CHUNK_DRAM:\r
554         if (Pico32xMem != NULL)\r
555           CHECKED_READ_BUFF(Pico32xMem->dram);\r
556         break;\r
557 \r
558       case CHUNK_32XPAL:\r
559         if (Pico32xMem != NULL)\r
560           CHECKED_READ_BUFF(Pico32xMem->pal);\r
561         Pico32x.dirty_pal = 1;\r
562         break;\r
563 \r
564       case CHUNK_32XSYS:\r
565         CHECKED_READ_BUFF(Pico32x);\r
566         break;\r
567 #endif\r
568       default:\r
569         areaSeek(file, len, SEEK_CUR);\r
570         break;\r
571     }\r
572   }\r
573 \r
574 readend:\r
575   return 0;\r
576 }\r
577 \r
578 int PicoState(const char *fname, int is_save)\r
579 {\r
580   void *afile = NULL;\r
581   int ret;\r
582 \r
583   afile = open_save_file(fname, is_save);\r
584   if (afile == NULL)\r
585     return -1;\r
586 \r
587   if (is_save)\r
588     ret = state_save(afile);\r
589   else {\r
590     ret = state_load(afile);\r
591     if (ret != 0) {\r
592       areaSeek(afile, 0, SEEK_SET);\r
593       ret = state_load_legacy(afile);\r
594     }\r
595 \r
596     if (PicoLoadStateHook != NULL)\r
597       PicoLoadStateHook();\r
598     Pico.m.dirtyPal = 1;\r
599   }\r
600 \r
601   areaClose(afile);\r
602   return ret;\r
603 }\r
604 \r
605 int PicoStateLoadGfx(const char *fname)\r
606 {\r
607   void *afile;\r
608   int ret;\r
609 \r
610   afile = open_save_file(fname, 0);\r
611   if (afile == NULL)\r
612     return -1;\r
613 \r
614   ret = state_load_gfx(afile);\r
615   if (ret != 0) {\r
616     // assume legacy\r
617     areaSeek(afile, 0x10020, SEEK_SET);  // skip header and RAM\r
618     areaRead(Pico.vram, 1, sizeof(Pico.vram), afile);\r
619     areaSeek(afile, 0x2000, SEEK_CUR);\r
620     areaRead(Pico.cram, 1, sizeof(Pico.cram), afile);\r
621     areaRead(Pico.vsram, 1, sizeof(Pico.vsram), afile);\r
622     areaSeek(afile, 0x221a0, SEEK_SET);\r
623     areaRead(&Pico.video, 1, sizeof(Pico.video), afile);\r
624   }\r
625   areaClose(afile);\r
626   return 0;\r
627 }\r
628 \r
629 // tmp state\r
630 struct PicoTmp\r
631 {\r
632   unsigned short vram[0x8000];\r
633   unsigned short cram[0x40];\r
634   unsigned short vsram[0x40];\r
635 \r
636   //struct PicoMisc m;\r
637   struct PicoVideo video;\r
638 \r
639   struct {\r
640     struct Pico32x p32x;\r
641     unsigned short dram[2][0x20000/2];\r
642     unsigned short pal[0x100];\r
643   } t32x;\r
644 };\r
645 \r
646 // returns data ptr to free() or PicoTmpStateRestore()\r
647 void *PicoTmpStateSave(void)\r
648 {\r
649   // gfx only for now\r
650   struct PicoTmp *t = malloc(sizeof(*t));\r
651   if (t == NULL)\r
652     return NULL;\r
653 \r
654   memcpy(t->vram, Pico.vram, sizeof(Pico.vram));\r
655   memcpy(t->cram, Pico.cram, sizeof(Pico.cram));\r
656   memcpy(t->vsram, Pico.vsram, sizeof(Pico.vsram));\r
657   memcpy(&t->video, &Pico.video, sizeof(Pico.video));\r
658 \r
659 #ifndef NO_32X\r
660   if (PicoAHW & PAHW_32X) {\r
661     memcpy(&t->t32x.p32x, &Pico32x, sizeof(Pico32x));\r
662     memcpy(t->t32x.dram, Pico32xMem->dram, sizeof(Pico32xMem->dram));\r
663     memcpy(t->t32x.pal, Pico32xMem->pal, sizeof(Pico32xMem->pal));\r
664   }\r
665 #endif\r
666 \r
667   return t;\r
668 }\r
669 \r
670 void PicoTmpStateRestore(void *data)\r
671 {\r
672   struct PicoTmp *t = data;\r
673   if (t == NULL)\r
674     return;\r
675 \r
676   memcpy(Pico.vram, t->vram, sizeof(Pico.vram));\r
677   memcpy(Pico.cram, t->cram, sizeof(Pico.cram));\r
678   memcpy(Pico.vsram, t->vsram, sizeof(Pico.vsram));\r
679   memcpy(&Pico.video, &t->video, sizeof(Pico.video));\r
680   Pico.m.dirtyPal = 1;\r
681 \r
682 #ifndef NO_32X\r
683   if (PicoAHW & PAHW_32X) {\r
684     memcpy(&Pico32x, &t->t32x.p32x, sizeof(Pico32x));\r
685     memcpy(Pico32xMem->dram, t->t32x.dram, sizeof(Pico32xMem->dram));\r
686     memcpy(Pico32xMem->pal, t->t32x.pal, sizeof(Pico32xMem->pal));\r
687     Pico32x.dirty_pal = 1;\r
688   }\r
689 #endif\r
690 }\r
691 \r
692 // vim:shiftwidth=2:expandtab\r