Exemple #1
0
int cdc_context_load(uint8 *state)
{
  uint8 tmp8;
  int bufferptr = 0;

  load_param(&cdc, sizeof(cdc));
  load_param(&tmp8, 1);

  switch (tmp8)
  {
    case 1:
      cdc.dma_w = pcm_ram_dma_w;
      break;
    case 2:
      cdc.dma_w = prg_ram_dma_w;
      break;
    case 3:
      cdc.dma_w = word_ram_0_dma_w;
      break;
    case 4:
      cdc.dma_w = word_ram_1_dma_w;
      break;
    case 5:
      cdc.dma_w = word_ram_2M_dma_w;
      break;
    default:
      cdc.dma_w = 0;
      break;
  }

  return bufferptr;
}
Exemple #2
0
int sound_context_load(uint8 *state)
{
    int bufferptr = 0;

    if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
    {
        bufferptr = YM2612LoadContext(state);
        YM2612Config(config.dac_bits);
    }
    else
    {
        load_param(YM2413GetContextPtr(),YM2413GetContextSize());
    }

    load_param(SN76489_GetContextPtr(),SN76489_GetContextSize());

    load_param(&fm_cycles_start,sizeof(fm_cycles_start));
    fm_cycles_count = fm_cycles_start;

    return bufferptr;
}
Exemple #3
0
int main(int argc, char *argv[])
{  FILE *pdb_fp, *fp;
   PROT prot;
 
   
   db_open();
   if (get_env()) {
      printf("   This program needs run.prm in working directory.\n");
      return USERERR;
   }

   if (argc < 2) {
      printf("surfmcce mcce_pdb_file\n");
      return 0;
   }

   /* load parameters */
   if ((fp=fopen(env.new_tpl, "r"))) {
      fclose(fp);
      load_param(env.new_tpl);
      printf("%s loaded.\n",env.new_tpl);
   }
   if (strlen(env.param)) {
      if (load_all_param(env.param)) {
         printf("   Can't load parameter files in %s\n",env.param);
         return USERERR;
      }
   }
   
   /* load pdb */
   if ((pdb_fp=fopen(argv[1], "r"))) {
      prot = load_pdb(pdb_fp);
      fclose(pdb_fp);
      if (prot.n_res == 0) {
         printf("   Fail to load pdb file: %s\n",STEP2_OUT);
         return USERERR;
      }
   }
   else {
      printf("   Specified PDB file \"%s\" was not found\n",argv[1]);
      return USERERR;
   }
   
   surfw(prot, 1.4);
   print_surfw(prot);
   
   return 0;
}
Exemple #4
0
int pcm_context_load(uint8 *state)
{
  uint8 tmp8;
  int bufferptr = 0;

  load_param(pcm.chan, sizeof(pcm.chan));
  load_param(pcm.out, sizeof(pcm.out));

  load_param(&tmp8, 1);
  pcm.bank = &pcm.ram[(tmp8 & 0x0f) << 12];

  load_param(&pcm.enabled, sizeof(pcm.enabled));
  load_param(&pcm.status, sizeof(pcm.status));
  load_param(&pcm.index, sizeof(pcm.index));
  load_param(pcm.ram, sizeof(pcm.ram));

  return bufferptr;
}
Exemple #5
0
int state_load(unsigned char *buffer)
{
  /* buffer size */
  int bufferptr = 0;

  /* uncompress savestate */
  unsigned long inbytes, outbytes;
  memcpy(&inbytes, buffer, 4);
  outbytes = STATE_SIZE;
  uncompress ((Bytef *)state, &outbytes, (Bytef *)(buffer + 4), inbytes);

  /* version check */
  char version[16];
  load_param(version,16);
  if (strncmp(version,STATE_VERSION,16))
  {
    return 0;
  }

  /* reset system */
  system_reset();
  m68k_memory_map[0].base = default_rom;

  // GENESIS
  load_param(work_ram, sizeof(work_ram));
  load_param(zram, sizeof(zram));
  load_param(&zbusreq, sizeof(zbusreq));
  load_param(&zreset, sizeof(zreset));
  load_param(&zbank, sizeof(zbank));
  zbusack = 1 ^(zbusreq & zreset);

  // IO
  load_param(io_reg, sizeof(io_reg));

  // VDP
  uint8 temp_reg[0x20];
  load_param(sat, sizeof(sat));
  load_param(vram, sizeof(vram));
  load_param(cram, sizeof(cram));
  load_param(vsram, sizeof(vsram));
  load_param(temp_reg, sizeof(temp_reg));
  load_param(&addr, sizeof(addr));
  load_param(&addr_latch, sizeof(addr_latch));
  load_param(&code, sizeof(code));
  load_param(&pending, sizeof(pending));
  load_param(&status, sizeof(status));
  load_param(&dmafill, sizeof(dmafill));
  load_param(&hint_pending, sizeof(hint_pending));
  load_param(&vint_pending, sizeof(vint_pending));
  load_param(&irq_status, sizeof(irq_status));
  vdp_restore(temp_reg);

  // FM 
  YM2612Restore(&state[bufferptr]);
  bufferptr+= YM2612GetContextSize();

  // PSG
  load_param(SN76489_GetContextPtr(),SN76489_GetContextSize());

  // 68000 
  uint16 tmp16;
  uint32 tmp32;
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);  
  load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
  load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);

  // Z80 
  load_param(&Z80, sizeof(Z80_Regs));

  return 1;
}
Exemple #6
0
int cdd_context_load(uint8 *state)
{
  int lba;
  int bufferptr = 0;

#ifdef USE_LIBTREMOR
#ifdef DISABLE_MANY_OGG_OPEN_FILES
  /* close previous track VORBIS file structure to save memory */
  if (cdd.toc.tracks[cdd.index].vf.datasource)
  {
    ogg_free(cdd.index);
  }
#endif
#endif

  load_param(&cdd.cycles, sizeof(cdd.cycles));
  load_param(&cdd.latency, sizeof(cdd.latency));
  load_param(&cdd.index, sizeof(cdd.index));
  load_param(&cdd.lba, sizeof(cdd.lba));
  load_param(&cdd.scanOffset, sizeof(cdd.scanOffset));
  load_param(&cdd.volume, sizeof(cdd.volume));
  load_param(&cdd.status, sizeof(cdd.status));

  /* adjust current LBA within track limit */
  lba = cdd.lba;
  if (lba < cdd.toc.tracks[cdd.index].start)
  {
    lba = cdd.toc.tracks[cdd.index].start;
  }

  /* seek to current track position */
  if (!cdd.index)
  {
    /* DATA track */
    if (cdd.toc.tracks[0].fd)
    {
      pm_seek(cdd.toc.tracks[0].fd, lba * cdd.sectorSize, SEEK_SET);
    }
  }
#ifdef USE_LIBTREMOR
  else if (cdd.toc.tracks[cdd.index].vf.seekable)
  {
#ifdef DISABLE_MANY_OGG_OPEN_FILES
    /* VORBIS file need to be opened first */
    ov_open(cdd.toc.tracks[cdd.index].fd,&cdd.toc.tracks[cdd.index].vf,0,0);
#endif
    /* VORBIS AUDIO track */
    ov_pcm_seek(&cdd.toc.tracks[cdd.index].vf, (lba - cdd.toc.tracks[cdd.index].start) * 588 - cdd.toc.tracks[cdd.index].offset);
  }
#endif
#if 0
  else if (cdd.toc.tracks[cdd.index].fd)
  {
    /* PCM AUDIO track */
    fseek(cdd.toc.tracks[cdd.index].fd, (lba * 2352) - cdd.toc.tracks[cdd.index].offset, SEEK_SET);
  }
#else
  else
  {
    cdd_change_track(cdd.index, lba);
  }
#endif

  return bufferptr;
}
int state_load(unsigned char *buffer)
{
  /* buffer size */
  int bufferptr = 0;

  /* first allocate state buffer */
  unsigned char *state = (unsigned char *)malloc(STATE_SIZE);
  if (!state) return 0;

  /* uncompress savestate */
  unsigned long inbytes, outbytes;
  memcpy(&inbytes, buffer, 4);
  outbytes = STATE_SIZE;
  uncompress ((Bytef *)state, &outbytes, (Bytef *)(buffer + 4), inbytes);

  /* signature check (GENPLUS-GX x.x.x) */
  char version[17];
  load_param(version,16);
  version[16] = 0;
  if (strncmp(version,STATE_VERSION,11))
  {
    free(state);
    return -1;
  }

  /* version check (1.5.0 and above) */
  if ((version[11] < 0x31) || ((version[11] == 0x31) && (version[13] < 0x35)))
  {
    free(state);
    return -1;
  }

  /* reset system */
  system_reset();

  // GENESIS
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {
    load_param(work_ram, sizeof(work_ram));
    load_param(zram, sizeof(zram));
    load_param(&zstate, sizeof(zstate));
    load_param(&zbank, sizeof(zbank));
    if (zstate == 3)
    {
      m68k_memory_map[0xa0].read8   = z80_read_byte;
      m68k_memory_map[0xa0].read16  = z80_read_word;
      m68k_memory_map[0xa0].write8  = z80_write_byte;
      m68k_memory_map[0xa0].write16 = z80_write_word;
    }
    else
    {
      m68k_memory_map[0xa0].read8   = m68k_read_bus_8;
      m68k_memory_map[0xa0].read16  = m68k_read_bus_16;
      m68k_memory_map[0xa0].write8  = m68k_unused_8_w;
      m68k_memory_map[0xa0].write16 = m68k_unused_16_w;
    }
  }
  else
  {
    load_param(work_ram, 0x2000);
  }

  /* extended state */
  load_param(&mcycles_68k, sizeof(mcycles_68k));
  load_param(&mcycles_z80, sizeof(mcycles_z80));

  // IO
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {
    load_param(io_reg, sizeof(io_reg));
    io_reg[0] = region_code | 0x20 | (config.tmss & 1);
  }
  else
  {
    load_param(&io_reg[0x0F], 1);
  }

  // VDP
  bufferptr += vdp_context_load(&state[bufferptr], version);

  // SOUND 
  bufferptr += sound_context_load(&state[bufferptr], version);

  // 68000 
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {
    uint16 tmp16;
    uint32 tmp32;
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);  
    load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);
  }

  // Z80 
  load_param(&Z80, sizeof(Z80_Regs));
  Z80.irq_callback = z80_irq_callback;

  // Cartridge HW
  if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
  {  
    bufferptr += md_cart_context_load(&state[bufferptr]);
  }
  else
  {
    bufferptr += sms_cart_context_load(&state[bufferptr]);
  }

  free(state);
  return 1;
}
Exemple #8
0
int state_load_old(unsigned char *state)
{
	int i, bufferptr = 0x10;

	/* reset system */
	system_reset();

	// GENESIS
	if (system_hw == SYSTEM_PBC || system_hw == SYSTEM_GAMEGEAR) {
		load_param(work_ram, 0x2000);
	} else {
		load_param(work_ram, sizeof(work_ram));
		load_param(zram, sizeof(zram));
		load_param(&zstate, sizeof(zstate));
		load_param(&zbank, sizeof(zbank));
		if (zstate == 3) {
			m68k_memory_map[0xa0].read8 = z80_read_byte;
			m68k_memory_map[0xa0].read16 = z80_read_word;
			m68k_memory_map[0xa0].write8 = z80_write_byte;
			m68k_memory_map[0xa0].write16 = z80_write_word;
		} else {
			m68k_memory_map[0xa0].read8 = m68k_read_bus_8;
			m68k_memory_map[0xa0].read16 = m68k_read_bus_16;
			m68k_memory_map[0xa0].write8 = m68k_unused_8_w;
			m68k_memory_map[0xa0].write16 = m68k_unused_16_w;
		}
	}

	// IO
	if (system_hw == SYSTEM_PBC || system_hw == SYSTEM_GAMEGEAR) {
		load_param(&io_reg[0xf], 1);
		bufferptr+=0x10-1;
	} else {
		load_param(io_reg, sizeof(io_reg));
		io_reg[0] = region_code | 0x20 | (config.tmss & 1);
	}

	  /* VDP */
	  bufferptr += vdp_context_load_old(&state[bufferptr]);

	  /* SOUND */
	  bufferptr += sound_context_load(&state[bufferptr]);

	  /* 68000 */
	  if (system_hw != SYSTEM_PBC && system_hw != SYSTEM_GAMEGEAR)
	  {
	    uint16 tmp16;
	    uint32 tmp32;
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D0, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D1, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D2, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D3, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D4, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D5, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D6, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_D7, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A0, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A1, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A2, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A3, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A4, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A5, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A6, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_A7, tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_PC, tmp32);
	    load_param(&tmp16, 2); m68k_set_reg(M68K_REG_SR, tmp16);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_USP,tmp32);
	    load_param(&tmp32, 4); m68k_set_reg(M68K_REG_ISP,tmp32);

	  	load_param(&mcycles_68k, sizeof(mcycles_68k));
	  	load_param(&tmp32, 4);
	  	m68k_irq_state = tmp32 >> 8;
	    bufferptr += 4; // skip m68k.stopped
	  }
