int slot_delete(int slot, int device) { char filename[MAXPATHLEN]; int ret = 0; if (!device) { /* FAT support */ if (slot > 0) { /* remove screenshot */ sprintf(filename,"%s/saves/%s__%d.png", DEFAULT_PATH, rom_filename, slot - 1); remove(filename); sprintf (filename,"%s/saves/%s.gp%d", DEFAULT_PATH, rom_filename, slot - 1); } else sprintf (filename,"%s/saves/%s.srm", DEFAULT_PATH, rom_filename); /* Delete file */ ret = remove(filename); } else { /* Memory Card support */ if (slot > 0) sprintf(filename,"MD-%04X.gp%d", rominfo.realchecksum, slot - 1); else sprintf(filename,"MD-%04X.srm", rominfo.realchecksum); /* Initialise the CARD system */ memset(&SysArea, 0, CARD_WORKAREA); CARD_Init("GENP", "00"); /* CARD slot */ device--; /* Mount CARD */ if (CardMount(device)) { /* Delete file */ ret = CARD_Delete(device,filename); CARD_Unmount(device); } } return ret; }
//--------------------------------------------------------------------------------- int main() { //--------------------------------------------------------------------------------- VIDEO_Init(); rmode = VIDEO_GetPreferredMode(NULL); PAD_Init(); xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode)); VIDEO_Configure(rmode); VIDEO_SetNextFramebuffer(xfb); VIDEO_SetBlack(FALSE); VIDEO_Flush(); VIDEO_WaitVSync(); if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync(); console_init(xfb,20,64,rmode->fbWidth,rmode->xfbHeight,rmode->fbWidth*2); VIDEO_SetNextFramebuffer(xfb); printf("Memory Card Demo\n\n"); while (1) { printf("Insert A card in slot B and press A\n"); do { PAD_ScanPads(); if (PAD_ButtonsDown(0) & PAD_BUTTON_START) PSOreload(); VIDEO_WaitVSync(); } while ( !(PAD_ButtonsDown(0) & PAD_BUTTON_A)); printf("Mounting card ...\n"); CARD_Init("DEMO","00"); int SlotB_error = CARD_Mount(CARD_SLOTB, SysArea, card_removed); printf("slot B code %d\n",SlotB_error); int CardError; if (SlotB_error >= 0) { unsigned int SectorSize = 0; CARD_GetSectorSize(CARD_SLOTB,&SectorSize); printf("Sector size is %d bytes.\n\n",SectorSize); char *CardBuffer = (char *)memalign(32,SectorSize); printf("Starting directory\n"); card_dir CardDir; card_file CardFile; CardError = CARD_FindFirst(CARD_SLOTB, &CardDir, true); bool found = false; while ( CARD_ERROR_NOFILE != CardError ) { printf("%s %s %s\n",CardDir.filename,CardDir.gamecode,CardDir.company); CardError = CARD_FindNext(&CardDir); if ( 0 == strcmp (DemoFileName, (char *)CardDir.filename)) found = true; }; printf("Finished directory\n\n"); if (found) { printf("Test file contains :- \n"); CardError = CARD_Open(CARD_SLOTB ,DemoFileName,&CardFile); CARD_Read(&CardFile,CardBuffer,SectorSize,0); printf("%s\n",CardBuffer); CARD_Close(&CardFile); CARD_Delete(CARD_SLOTB,DemoFileName); } else { printf("writing test file ...\n"); CardError = CARD_Create(CARD_SLOTB ,DemoFileName,SectorSize,&CardFile); if (0 == CardError) { time_t gc_time; gc_time = time(NULL); sprintf(CardBuffer,"This text was written by MemCardDemo\nat %s\n",ctime(&gc_time)); CardError = CARD_Write(&CardFile,CardBuffer,SectorSize,0); CardError = CARD_Close(&CardFile); } } CARD_Unmount(CARD_SLOTB); free(CardBuffer); } } }
int slot_save(int slot, int device) { char filename[MAXPATHLEN]; int filesize, done = 0; int offset = device ? 2112 : 0; u8 *savebuffer; if (slot > 0) { /* allocate buffer */ savebuffer = (u8 *)memalign(32,STATE_SIZE); if (!savebuffer) { GUI_WaitPrompt("Error","Unable to allocate memory !"); return 0; } GUI_MsgBoxOpen("Information","Saving State ...",1); filesize = state_save(&savebuffer[offset]); } else { if (!sram.on) { GUI_WaitPrompt("Error","SRAM is disabled !"); return 0; } /* allocate buffer */ savebuffer = (u8 *)memalign(32,0x10000+offset); if (!savebuffer) { GUI_WaitPrompt("Error","Unable to allocate memory !"); return 0; } GUI_MsgBoxOpen("Information","Saving SRAM ...",1); memcpy(&savebuffer[offset], sram.sram, 0x10000); sram.crc = crc32(0, sram.sram, 0x10000); filesize = 0x10000; } if (!device) { /* FAT support */ if (slot > 0) sprintf(filename, "%s/saves/%s.gp%d", DEFAULT_PATH, rom_filename, slot - 1); else sprintf(filename, "%s/saves/%s.srm", DEFAULT_PATH, rom_filename); /* Open file */ FILE *fp = fopen(filename, "wb"); if (!fp) { GUI_WaitPrompt("Error","Unable to open file !"); free(savebuffer); return 0; } /* Write from buffer (2k blocks) */ while (filesize > FILECHUNK) { fwrite(savebuffer + done, FILECHUNK, 1, fp); done += FILECHUNK; filesize -= FILECHUNK; } /* Write remaining bytes */ fwrite(savebuffer + done, filesize, 1, fp); done += filesize; fclose(fp); } else { /* Memory Card support */ if (slot > 0) sprintf(filename, "MD-%04X.gp%d", rominfo.realchecksum, slot - 1); else sprintf(filename, "MD-%04X.srm", rominfo.realchecksum); /* Initialise the CARD system */ char action[64]; memset(&SysArea, 0, CARD_WORKAREA); CARD_Init("GENP", "00"); /* CARD slot */ device--; /* Attempt to mount the card */ if (!CardMount(device)) { GUI_WaitPrompt("Error","Unable to mount memory card"); free(savebuffer); return 0; } /* Retrieve the sector size */ u32 SectorSize = 0; int CardError = CARD_GetSectorSize(device, &SectorSize); if (!SectorSize) { sprintf(action, "Invalid sector size (%d)", CardError); GUI_WaitPrompt("Error",action); CARD_Unmount(device); free(savebuffer); return 0; } /* Build the output buffer */ char comment[2][32] = { {"Genesis Plus GX"}, {"SRAM Save"} }; strcpy (comment[1], filename); memcpy (&savebuffer[0], &icon, 2048); memcpy (&savebuffer[2048], &comment[0], 64); /* Adjust file size */ filesize += 2112; if (filesize % SectorSize) filesize = ((filesize / SectorSize) + 1) * SectorSize; /* Check if file already exists */ card_file CardFile; if (CARD_Open(device, filename, &CardFile) == CARD_ERROR_READY) { int size = filesize - CardFile.len; CARD_Close(&CardFile); memset(&CardFile,0,sizeof(CardFile)); /* Check file new size */ if (size > 0) { CardError = CARD_Create(device, "TEMP", size, &CardFile); if (CardError) { sprintf(action, "Unable to increase file size (%d)", CardError); GUI_WaitPrompt("Error",action); CARD_Unmount(device); free(savebuffer); return 0; } /* delete temporary file */ CARD_Close(&CardFile); memset(&CardFile,0,sizeof(CardFile)); CARD_Delete(device, "TEMP"); } /* delete previously existing file */ CARD_Delete(device, filename); } /* Create a new file */ CardError = CARD_Create(device, filename, filesize, &CardFile); if (CardError) { sprintf(action, "Unable to create file (%d)", CardError); GUI_WaitPrompt("Error",action); CARD_Unmount(device); free(savebuffer); return 0; } /* Update file informations */ time_t rawtime; time(&rawtime); card_stat CardStatus; CARD_GetStatus(device, CardFile.filenum, &CardStatus); CardStatus.icon_addr = 0x0; CardStatus.icon_fmt = 2; CardStatus.icon_speed = 1; CardStatus.comment_addr = 2048; CardStatus.time = rawtime; CARD_SetStatus(device, CardFile.filenum, &CardStatus); /* Write file sectors */ while (filesize > 0) { CARD_Write(&CardFile, &savebuffer[done], SectorSize, done); filesize -= SectorSize; done += SectorSize; } /* Close file */ CARD_Close(&CardFile); CARD_Unmount(device); } GUI_MsgBoxClose(); free(savebuffer); /* Save screenshot */ if (slot && !device) { sprintf(filename,"%s/saves/%s__%d.png", DEFAULT_PATH, rom_filename, slot - 1); gxSaveScreenshot(filename); } return 1; }
/**************************************************************************** * SaveMCFile * Write savebuffer to Memory Card file ***************************************************************************/ int SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent) { card_file CardFile; card_stat CardStatus; int CardError; unsigned int blocks; unsigned int SectorSize; int byteswritten = 0; int bytesleft = 0; if(datasize <= 0) return 0; // add save icon and comments memmove(buf+sizeof(saveicon)+64, buf, datasize); memcpy(buf, saveicon, sizeof(saveicon)); memcpy(buf+sizeof(saveicon), savecomments, 64); datasize += (sizeof(saveicon)+64); // Try to mount the card CardError = MountMC(slot, NOTSILENT); if (CardError == 0) { // Get Sector Size CARD_GetSectorSize (slot, &SectorSize); // Calculate number of blocks required blocks = (datasize / SectorSize) * SectorSize; if (datasize % SectorSize) blocks += SectorSize; // Delete existing file (if present) memset(&CardStatus, 0, sizeof(card_stat)); CardError = CARD_Open (slot, filename, &CardFile); if(CardError == 0) { CARD_Close (&CardFile); CardError = CARD_Delete(slot, filename); if (CardError) { ErrorPrompt("Unable to delete existing file!"); goto done; } } // Create new file memset(&CardStatus, 0, sizeof(card_stat)); CardError = CARD_Create (slot, filename, blocks, &CardFile); if (CardError) { if (CardError == CARD_ERROR_INSSPACE) ErrorPrompt("Insufficient space to create file!"); else ErrorPrompt("Unable to create card file!"); goto done; } // Now, have an open file handle, ready to send out the data CARD_GetStatus (slot, CardFile.filenum, &CardStatus); CardStatus.icon_addr = 0x0; CardStatus.icon_fmt = 2; CardStatus.icon_speed = 1; CardStatus.comment_addr = 2048; CARD_SetStatus (slot, CardFile.filenum, &CardStatus); bytesleft = blocks; while (bytesleft > 0) { CardError = CARD_Write (&CardFile, buf + byteswritten, SectorSize, byteswritten); if(CardError) { ErrorPrompt("Error writing file!"); byteswritten = 0; break; } bytesleft -= SectorSize; byteswritten += SectorSize; ShowProgress ("Saving...", byteswritten, blocks); } CARD_Close (&CardFile); CancelAction(); if (byteswritten > 0 && GCSettings.VerifySaves) { // Verify the written file if (!VerifyMCFile (buf, slot, filename, byteswritten) ) byteswritten = 0; } done: CARD_Unmount (slot); } free(SysArea); return byteswritten; }
void MC_DeleteMode(int slot) { int memitems, err; int selected = 0; int erase; displaypath = 0; clearRightPane(); DrawText(386,130,"D e l e t e M o d e"); DrawText(386,134,"_____________________"); char msg[1024]; writeStatusBar("Reading memory card... ", ""); /*** Get the directory listing from the memory card ***/ memitems = CardGetDirectory (slot); setfontsize (14); writeStatusBar("Choose a file with UP button or DOWN button ", "Press A button to delete ") ; /*** If it's a blank card, get out of here ***/ if (!memitems) { WaitPrompt ("No saved games to delete !"); } else { while(1) { // TODO: implement showselector selected = ShowSelector(1); if (cancel) { WaitPrompt ("Delete action cancelled !"); return; } //0 = Z or 2 was pressed -> delete the file erase = WaitPromptChoiceAZ("Are you sure you want to delete the file?", "Delete", "Cancel"); if (!erase) { // selected = 1; /*** Delete the file ***/ sprintf(msg, "Deleting \"%s\"", CardList[selected].filename); writeStatusBar(msg,""); //WaitPrompt(msg); /*** Try to mount the card ***/ err = MountCard(slot); if (err < 0) { WaitCardError("MCDel Mount", err); return; /*** Unable to mount the card ***/ } /*** Initialise for this company & gamecode ***/ CARD_SetCompany(CardList[selected].company); CARD_SetGamecode(CardList[selected].gamecode); err = CARD_Delete(slot, (char *) &CardList[selected].filename); if (err < 0) { WaitCardError("MCDel", err); } else { WaitPrompt("Delete complete"); } CARD_Unmount(slot); return; } offsetchanged = true; } } }
/**************************************************************************** * CardWriteFile * * Relies on *GOOD* data being placed in the FileBuffer prior to calling. * See ReadSMBImage ****************************************************************************/ int CardWriteFile (int slot) { char company[4]; char gamecode[6]; char filename[CARD_FILENAMELEN]; int err, ret; u32 SectorSize; int offset; int written; int filelen; char txt[128]; //add null char company[2] = gamecode[4] = 0; memset (SysArea, 0, CARD_WORKAREA); memset(filename, 0, CARD_FILENAMELEN); ExtractGCIHeader(); memcpy(company, &gci.company, 2); memcpy(gamecode, &gci.gamecode, 4); memcpy(filename, &gci.filename, CARD_FILENAMELEN); filelen = gci.filesize8 * 8192; /*** Mount the card ***/ err = MountCard(slot); if (err < 0) { WaitCardError("CardMount", err); return 0; /*** Unable to mount the card ***/ } CARD_GetSectorSize (slot, &SectorSize); /*** Initialise for this company & gamecode ***/ CARD_SetCompany(company); CARD_SetGamecode(gamecode); /*** If this file exists, abort ***/ err = CARD_FindFirst (slot, &CardDir, false); while (err != CARD_ERROR_NOFILE) { if ((memcmp(CardDir.gamecode, &gamecode, 4) == 0) && (memcmp(CardDir.company, &company, 2) == 0) && (strcmp ((char *) CardDir.filename, (char *)filename) == 0)) { /*** Found the file - prompt user ***/ sprintf(txt, "Savegame %s(%s%s) already exists. Overwrite?", (char *)filename, gamecode, company); ret = WaitPromptChoice(txt, "Overwrite", "Cancel"); if (!ret){ sprintf(txt, "Are you -SURE- you want to overwrite %s?", (char *)filename); ret = WaitPromptChoiceAZ(txt, "Overwrite", "Cancel"); if(!ret){ err = CARD_Delete(slot, (char *) &filename); if (err < 0) { WaitCardError("MCDel", err); CARD_Unmount (slot); return 0; } err = CARD_FindFirst (slot, &CardDir, false); continue; } } /*** User canceled - abort ***/ CARD_Unmount (slot); WaitCardError("File already exists", err); return 0; } err = CARD_FindNext (&CardDir); } tryagain: /*** Initialise for this company & gamecode ***/ //Again just in case, as this is very important for propper restoring CARD_SetCompany(company); CARD_SetGamecode(gamecode); /*** Now restore the file from backup ***/ err = CARD_Create (slot, (char *) filename, filelen, &CardFile); if (err < 0) { if (err == CARD_ERROR_EXIST) { /*** Found the file - prompt user ***/ sprintf(txt, "File %s(%s%s) already exists. Overwrite?", (char *) filename, gamecode, company); ret = WaitPromptChoice(txt, "Overwrite", "Cancel"); if (!ret){ sprintf(txt, "Are you -SURE- you want to overwrite %s?", (char *) filename); ret = WaitPromptChoiceAZ(txt, "Overwrite", "Cancel"); if(!ret){ err = CARD_Delete(slot, (char *) &filename); if (err < 0) { WaitCardError("MCDel", err); CARD_Unmount (slot); return 0; } goto tryagain; } } } CARD_Unmount (slot); WaitCardError("CardCreate", err); return 0; } //Thanks to Ralf, validate F-zero and PSO savegames FZEROGX_MakeSaveGameValid(slot); PSO_MakeSaveGameValid(slot); /*** Now write the file data, in sector sized chunks ***/ offset = 0; while (offset < filelen) { if ((offset + SectorSize) <= filelen) { written = CARD_Write (&CardFile, FileBuffer + MCDATAOFFSET + offset + OFFSET, SectorSize, offset); } else { written = CARD_Write (&CardFile, FileBuffer + MCDATAOFFSET + offset + OFFSET, ((offset + SectorSize) - filelen), offset); } offset += SectorSize; } OFFSET = 0; #ifdef STATUSOGC /*** Finally, update the status ***/ CARD_SetStatus (slot, CardFile.filenum, &CardStatus); //For some reason this sets the file to Move->allowed, Copy->not allowed, Public file instead of the actual permission value CARD_SetAttributes(slot, CardFile.filenum, &permission); #else __card_setstatusex(slot, CardFile.filenum, &gci); #endif CARD_Close (&CardFile); CARD_Unmount (slot); return 1; }
/**************************************************************************** * 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 ***/ }
/**************************************************************************** * SaveMCFile * Write savebuffer to Memory Card file ***************************************************************************/ int SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent) { int CardError; unsigned int blocks; unsigned int SectorSize; char msg[80]; if(datasize <= 0) return 0; /*** Initialize Card System ***/ memset (SysArea, 0, CARD_WORKAREA); CARD_Init ("VBA0", "00"); /*** Try to mount the card ***/ CardError = MountCard(slot, NOTSILENT); if (CardError == 0) { /*** Get Sector Size ***/ CARD_GetSectorSize (slot, &SectorSize); /*** Calculate number of blocks required ***/ blocks = (datasize / SectorSize) * SectorSize; if (datasize % SectorSize) blocks += SectorSize; /*** Does this file exist ? ***/ if (CardFileExists (filename, slot)) { /*** Try to open the file ***/ CardError = CARD_Open (slot, filename, &CardFile); if (CardError) { CARD_Unmount (slot); WaitPrompt("Unable to open card file!"); return 0; } if ( (s32)blocks > CardFile.len ) /*** new data is longer ***/ { CARD_Close (&CardFile); /*** Try to create temp file to check available space ***/ CardError = CARD_Create (slot, "TEMPFILESNES9XGX201", blocks, &CardFile); if (CardError) { CARD_Unmount (slot); WaitPrompt("Not enough space to update file!"); return 0; } /*** Delete the temporary file ***/ CARD_Close (&CardFile); CardError = CARD_Delete(slot, "TEMPFILESNES9XGX201"); if (CardError) { CARD_Unmount (slot); WaitPrompt("Unable to delete temporary file!"); return 0; } /*** Delete the existing shorter file ***/ CardError = CARD_Delete(slot, filename); if (CardError) { CARD_Unmount (slot); WaitPrompt("Unable to delete existing file!"); return 0; } /*** Create new, longer file ***/ CardError = CARD_Create (slot, filename, blocks, &CardFile); if (CardError) { CARD_Unmount (slot); WaitPrompt("Unable to create updated card file!"); return 0; } } } else /*** no file existed, create new one ***/ { /*** Create new file ***/ CardError = CARD_Create (slot, filename, blocks, &CardFile); if (CardError) { CARD_Unmount (slot); if ( CardError == CARD_ERROR_INSSPACE ) WaitPrompt("Not enough space to create file!"); else WaitPrompt("Unable to create card file!"); return 0; } } /*** Now, have an open file handle, ready to send out the data ***/ CARD_GetStatus (slot, CardFile.filenum, &CardStatus); CardStatus.icon_addr = 0x0; CardStatus.icon_fmt = 2; CardStatus.icon_speed = 1; CardStatus.comment_addr = 2048; CARD_SetStatus (slot, CardFile.filenum, &CardStatus); int byteswritten = 0; int bytesleft = blocks; while (bytesleft > 0) { CardError = CARD_Write (&CardFile, buf + byteswritten, SectorSize, byteswritten); bytesleft -= SectorSize; byteswritten += SectorSize; sprintf (msg, "Wrote %d of %d bytes", byteswritten, blocks); ShowProgress (msg, byteswritten, blocks); } CARD_Close (&CardFile); CARD_Unmount (slot); if ( GCSettings.VerifySaves ) { /*** Verify the written file, but only up to the length we wrote because the file could be longer due to past writes ***/ if ( VerifyMCFile (buf, slot, filename, byteswritten) ) return byteswritten; else return 0; } else return byteswritten; } else if (slot == CARD_SLOTA) WaitPrompt("Unable to Mount Slot A Memory Card!"); else WaitPrompt("Unable to Mount Slot B Memory Card!"); return 0; }