Ejemplo n.º 1
0
/* Load system state */
int load_state(const char *game_name, int state_slot) {
    char name[0x100];
    FILE *fd = NULL;
    strcpy(name, game_name);
    sprintf(strrchr(name, '.'), ".st%d", state_slot);
    fd = fopen(name, "rb");
    if (!fd) return (0);
    system_load_state(fd);
    fclose(fd);
    return (1);
}
Ejemplo n.º 2
0
/****************************************************************************
 * SDCARD Access functions
 *
 * We use the same buffer as for Memory Card manager
 * Function returns TRUE on success.
 *****************************************************************************/
static int FAT_ManageFile(char *filename, int direction)
{
  char pathname[MAXPATHLEN];
  int done = 0;
  int filesize;

  if (!fat_enabled) return 0;

  /* first check if directory exist */
  sprintf (pathname, "%s/saves", DEFAULT_PATH);

  DIR_ITER *dir = diropen(pathname);
  if (dir == NULL) mkdir(pathname,S_IRWXU);
  else dirclose(dir);

  /* build complete SDCARD filename */
  sprintf (pathname, "%s/%s", pathname, filename);

  /* open file */
  FILE *fp = fopen(pathname, direction ? "rb" : "wb");
  if (fp == NULL)
  {
    sprintf (filename, "Error opening %s", pathname);
    WaitPrompt(filename);
    return 0;
  }

  switch (direction)
  {
    case 0: /* SAVING */
      /* save sate into buffer */
      filesize = system_save_state(savebuffer);

      /* write buffer */
      while (filesize > FATCHUNK)
      {
        fwrite(savebuffer + done, FATCHUNK, 1, fp);
        done+=FATCHUNK;
        filesize-=FATCHUNK;
      }
      fwrite(savebuffer + done, filesize, 1, fp);
      done+=filesize;
      fclose(fp);

      sprintf (filename, "Saved %d bytes successfully", done);
      WaitPrompt (filename);
      return 1;

    case 1: /* LOADING */

      /* read size */
      fseek(fp , 0 , SEEK_END);
      filesize = ftell (fp);
      fseek(fp, 0, SEEK_SET);

      /* read into buffer (32k blocks) */
      while (filesize > FATCHUNK)
      {
        fread(savebuffer + done, FATCHUNK, 1, fp);
        done+=FATCHUNK;
        filesize-=FATCHUNK;
      }
      fread(savebuffer + done, filesize, 1, fp);
      done+=filesize;
      fclose(fp);

      /* load STATE */
      system_load_state(savebuffer);

      sprintf (filename, "Loaded %d bytes successfully", done);
      WaitPrompt (filename);
      return 1;
  }

  return 0; 
}
Ejemplo n.º 3
0
/****************************************************************************
 * ManageState
 *
 * Here is the main Freeze File Management stuff.
 * The output file contains an icon (2K), 64 bytes comment and the STATE (~128k)
 *
 * direction == 0 save, 1 load.
 ****************************************************************************/