Exemple #9
0
int psg_context_load(uint8 *state)
{
  int delta[2];
  int i, bufferptr = 0;

  /* initialize delta with current noise channel output */
  if (psg.noiseShiftValue & 1)
  {
    delta[0] = -psg.chanOut[3][0];
    delta[1] = -psg.chanOut[3][1];
  }
  else
  {
    delta[0] = 0;
    delta[1] = 0;
  }

  /* add current tone channels output */
  for (i=0; i<3; i++)
  {
    if (psg.polarity[i] > 0)
    {
      delta[0] -= psg.chanOut[i][0];
      delta[1] -= psg.chanOut[i][1];
    }
  }

  load_param(&psg.clocks,sizeof(psg.clocks));
  load_param(&psg.latch,sizeof(psg.latch));
  load_param(&psg.noiseShiftValue,sizeof(psg.noiseShiftValue));
  load_param(psg.regs,sizeof(psg.regs));
  load_param(psg.freqInc,sizeof(psg.freqInc));
  load_param(psg.freqCounter,sizeof(psg.freqCounter));
  load_param(psg.polarity,sizeof(psg.polarity));
  load_param(psg.chanOut,sizeof(psg.chanOut));

  /* add noise channel output variation */
  if (psg.noiseShiftValue & 1)
  {
    delta[0] += psg.chanOut[3][0];
    delta[1] += psg.chanOut[3][1];
  }

  /* add tone channels output variation */
  for (i=0; i<3; i++)
  {
    if (psg.polarity[i] > 0)
    {
      delta[0] += psg.chanOut[i][0];
      delta[1] += psg.chanOut[i][1];
    }
  }

  /* update mixed channels output */
  if (config.hq_psg)
  {
    blip_add_delta(snd.blips[0], psg.clocks, delta[0], delta[1]);
  }
  else
  {
    blip_add_delta_fast(snd.blips[0], psg.clocks, delta[0], delta[1]);
  }

  return bufferptr;
}