5 * This work is licensed under the terms of MAME license.
\r
6 * See COPYING file in the top-level directory.
\r
9 #include "pico_int.h"
\r
12 #include "../cpu/sh2/sh2.h"
\r
13 #include "sound/ym2612.h"
\r
17 extern int *sn76496_regs;
\r
19 static arearw *areaRead;
\r
20 static arearw *areaWrite;
\r
21 static areaeof *areaEof;
\r
22 static areaseek *areaSeek;
\r
23 static areaclose *areaClose;
\r
25 carthw_state_chunk *carthw_chunks;
\r
26 void (*PicoStateProgressCB)(const char *str);
\r
27 void (*PicoLoadStateHook)(void);
\r
31 static size_t gzRead2(void *p, size_t _size, size_t _n, void *file)
\r
33 return gzread(file, p, _size * _n);
\r
36 static size_t gzWrite2(void *p, size_t _size, size_t _n, void *file)
\r
38 return gzwrite(file, p, _size * _n);
\r
41 static void set_cbs(int gz)
\r
45 areaWrite = gzWrite2;
\r
46 areaEof = (areaeof *) gzeof;
\r
47 areaSeek = (areaseek *) gzseek;
\r
48 areaClose = (areaclose *) gzclose;
\r
50 areaRead = (arearw *) fread;
\r
51 areaWrite = (arearw *) fwrite;
\r
52 areaEof = (areaeof *) feof;
\r
53 areaSeek = (areaseek *) fseek;
\r
54 areaClose = (areaclose *) fclose;
\r
58 static void *open_save_file(const char *fname, int is_save)
\r
60 int len = strlen(fname);
\r
63 if (len > 3 && strcmp(fname + len - 3, ".gz") == 0)
\r
65 if ( (afile = gzopen(fname, is_save ? "wb" : "rb")) ) {
\r
68 gzsetparams(afile, 9, Z_DEFAULT_STRATEGY);
\r
73 if ( (afile = fopen(fname, is_save ? "wb" : "rb")) ) {
\r
81 // ---------------------------------------------------------------------------
\r
99 CHUNK_PCM_RAM, // 15
\r
104 CHUNK_CDD, // 20 old
\r
109 CHUNK_IOPORTS, // versions < 1.70 did not save that..
\r
116 CHUNK_SSH2_DATA, // 30
\r
121 CHUNK_SSH2_BIOS, // 35
\r
126 CHUNK_32X_FIRST = CHUNK_MSH2,
\r
127 CHUNK_32X_LAST = CHUNK_32X_EVT,
\r
128 // add new stuff here
\r
134 CHUNK_DEFAULT_COUNT,
\r
135 CHUNK_CARTHW_ = CHUNK_CARTHW, // 64 (defined in PicoInt)
\r
138 static const char * const chunk_names[CHUNK_DEFAULT_COUNT] = {
\r
184 static int write_chunk(chunk_name_e name, int len, void *data, void *file)
\r
186 size_t bwritten = 0;
\r
187 bwritten += areaWrite(&name, 1, 1, file);
\r
188 bwritten += areaWrite(&len, 1, 4, file);
\r
189 bwritten += areaWrite(data, 1, len, file);
\r
191 return (bwritten == len + 4 + 1);
\r
194 #define CHUNK_LIMIT_W 18772 // sizeof(cdc)
\r
196 #define CHECKED_WRITE(name,len,data) { \
\r
197 if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT && chunk_names[name]) { \
\r
198 strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff) - 9); \
\r
199 PicoStateProgressCB(sbuff); \
\r
201 if (data == buf2 && len > CHUNK_LIMIT_W) \
\r
203 if (!write_chunk(name, len, data, file)) \
\r
207 #define CHECKED_WRITE_BUFF(name,buff) { \
\r
208 if (PicoStateProgressCB && name < CHUNK_DEFAULT_COUNT && chunk_names[name]) { \
\r
209 strncpy(sbuff + 9, chunk_names[name], sizeof(sbuff) - 9); \
\r
210 PicoStateProgressCB(sbuff); \
\r
212 if (!write_chunk(name, sizeof(buff), &buff, file)) \
\r
216 static int state_save(void *file)
\r
218 char sbuff[32] = "Saving.. ";
\r
219 unsigned char buff[0x60], buff_z80[Z80_STATE_SIZE];
\r
220 void *ym2612_regs = YM2612GetRegs();
\r
222 int ver = 0x0191; // not really used..
\r
226 areaWrite("PicoSEXT", 1, 8, file);
\r
227 areaWrite(&ver, 1, 4, file);
\r
229 if (!(PicoIn.AHW & PAHW_SMS)) {
\r
230 // the patches can cause incompatible saves with no-idle
\r
231 SekFinishIdleDet();
\r
233 memset(buff, 0, sizeof(buff));
\r
234 SekPackCpu(buff, 0);
\r
235 CHECKED_WRITE_BUFF(CHUNK_M68K, buff);
\r
236 CHECKED_WRITE_BUFF(CHUNK_RAM, PicoMem.ram);
\r
237 CHECKED_WRITE_BUFF(CHUNK_VSRAM, PicoMem.vsram);
\r
238 CHECKED_WRITE_BUFF(CHUNK_IOPORTS, PicoMem.ioports);
\r
239 ym2612_pack_state();
\r
240 CHECKED_WRITE(CHUNK_FM, 0x200+4, ym2612_regs);
\r
242 if (!(PicoIn.opt & POPT_DIS_IDLE_DET))
\r
246 CHECKED_WRITE_BUFF(CHUNK_SMS, Pico.ms);
\r
249 CHECKED_WRITE_BUFF(CHUNK_VRAM, PicoMem.vram);
\r
250 CHECKED_WRITE_BUFF(CHUNK_ZRAM, PicoMem.zram);
\r
251 CHECKED_WRITE_BUFF(CHUNK_CRAM, PicoMem.cram);
\r
252 CHECKED_WRITE_BUFF(CHUNK_MISC, Pico.m);
\r
253 CHECKED_WRITE_BUFF(CHUNK_VIDEO, Pico.video);
\r
255 z80_pack(buff_z80);
\r
256 CHECKED_WRITE_BUFF(CHUNK_Z80, buff_z80);
\r
257 CHECKED_WRITE(CHUNK_PSG, 28*4, sn76496_regs);
\r
259 if (PicoIn.AHW & PAHW_MCD)
\r
261 buf2 = malloc(CHUNK_LIMIT_W);
\r
265 memset(buff, 0, sizeof(buff));
\r
266 SekPackCpu(buff, 1);
\r
267 if (Pico_mcd->s68k_regs[3] & 4) // 1M mode?
\r
268 wram_1M_to_2M(Pico_mcd->word_ram2M);
\r
269 memcpy(&Pico_mcd->m.hint_vector, Pico_mcd->bios + 0x72,
\r
270 sizeof(Pico_mcd->m.hint_vector));
\r
272 CHECKED_WRITE_BUFF(CHUNK_S68K, buff);
\r
273 CHECKED_WRITE_BUFF(CHUNK_PRG_RAM, Pico_mcd->prg_ram);
\r
274 CHECKED_WRITE_BUFF(CHUNK_WORD_RAM, Pico_mcd->word_ram2M); // in 2M format
\r
275 CHECKED_WRITE_BUFF(CHUNK_PCM_RAM, Pico_mcd->pcm_ram);
\r
276 CHECKED_WRITE_BUFF(CHUNK_BRAM, Pico_mcd->bram);
\r
277 CHECKED_WRITE_BUFF(CHUNK_GA_REGS, Pico_mcd->s68k_regs); // GA regs, not CPU regs
\r
278 CHECKED_WRITE_BUFF(CHUNK_PCM, Pico_mcd->pcm);
\r
279 CHECKED_WRITE_BUFF(CHUNK_MISC_CD, Pico_mcd->m);
\r
280 memset(buff, 0, 0x40);
\r
281 memcpy(buff, pcd_event_times, sizeof(pcd_event_times));
\r
282 CHECKED_WRITE(CHUNK_CD_EVT, 0x40, buff);
\r
284 len = gfx_context_save(buf2);
\r
285 CHECKED_WRITE(CHUNK_CD_GFX, len, buf2);
\r
286 len = cdc_context_save(buf2);
\r
287 CHECKED_WRITE(CHUNK_CD_CDC, len, buf2);
\r
288 len = cdd_context_save(buf2);
\r
289 CHECKED_WRITE(CHUNK_CD_CDD, len, buf2);
\r
291 if (Pico_mcd->s68k_regs[3] & 4) // convert back
\r
292 wram_2M_to_1M(Pico_mcd->word_ram2M);
\r
296 if (PicoIn.AHW & PAHW_32X)
\r
298 unsigned char cpubuff[SH2_STATE_SIZE];
\r
300 memset(cpubuff, 0, sizeof(cpubuff));
\r
302 sh2_pack(&sh2s[0], cpubuff);
\r
303 CHECKED_WRITE_BUFF(CHUNK_MSH2, cpubuff);
\r
304 CHECKED_WRITE_BUFF(CHUNK_MSH2_DATA, sh2s[0].data_array);
\r
305 CHECKED_WRITE_BUFF(CHUNK_MSH2_PERI, sh2s[0].peri_regs);
\r
307 sh2_pack(&sh2s[1], cpubuff);
\r
308 CHECKED_WRITE_BUFF(CHUNK_SSH2, cpubuff);
\r
309 CHECKED_WRITE_BUFF(CHUNK_SSH2_DATA, sh2s[1].data_array);
\r
310 CHECKED_WRITE_BUFF(CHUNK_SSH2_PERI, sh2s[1].peri_regs);
\r
312 CHECKED_WRITE_BUFF(CHUNK_32XSYS, Pico32x);
\r
313 CHECKED_WRITE_BUFF(CHUNK_M68K_BIOS, Pico32xMem->m68k_rom);
\r
314 CHECKED_WRITE_BUFF(CHUNK_MSH2_BIOS, Pico32xMem->sh2_rom_m);
\r
315 CHECKED_WRITE_BUFF(CHUNK_SSH2_BIOS, Pico32xMem->sh2_rom_s);
\r
316 CHECKED_WRITE_BUFF(CHUNK_SDRAM, Pico32xMem->sdram);
\r
317 CHECKED_WRITE_BUFF(CHUNK_DRAM, Pico32xMem->dram);
\r
318 CHECKED_WRITE_BUFF(CHUNK_32XPAL, Pico32xMem->pal);
\r
320 memset(buff, 0, 0x40);
\r
321 memcpy(buff, p32x_event_times, sizeof(p32x_event_times));
\r
322 CHECKED_WRITE(CHUNK_32X_EVT, 0x40, buff);
\r
326 if (carthw_chunks != NULL)
\r
328 carthw_state_chunk *chwc;
\r
329 if (PicoStateProgressCB)
\r
330 PicoStateProgressCB("Saving.. cart hw state");
\r
331 for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++)
\r
332 CHECKED_WRITE(chwc->chunk, chwc->size, chwc->ptr);
\r
343 static int g_read_offs = 0;
\r
345 #define R_ERROR_RETURN(error) \
\r
347 elprintf(EL_STATUS, "load_state @ %x: " error, g_read_offs); \
\r
351 // when is eof really set?
\r
352 #define CHECKED_READ(len,data) { \
\r
353 if (areaRead(data, 1, len, file) != len) { \
\r
354 if (len == 1 && areaEof(file)) goto readend; \
\r
355 R_ERROR_RETURN("areaRead: premature EOF\n"); \
\r
357 g_read_offs += len; \
\r
360 #define CHECKED_READ2(len2,data) { \
\r
361 if (len2 != len) { \
\r
362 elprintf(EL_STATUS, "unexpected len %i, wanted %i (%s)", len, len2, #len2); \
\r
363 if (len > len2) R_ERROR_RETURN("failed."); \
\r
364 /* else read anyway and hope for the best.. */ \
\r
366 CHECKED_READ(len, data); \
\r
369 #define CHECKED_READ_BUFF(buff) CHECKED_READ2(sizeof(buff), &buff);
\r
371 #define CHUNK_LIMIT_R 0x10960 // sizeof(old_cdc)
\r
373 #define CHECKED_READ_LIM(data) { \
\r
374 if (len > CHUNK_LIMIT_R) \
\r
375 R_ERROR_RETURN("chunk size over limit."); \
\r
376 CHECKED_READ(len, data); \
\r
379 static int state_load(void *file)
\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 *buf = NULL;
\r
385 unsigned char chunk;
\r
392 memset(buff_m68k, 0, sizeof(buff_m68k));
\r
393 memset(buff_s68k, 0, sizeof(buff_s68k));
\r
394 memset(buff_z80, 0, sizeof(buff_z80));
\r
396 buf = malloc(CHUNK_LIMIT_R);
\r
401 CHECKED_READ(8, header);
\r
402 if (strncmp(header, "PicoSMCD", 8) && strncmp(header, "PicoSEXT", 8))
\r
403 R_ERROR_RETURN("bad header");
\r
404 CHECKED_READ(4, &ver);
\r
406 memset(pcd_event_times, 0, sizeof(pcd_event_times));
\r
407 memset(p32x_event_times, 0, sizeof(p32x_event_times));
\r
409 while (!areaEof(file))
\r
412 CHECKED_READ(1, &chunk);
\r
413 CHECKED_READ(4, &len);
\r
414 if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");
\r
415 if (CHUNK_S68K <= chunk && chunk <= CHUNK_MISC_CD && !(PicoIn.AHW & PAHW_MCD))
\r
416 R_ERROR_RETURN("cd chunk in non CD state?");
\r
417 if (CHUNK_32X_FIRST <= chunk && chunk <= CHUNK_32X_LAST && !(PicoIn.AHW & PAHW_32X))
\r
423 CHECKED_READ_BUFF(buff_m68k);
\r
427 CHECKED_READ_BUFF(buff_z80);
\r
430 case CHUNK_RAM: CHECKED_READ_BUFF(PicoMem.ram); break;
\r
431 case CHUNK_VRAM: CHECKED_READ_BUFF(PicoMem.vram); break;
\r
432 case CHUNK_ZRAM: CHECKED_READ_BUFF(PicoMem.zram); break;
\r
433 case CHUNK_CRAM: CHECKED_READ_BUFF(PicoMem.cram); break;
\r
434 case CHUNK_VSRAM: CHECKED_READ_BUFF(PicoMem.vsram); break;
\r
435 case CHUNK_MISC: CHECKED_READ_BUFF(Pico.m); break;
\r
436 case CHUNK_VIDEO: CHECKED_READ_BUFF(Pico.video); break;
\r
437 case CHUNK_IOPORTS: CHECKED_READ_BUFF(PicoMem.ioports); break;
\r
438 case CHUNK_PSG: CHECKED_READ2(28*4, sn76496_regs); break;
\r
440 ym2612_regs = YM2612GetRegs();
\r
441 CHECKED_READ2(0x200+4, ym2612_regs);
\r
442 ym2612_unpack_state();
\r
446 CHECKED_READ_BUFF(Pico.ms);
\r
451 CHECKED_READ_BUFF(buff_s68k);
\r
454 case CHUNK_PRG_RAM: CHECKED_READ_BUFF(Pico_mcd->prg_ram); break;
\r
455 case CHUNK_WORD_RAM: CHECKED_READ_BUFF(Pico_mcd->word_ram2M); break;
\r
456 case CHUNK_PCM_RAM: CHECKED_READ_BUFF(Pico_mcd->pcm_ram); break;
\r
457 case CHUNK_BRAM: CHECKED_READ_BUFF(Pico_mcd->bram); break;
\r
458 case CHUNK_GA_REGS: CHECKED_READ_BUFF(Pico_mcd->s68k_regs); break;
\r
459 case CHUNK_PCM: CHECKED_READ_BUFF(Pico_mcd->pcm); break;
\r
460 case CHUNK_MISC_CD: CHECKED_READ_BUFF(Pico_mcd->m); break;
\r
463 CHECKED_READ2(0x40, buf);
\r
464 memcpy(pcd_event_times, buf, sizeof(pcd_event_times));
\r
468 CHECKED_READ_LIM(buf);
\r
469 len_check = gfx_context_load(buf);
\r
473 CHECKED_READ_LIM(buf);
\r
474 len_check = cdc_context_load(buf);
\r
478 CHECKED_READ_LIM(buf);
\r
479 len_check = cdd_context_load(buf);
\r
482 // old, to be removed:
\r
484 CHECKED_READ_LIM(buf);
\r
485 cdc_context_load_old(buf);
\r
489 CHECKED_READ_LIM(buf);
\r
490 cdd_context_load_old(buf);
\r
496 CHECKED_READ_BUFF(buff_sh2);
\r
497 sh2_unpack(&sh2s[0], buff_sh2);
\r
501 CHECKED_READ_BUFF(buff_sh2);
\r
502 sh2_unpack(&sh2s[1], buff_sh2);
\r
505 case CHUNK_MSH2_DATA: CHECKED_READ_BUFF(sh2s[0].data_array); break;
\r
506 case CHUNK_MSH2_PERI: CHECKED_READ_BUFF(sh2s[0].peri_regs); break;
\r
507 case CHUNK_SSH2_DATA: CHECKED_READ_BUFF(sh2s[1].data_array); break;
\r
508 case CHUNK_SSH2_PERI: CHECKED_READ_BUFF(sh2s[1].peri_regs); break;
\r
509 case CHUNK_32XSYS: CHECKED_READ_BUFF(Pico32x); break;
\r
510 case CHUNK_M68K_BIOS: CHECKED_READ_BUFF(Pico32xMem->m68k_rom); break;
\r
511 case CHUNK_MSH2_BIOS: CHECKED_READ_BUFF(Pico32xMem->sh2_rom_m); break;
\r
512 case CHUNK_SSH2_BIOS: CHECKED_READ_BUFF(Pico32xMem->sh2_rom_s); break;
\r
513 case CHUNK_SDRAM: CHECKED_READ_BUFF(Pico32xMem->sdram); break;
\r
514 case CHUNK_DRAM: CHECKED_READ_BUFF(Pico32xMem->dram); break;
\r
515 case CHUNK_32XPAL: CHECKED_READ_BUFF(Pico32xMem->pal); break;
\r
517 case CHUNK_32X_EVT:
\r
518 CHECKED_READ2(0x40, buf);
\r
519 memcpy(p32x_event_times, buf, sizeof(p32x_event_times));
\r
523 if (carthw_chunks != NULL)
\r
525 carthw_state_chunk *chwc;
\r
526 for (chwc = carthw_chunks; chwc->ptr != NULL; chwc++) {
\r
527 if (chwc->chunk == chunk) {
\r
528 CHECKED_READ2(chwc->size, chwc->ptr);
\r
533 elprintf(EL_STATUS, "load_state: skipping unknown chunk %i of size %i", chunk, len);
\r
534 areaSeek(file, len, SEEK_CUR);
\r
538 if (len_check != 0 && len_check != len)
\r
539 elprintf(EL_STATUS, "load_state: chunk %d has bad len %d/%d",
\r
544 if (PicoIn.AHW & PAHW_SMS)
\r
545 PicoStateLoadedMS();
\r
547 if (PicoIn.AHW & PAHW_32X)
\r
548 Pico32xStateLoaded(1);
\r
550 if (PicoLoadStateHook != NULL)
\r
551 PicoLoadStateHook();
\r
553 // must unpack 68k and z80 after banks are set up
\r
554 if (!(PicoIn.AHW & PAHW_SMS))
\r
555 SekUnpackCpu(buff_m68k, 0);
\r
556 if (PicoIn.AHW & PAHW_MCD)
\r
557 SekUnpackCpu(buff_s68k, 1);
\r
559 z80_unpack(buff_z80);
\r
561 // due to dep from 68k cycles..
\r
562 Pico.t.m68c_aim = Pico.t.m68c_cnt;
\r
563 if (PicoIn.AHW & PAHW_32X)
\r
564 Pico32xStateLoaded(0);
\r
565 if (PicoIn.AHW & PAHW_MCD)
\r
567 SekCycleAimS68k = SekCycleCntS68k;
\r
568 pcd_state_loaded();
\r
571 Pico.m.dirtyPal = 1;
\r
572 Pico.video.status &= ~(SR_VB | SR_F);
\r
573 Pico.video.status |= ((Pico.video.reg[1] >> 3) ^ SR_VB) & SR_VB;
\r
574 Pico.video.status |= (Pico.video.pending_ints << 2) & SR_F;
\r
583 static int state_load_gfx(void *file)
\r
585 int ver, len, found = 0, to_find = 4;
\r
588 if (PicoIn.AHW & PAHW_32X)
\r
592 CHECKED_READ(8, buff);
\r
593 if (strncmp((char *)buff, "PicoSMCD", 8) && strncmp((char *)buff, "PicoSEXT", 8))
\r
594 R_ERROR_RETURN("bad header");
\r
595 CHECKED_READ(4, &ver);
\r
597 while (!areaEof(file) && found < to_find)
\r
599 CHECKED_READ(1, buff);
\r
600 CHECKED_READ(4, &len);
\r
601 if (len < 0 || len > 1024*512) R_ERROR_RETURN("bad length");
\r
602 if (buff[0] > CHUNK_FM && buff[0] <= CHUNK_MISC_CD && !(PicoIn.AHW & PAHW_MCD))
\r
603 R_ERROR_RETURN("cd chunk in non CD state?");
\r
607 case CHUNK_VRAM: CHECKED_READ_BUFF(PicoMem.vram); found++; break;
\r
608 case CHUNK_CRAM: CHECKED_READ_BUFF(PicoMem.cram); found++; break;
\r
609 case CHUNK_VSRAM: CHECKED_READ_BUFF(PicoMem.vsram); found++; break;
\r
610 case CHUNK_VIDEO: CHECKED_READ_BUFF(Pico.video); found++; break;
\r
614 if (Pico32xMem != NULL)
\r
615 CHECKED_READ_BUFF(Pico32xMem->dram);
\r
619 if (Pico32xMem != NULL)
\r
620 CHECKED_READ_BUFF(Pico32xMem->pal);
\r
621 Pico32x.dirty_pal = 1;
\r
625 CHECKED_READ_BUFF(Pico32x);
\r
629 areaSeek(file, len, SEEK_CUR);
\r
639 static int pico_state_internal(void *afile, int is_save)
\r
644 ret = state_save(afile);
\r
646 ret = state_load(afile);
\r
651 int PicoState(const char *fname, int is_save)
\r
653 void *afile = NULL;
\r
656 afile = open_save_file(fname, is_save);
\r
660 ret = pico_state_internal(afile, is_save);
\r
665 int PicoStateFP(void *afile, int is_save,
\r
666 arearw *read, arearw *write, areaeof *eof, areaseek *seek)
\r
674 return pico_state_internal(afile, is_save);
\r
677 int PicoStateLoadGfx(const char *fname)
\r
682 afile = open_save_file(fname, 0);
\r
686 ret = state_load_gfx(afile);
\r
689 areaSeek(afile, 0x10020, SEEK_SET); // skip header and RAM
\r
690 areaRead(PicoMem.vram, 1, sizeof(PicoMem.vram), afile);
\r
691 areaSeek(afile, 0x2000, SEEK_CUR);
\r
692 areaRead(PicoMem.cram, 1, sizeof(PicoMem.cram), afile);
\r
693 areaRead(PicoMem.vsram, 1, sizeof(PicoMem.vsram), afile);
\r
694 areaSeek(afile, 0x221a0, SEEK_SET);
\r
695 areaRead(&Pico.video, 1, sizeof(Pico.video), afile);
\r
704 unsigned short vram[0x8000];
\r
705 unsigned short cram[0x40];
\r
706 unsigned short vsram[0x40];
\r
708 //struct PicoMisc m;
\r
709 struct PicoVideo video;
\r
712 struct Pico32x p32x;
\r
713 unsigned short dram[2][0x20000/2];
\r
714 unsigned short pal[0x100];
\r
718 // returns data ptr to free() or PicoTmpStateRestore()
\r
719 void *PicoTmpStateSave(void)
\r
721 // gfx only for now
\r
722 struct PicoTmp *t = malloc(sizeof(*t));
\r
726 memcpy(t->vram, PicoMem.vram, sizeof(PicoMem.vram));
\r
727 memcpy(t->cram, PicoMem.cram, sizeof(PicoMem.cram));
\r
728 memcpy(t->vsram, PicoMem.vsram, sizeof(PicoMem.vsram));
\r
729 memcpy(&t->video, &Pico.video, sizeof(Pico.video));
\r
732 if (PicoIn.AHW & PAHW_32X) {
\r
733 memcpy(&t->t32x.p32x, &Pico32x, sizeof(Pico32x));
\r
734 memcpy(t->t32x.dram, Pico32xMem->dram, sizeof(Pico32xMem->dram));
\r
735 memcpy(t->t32x.pal, Pico32xMem->pal, sizeof(Pico32xMem->pal));
\r
742 void PicoTmpStateRestore(void *data)
\r
744 struct PicoTmp *t = data;
\r
748 memcpy(PicoMem.vram, t->vram, sizeof(PicoMem.vram));
\r
749 memcpy(PicoMem.cram, t->cram, sizeof(PicoMem.cram));
\r
750 memcpy(PicoMem.vsram, t->vsram, sizeof(PicoMem.vsram));
\r
751 memcpy(&Pico.video, &t->video, sizeof(Pico.video));
\r
752 Pico.m.dirtyPal = 1;
\r
755 if (PicoIn.AHW & PAHW_32X) {
\r
756 memcpy(&Pico32x, &t->t32x.p32x, sizeof(Pico32x));
\r
757 memcpy(Pico32xMem->dram, t->t32x.dram, sizeof(Pico32xMem->dram));
\r
758 memcpy(Pico32xMem->pal, t->t32x.pal, sizeof(Pico32xMem->pal));
\r
759 Pico32x.dirty_pal = 1;
\r
764 // vim:shiftwidth=2:ts=2:expandtab
\r