int ManageState (u8 direction, u8 device)
{
  if (!smsromsize)
    return 0;

  char filename[MAXJOLIET];

  /* clean buffer */
  memset(savebuffer, 0, 0x12000);

  if (direction)
    ShowAction ("Loading State ...");
  else
    ShowAction ("Saving State ...");

  if (device == 0)
  {
    /* FAT support */
    sprintf (filename, "%s.spz", rom_filename);
    return FAT_ManageFile(filename,direction);
  }

  /* Memory CARD support */
  char action[80];
  int CardError;
  unsigned int SectorSize = 0;
  int blocks;
  char comment[2][32] = { {"SMS Plus 1.3 [FRZ]"}, {"Freeze State"} };
  int outbytes = 0;
  int sbo;
  int state_size = 0;

  /* First, build a filename */
  sprintf (filename, "%08X.spz", (u32)crc32 (0, &cart.rom[0], smsromsize));
  strcpy (comment[1], filename);

  /* set MCARD slot nr. */
  u8 CARDSLOT = device - 1;

  /* Saving */
  if (direction == 0)
  {
    /*** Build the output buffer ***/
    memcpy (&savebuffer, &icon, 2048);
    memcpy (&savebuffer[2048], &comment[0], 64);
    state_size = system_save_state(&savebuffer[2112]);
  }

  outbytes = 2048 + 64 + state_size;

  /*** Initialise the CARD system ***/
  memset (&SysArea, 0, CARD_WORKAREA);
  CARD_Init ("SMSP", "00");

  /*** Attempt to mount the card ***/
  CardError = MountTheCard (CARDSLOT);

  if (CardError)
  {
    /*** Retrieve the sector size ***/
    CardError = CARD_GetSectorSize (CARDSLOT, &SectorSize);

    if (SectorSize)
    {
      switch (direction)
      {
        case 0: /*** Saving ***/
          /*** Determine number of blocks on this card ***/
          blocks = (outbytes / SectorSize) * SectorSize;
          if (outbytes % SectorSize) blocks += SectorSize;

          /*** Check if a previous save exists ***/
          if (CardFileExists (filename,CARDSLOT))
          {
            CardError = CARD_Open (CARDSLOT, filename, &CardFile);
            if (CardError)
            {
              sprintf (action, "Error Open : %d", CardError);
              WaitPrompt (action);
              CARD_Unmount (CARDSLOT);
              return 0;
            }

            int size = CardFile.len;
            CARD_Close (&CardFile);

            if (size < blocks)
            {
              /* new size is bigger: check if there is enough space left */
              CardError = CARD_Create (CARDSLOT, "TEMP", blocks-size, &CardFile);
              if (CardError)
              {
                sprintf (action, "Error Update : %d", CardError);
                WaitPrompt (action);
                CARD_Unmount (CARDSLOT);
                return 0;
              }
              CARD_Close (&CardFile);
              CARD_Delete(CARDSLOT, "TEMP");
            }

            /* always delete existing slot */
            CARD_Delete(CARDSLOT, filename);
          }

          /*** Create a new slot ***/
          CardError = CARD_Create (CARDSLOT, filename, blocks, &CardFile);
          if (CardError)
          {
            sprintf (action, "Error create : %d %d", CardError, CARDSLOT);
            WaitPrompt (action);
            CARD_Unmount (CARDSLOT);
            return 0;
          }

          /*** Continue and save ***/
          CARD_GetStatus (CARDSLOT, CardFile.filenum, &CardStatus);
          CardStatus.icon_addr = 0x0;
          CardStatus.icon_fmt = 2;
          CardStatus.icon_speed = 1;
          CardStatus.comment_addr = 2048;
          CARD_SetStatus (CARDSLOT, CardFile.filenum, &CardStatus);

          /*** And write the blocks out ***/
          sbo = 0;
          while (outbytes > 0)
          {
            CardError = CARD_Write (&CardFile, &savebuffer[sbo], SectorSize, sbo);
            outbytes -= SectorSize;
            sbo += SectorSize;
          }

          CARD_Close (&CardFile);
          CARD_Unmount (CARDSLOT);
          sprintf (action, "Saved %d bytes successfully", blocks);
          WaitPrompt (action);
          return 1;

      default: /*** Loading ***/
        if (!CardFileExists (filename, CARDSLOT))
        {
          WaitPrompt ("No Savestate Found");
          CARD_Unmount (CARDSLOT);
          return 0;
        }

        memset (&CardFile, 0, sizeof (CardFile));
        CardError = CARD_Open (CARDSLOT, filename, &CardFile);
        if (CardError)
        {
          sprintf (action, "Error Open : %d", CardError);
          WaitPrompt (action);
          CARD_Unmount (CARDSLOT);
          return 0;
        }

        blocks = CardFile.len;
        if (blocks < SectorSize) blocks = SectorSize;
        if (blocks % SectorSize) blocks++;

        /*** Just read the file back in ***/
        sbo = 0;
        int size = blocks;
        while (blocks > 0)
        {
          CARD_Read (&CardFile, &savebuffer[sbo], SectorSize, sbo);
          sbo += SectorSize;
          blocks -= SectorSize;
        }
        CARD_Close (&CardFile);
        CARD_Unmount (CARDSLOT);

        /*** Load State ***/
        system_load_state(&savebuffer[2112]);

        /*** Inform user ***/
        sprintf (action, "Loaded %d bytes successfully", size);
        WaitPrompt (action);
        return 1;
      }
    }
    WaitPrompt ("Invalid sector size");
    return 0;
  }
  WaitPrompt ("Unable to mount memory card");
  return 0; /*** Signal failure ***/
}