ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ImportFile and RemoveFile "fixed", should not cause corruption anymore, but still needs more work 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1098 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
LPFaint99 2008-11-08 20:34:43 +00:00
parent 8684b734e8
commit d2bbd6bda2
4 changed files with 350 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
Source/Core/DolphinWX/Src/MemcardManager.cpp
View File

@ -72,8 +72,8 @@ wxBitmap wxBitmapFromMemoryRGBA(const unsigned char* data, int width, int height
BEGIN_EVENT_TABLE(CMemcardManager, wxDialog)
EVT_CLOSE(CMemcardManager::OnClose)
EVT_BUTTON(ID_COPYLEFT,CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_COPYRIGHT,CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_COPYTOLEFT,CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_COPYTORIGHT,CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_FIXCHECKSUM,CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_DELETELEFT,CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_DELETERIGHT,CMemcardManager::CopyDeleteClick)
@ -111,8 +111,8 @@ CMemcardManager::~CMemcardManager()
void CMemcardManager::CreateGUIControls()
{
// buttons
m_CopyLeft = new wxButton(this, ID_COPYLEFT, wxT("<-Copy<-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
m_CopyRight = new wxButton(this, ID_COPYRIGHT, wxT("->Copy->"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
m_CopyToLeft = new wxButton(this, ID_COPYTOLEFT, wxT("<-Copy<-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
m_CopyToRight = new wxButton(this, ID_COPYTORIGHT, wxT("->Copy->"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
m_FixChecksum = new wxButton(this, ID_FIXCHECKSUM, wxT("<-Fix\nChecksum"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
@ -150,8 +150,8 @@ void CMemcardManager::CreateGUIControls()
wxBoxSizer* sButtons;
sButtons = new wxBoxSizer(wxVERTICAL);
sButtons->AddStretchSpacer(2);
sButtons->Add(m_CopyLeft, 0, wxEXPAND, 5);
sButtons->Add(m_CopyRight, 0, wxEXPAND, 5);
sButtons->Add(m_CopyToLeft, 0, wxEXPAND, 5);
sButtons->Add(m_CopyToRight, 0, wxEXPAND, 5);
sButtons->AddStretchSpacer(1);
sButtons->Add(m_FixChecksum, 0, wxEXPAND, 5);
sButtons->AddStretchSpacer(1);
@ -206,22 +206,25 @@ void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
int index1 = m_MemcardList[1]->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
int slot = 1;
int index2 = index1;
char * fileName2 = NULL;
std::string fileName2("");
int freeblocks = 0;
switch (event.GetId())
{
case ID_COPYLEFT:
slot=0;
index2 = index0;
case ID_COPYRIGHT:
if ((index2 != -1) && (memoryCard[slot] != NULL))
case ID_COPYTOLEFT:
if ((index1 != -1) && (memoryCard[0] != NULL))
{
int slot2;
slot == 0 ? slot2=1:slot2=0;
memoryCard[slot]->CopyFrom(*memoryCard[slot2], index2);
memoryCard[slot]->Save();
slot == 1 ? ReloadMemcard(m_Memcard2Path->GetPath().mb_str(), 1)
: ReloadMemcard(m_Memcard1Path->GetPath().mb_str(), 0);
memoryCard[0]->CopyFrom(*memoryCard[1], index1);
memoryCard[0]->Save();
ReloadMemcard(m_Memcard1Path->GetPath().mb_str(), 0);
}
break;
case ID_COPYTORIGHT:
if ((index0 != -1) && (memoryCard[1] != NULL))
{
memoryCard[1]->CopyFrom(*memoryCard[0], index0);
memoryCard[1]->Save();
ReloadMemcard(m_Memcard2Path->GetPath().mb_str(), 1);
}
break;
case ID_FIXCHECKSUM:
@ -234,11 +237,12 @@ void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
}
break;
case ID_CONVERTTOGCI:
fileName2 = new char;
fileName2 = "convert";
case ID_SAVEIMPORTLEFT:
slot = 0;
case ID_SAVEIMPORTRIGHT:
if (memoryCard[slot] != NULL || fileName2 != NULL)
if (memoryCard[slot] != NULL || !fileName2.empty())
{
wxString temp = wxFileSelector(_T("Select the GCI file to import"),
wxEmptyString, wxEmptyString, wxEmptyString,wxString::Format
@ -252,7 +256,7 @@ void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
),
wxFD_OPEN | wxFD_FILE_MUST_EXIST);
const char * fileName = temp.ToAscii();
if (*fileName2 != NULL && !temp.empty())
if (!temp.empty() && !fileName2.empty())
{
wxString temp2 = wxFileSelector(_T("Save GCI as.."),
wxEmptyString, wxEmptyString, _T(".gci"), wxString::Format
@ -262,8 +266,7 @@ void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
wxFileSelectorDefaultWildcardStr
),
wxFD_OVERWRITE_PROMPT|wxFD_SAVE);
delete fileName2;
fileName2 = (char*)temp2.ToAscii();
fileName2 = temp2.mb_str();
}
if (temp.length() > 0)
{
@ -288,6 +291,26 @@ void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
" does not have a valid extension"), wxT("Error"),
wxOK|wxICON_ERROR);
break;
case GCS:
wxMessageBox(wxT("File converted to .gci"),
wxT("Success"),wxOK);
break;
case OUTOFBLOCKS:
freeblocks = BE16(memoryCard[slot]->bat.FreeBlocks);
{
wxString Foobar;
Foobar.Printf("Only %d blocks available", freeblocks);
wxMessageBox(Foobar,wxT("Failure"),wxOK);
}
break;
case OUTOFDIRENTRIES:
wxMessageBox(wxT("No free dir index entries"),
wxT("Failure"),wxOK);
break;
case NOMEMCARD:
wxMessageBox(wxT("File is not recognized as a memcard"),
wxT("Failure"),wxOK);
break;
default:
memoryCard[slot]->Save();
slot == 1 ? ReloadMemcard(m_Memcard2Path->GetPath().mb_str(), 1)

12
Source/Core/DolphinWX/Src/MemcardManager.h
View File

@ -26,7 +26,7 @@
#include <wx/imaglist.h>
#include "MemoryCards/GCMemcard.h"
#define BE16(x) ((u16((x)[0])<<8) | u16((x)[1]))
#undef MEMCARD_MANAGER_STYLE
#define MEMCARD_MANAGER_STYLE wxCAPTION | wxSYSTEM_MENU | wxDIALOG_NO_PARENT | wxCLOSE_BOX | wxRESIZE_BORDER | wxMAXIMIZE_BOX
@ -35,7 +35,7 @@ class CMemcardManager
{
public:
CMemcardManager(wxWindow *parent, wxWindowID id = 1, const wxString& title = wxT("Memory Card Manager WARNING-Make backups before using, will probably mangle stuff!"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = MEMCARD_MANAGER_STYLE);
CMemcardManager(wxWindow *parent, wxWindowID id = 1, const wxString& title = wxT("Memory Card Manager WARNING-Make backups before using, should be fixed but could mangle stuff!"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = MEMCARD_MANAGER_STYLE);
virtual ~CMemcardManager();
private:
@ -43,8 +43,8 @@ class CMemcardManager
DECLARE_EVENT_TABLE();
wxBoxSizer *sMain;
wxButton *m_CopyLeft;
wxButton *m_CopyRight;
wxButton *m_CopyToLeft;
wxButton *m_CopyToRight;
wxButton *m_FixChecksum;
wxButton *m_SaveImportLeft;
wxButton *m_SaveExportLeft;
@ -62,8 +62,8 @@ class CMemcardManager
enum
{
ID_COPYRIGHT = 1000,
ID_COPYLEFT,
ID_COPYTORIGHT = 1000,
ID_COPYTOLEFT,
ID_FIXCHECKSUM,
ID_DELETERIGHT,
ID_DELETELEFT,

300
Source/Core/DolphinWX/Src/MemoryCards/GCMemcard.cpp
View File

@ -20,7 +20,6 @@
#endif
#include <assert.h>
#include <stdio.h>
#include "wx/ffile.h"
#include "GCMemcard.h"
@ -76,7 +75,7 @@ u32 GCMemcard::GetNumFiles()
{
if (!mcdFile) return 0;
int j = 0;
for(int i=0;i<126;i++)
for (int i = 0; i < 127; i++)
{
if (BE32(dir.Dir[i].Gamecode)!= 0xFFFFFFFF)
j++;
@ -92,133 +91,75 @@ bool GCMemcard::RemoveFile(u32 index) //index in the directory array
dir_backup = dir;
bat_backup = bat;
int totalspace = (((u32)BE16(hdr.Size)*16)-5);
//free the blocks
int blocks_left = BE16(dir.Dir[index].BlockCount);
int block = BE16(dir.Dir[index].FirstBlock);
do
bat.LastAllocated[0] = (u8)((block - 1) >> 8);
bat.LastAllocated[1] = (u8)(block - 1);
int i = index + 1;
memset(&(dir.Dir[index]), 0xFF, 0x40);
while (i < 127)
{
int cbi = block-5;
int nextblock=bswap16(bat.Map[cbi]);
//assert(nextblock!=0);
if(nextblock==0)
DEntry * d = new DEntry;
GetFileInfo(i, *d);
u8 *t = NULL;
//Only get file data if it is a valid dir entry
if (BE16(d->FirstBlock) != 0xFFFF)
{
nextblock = block+1;
u16 freeBlock= BE16(bat.FreeBlocks) - BE16(d->BlockCount);
bat.FreeBlocks[0] = u8(freeBlock >> 8);
bat.FreeBlocks[1] = u8(freeBlock);
t = new u8[GetFileSize(i) * 0x2000];
if (!GetFileData(i, t, true))
{
delete[] t;
}
}
memset(&(dir.Dir[i]), 0xFF, 0x40);
//Only call import file if Get File Data returns true
if (t)
{
ImportFile(*d, t, blocks_left);
delete[] t;
}
delete d;
i++;
}
bat.Map[cbi]=0;
block=nextblock;
blocks_left--;
}
while((block!=0xffff)&&(blocks_left>0));
//delete directory entry
for(int i=index;i<125;i++)
{
dir.Dir[i]=dir.Dir[i+1];
}
memset(&(dir.Dir[125]),0xFF,sizeof(DEntry));
//pack blocks to remove free space partitioning, assume no fragmentation.
u8 *mc_data2 = new u8[mc_data_size];
int firstFree=0;
for(int i=0;i<126;i++)
{
if(BE32(dir.Dir[i].Gamecode)==0xFFFFFFFF)
{
break;
}
int fb = BE16(dir.Dir[i].FirstBlock);
int bc = BE16(dir.Dir[i].BlockCount);
u8* src = mc_data + (fb-5)*0x2000;
u8* dst = mc_data2 + firstFree*0x2000;
memcpy(dst,src,bc*0x2000);
for(int j=0;j<bc;j++)
{
bat.Map[firstFree+j] = bswap16(u16(firstFree+j+6));
}
bat.Map[firstFree+bc-1] = 0xFFFF;
dir.Dir[i].FirstBlock[0] = u8((firstFree+5)>>8);
dir.Dir[i].FirstBlock[1] = u8((firstFree+5));
firstFree += bc;
}
for(int j=firstFree;j<totalspace;j++)
{
bat.Map[j] = 0;
}
firstFree+=4;
bat.LastAllocated[0] = u8(firstFree>>8);
bat.LastAllocated[1] = u8(firstFree);
delete [] mc_data;
mc_data = mc_data2;
//--
//update freespace counter
int freespace1 = totalspace - firstFree;
bat.FreeBlocks[0] = u8(freespace1>>8);
bat.FreeBlocks[1] = u8(freespace1);
// ... and update counter
// increment update counter
int updateCtr = BE16(dir.UpdateCounter) + 1;
dir.UpdateCounter[0] = u8(updateCtr >> 8);
dir.UpdateCounter[1] = u8(updateCtr);
//fix checksums
u16 csum1=0,csum2=0;
calc_checksumsBE((u16*)&dir,0xFFE,&csum1,&csum2);
dir.CheckSum1[0]=u8(csum1>>8);
dir.CheckSum1[1]=u8(csum1);
dir.CheckSum2[0]=u8(csum2>>8);
dir.CheckSum2[1]=u8(csum2);
calc_checksumsBE((u16*)(((u8*)&bat)+4),0xFFE,&csum1,&csum2);
bat.CheckSum1[0]=u8(csum1>>8);
bat.CheckSum1[1]=u8(csum1);
bat.CheckSum2[0]=u8(csum2>>8);
bat.CheckSum2[1]=u8(csum2);
dir_backup=dir;
bat_backup=bat;
FixChecksums();
Save();
return true;
}
u32 GCMemcard::ImportFile(DEntry& direntry, u8* contents)
u32 GCMemcard::ImportFile(DEntry& direntry, u8* contents, int remove)
{
if(!mcdFile) return 0;
// TODO: add a check for existing game id
// so that only one save per title is allowed
// until then any particular title will always use the first save
if (!mcdFile) return NOMEMCARD;
if (GetNumFiles() >= 127)
{
return OUTOFDIRENTRIES;
}
if (BE16(bat.FreeBlocks) < BE16(direntry.BlockCount))
{
return 0;
return OUTOFBLOCKS;
}
// find first free data block -- assume no freespace fragmentation
int totalspace = (((u32)BE16(hdr.Size) * 16) - 5);
int firstFree1 = BE16(bat.LastAllocated) + 1;
int firstFree2 = 0;
for(int i=0;i<totalspace;i++)
{
if(bat.Map[i]==0)
{
firstFree2=i+5;
break;
}
}
int firstFree3 = 0;
for (int i = 0; i < 126; i++)
{
if (BE32(dir.Dir[i].Gamecode) == 0xFFFFFFFF)
@ -227,15 +168,11 @@ u32 GCMemcard::ImportFile(DEntry& direntry, u8* contents)
}
else
{
firstFree3 = max<int>(firstFree3,(int)(BE16(dir.Dir[i].FirstBlock) + BE16(dir.Dir[i].BlockCount)));
firstFree2 = max<int>(firstFree2,
(int)(BE16(dir.Dir[i].FirstBlock) + BE16(dir.Dir[i].BlockCount)));
}
}
firstFree1 = max<int>(firstFree1, max<int>(firstFree3, firstFree2));
if(firstFree1>=126)
{
// TODO: show messagebox about the error
return 0;
}
firstFree1 = max<int>(firstFree1, firstFree2);
// find first free dir entry
int index = -1;
@ -247,7 +184,11 @@ u32 GCMemcard::ImportFile(DEntry& direntry, u8* contents)
dir.Dir[i] = direntry;
dir.Dir[i].FirstBlock[0] = u8(firstFree1 >> 8);
dir.Dir[i].FirstBlock[1] = u8(firstFree1);
if (!remove)
{
dir.Dir[i].CopyCounter = dir.Dir[i].CopyCounter+1;
}
dir_backup = dir;
break;
}
}
@ -257,42 +198,71 @@ u32 GCMemcard::ImportFile(DEntry& direntry, u8* contents)
int fileBlocks = BE16(direntry.BlockCount);
memcpy(destination, contents, 0x2000 * fileBlocks);
bat_backup = bat;
u16 last = BE16(bat_backup.LastAllocated);
u16 i = (last - 4);
int j = 2;
while(j < BE16(direntry.BlockCount) + 1)
{
bat_backup.Map[i] = bswap16(last + (u16)j);
i++;
j++;
}
bat_backup.Map[i++] = 0xFFFF;
//Set bat.map to 0 for each block that was removed
for (int j = 0; j < remove; j++)
{
bat_backup.Map[i++] = 0x0000;
}
//update last allocated block
int lastallocated = BE16(bat_backup.LastAllocated) + j - 1;
bat_backup.LastAllocated[0] = u8(lastallocated >> 8);
bat_backup.LastAllocated[1] = u8(lastallocated);
//update freespace counter
int freespace1 = totalspace - firstFree1;
bat.FreeBlocks[0] = u8(freespace1>>8);
bat.FreeBlocks[1] = u8(freespace1);
int freespace1 = totalspace - firstFree1 - fileBlocks + 5;
bat_backup.FreeBlocks[0] = u8(freespace1 >> 8);
bat_backup.FreeBlocks[1] = u8(freespace1);
// ... and update counter
int updateCtr = BE16(dir.UpdateCounter)+1;
dir.UpdateCounter[0] = u8(updateCtr>>8);
dir.UpdateCounter[1] = u8(updateCtr);
//fix checksums
u16 csum1=0,csum2=0;
calc_checksumsBE((u16*)&dir,0xFFE,&csum1,&csum2);
dir.CheckSum1[0]=u8(csum1>>8);
dir.CheckSum1[1]=u8(csum1);
dir.CheckSum2[0]=u8(csum2>>8);
dir.CheckSum2[1]=u8(csum2);
calc_checksumsBE((u16*)(((u8*)&bat)+4),0xFFE,&csum1,&csum2);
bat.CheckSum1[0]=u8(csum1>>8);
bat.CheckSum1[1]=u8(csum1);
bat.CheckSum2[0]=u8(csum2>>8);
bat.CheckSum2[1]=u8(csum2);
if (!remove)
{ // ... and dir update counter
int updateCtr = BE16(dir_backup.UpdateCounter) + 1;
dir_backup.UpdateCounter[0] = u8(updateCtr>>8);
dir_backup.UpdateCounter[1] = u8(updateCtr);
// ... and bat update counter
updateCtr = BE16(bat_backup.UpdateCounter) + 1;
bat_backup.UpdateCounter[0] = u8(updateCtr>>8);
bat_backup.UpdateCounter[1] = u8(updateCtr);
}
bat = bat_backup;
if (!remove)
{
FixChecksums();
Save();
}
return fileBlocks;
}
bool GCMemcard::GetFileData(u32 index, u8*dest) //index in the directory array
bool GCMemcard::GetFileData(u32 index, u8*dest, bool old) //index in the directory array
{
if (!mcdFile) return false;
if (!old)
{
int block = BE16(dir.Dir[index].FirstBlock);
int saveLength = BE16(dir.Dir[index].BlockCount) * 2000;
memcpy(dest,mc_data + 0x2000*(block-5), saveLength);
}
else
{
int block = BE16(dir.Dir[index].FirstBlock);
int saveLength = BE16(dir.Dir[index].BlockCount);
int memcardSize = BE16(hdr.Size) * 0x0010;
assert((block!=0xFFFF)&&(block>0));
assert(block != 0xFFFF);
assert(block > 0);
do
{
memcpy(dest,mc_data + 0x2000 * (block - 5), 0x2000);
@ -306,7 +276,7 @@ bool GCMemcard::GetFileData(u32 index, u8*dest) //index in the directory array
else block = 0xffff;
}
while (block != 0xffff);
}
return true;
}
@ -344,7 +314,6 @@ bool GCMemcard::GetComment1(u32 index, char *fn) //index in the directory array
fn[0] = 0;
return false;
}
memcpy(fn, mc_data + (DataBlock * 0x2000) + Comment1, 32);
fn[31] = 0;
return true;
@ -362,7 +331,6 @@ bool GCMemcard::GetComment2(u32 index, char *fn) //index in the directory array
fn[0] = 0;
return false;
}
memcpy(fn, mc_data + (DataBlock * 0x2000) + Comment2, 32);
fn[31] = 0;
return true;
@ -558,7 +526,8 @@ u32 GCMemcard::TestChecksums()
{
if (!mcdFile) return 0xFFFFFFFF;
u16 csum1=0,csum2=0;
u16 csum1=0,
csum2=0;
u32 results = 0;
@ -589,7 +558,8 @@ bool GCMemcard::FixChecksums()
{
if (!mcdFile) return false;
u16 csum1=0,csum2=0;
u16 csum1=0,
csum2=0;
calc_checksumsBE((u16*)&hdr, 0xFE, &csum1, &csum2);
hdr.CheckSum1[0] = u8(csum1 >> 8);
@ -623,7 +593,6 @@ bool GCMemcard::FixChecksums()
return true;
}
u32 GCMemcard::CopyFrom(GCMemcard& source, u32 index)
{
if (!mcdFile) return 0;
@ -633,17 +602,17 @@ u32 GCMemcard::CopyFrom(GCMemcard& source, u32 index)
u8 *t = new u8[source.GetFileSize(index) * 0x2000];
if(!source.GetFileData(index,t)) return 0;
u32 ret = ImportFile(d,t);
if(!source.GetFileData(index, t, true)) return 0;
u32 ret = ImportFile(d,t,0);
delete[] t;
return ret;
}
int GCMemcard::ImportGci(const char *fileName, const char *fileName2)
s32 GCMemcard::ImportGci(const char *fileName, std::string fileName2)
{
if (!mcdFile && !fileName2) return OPENFAIL;
if (fileName2.empty() && !mcdFile) return OPENFAIL;
FILE *gci = fopen(fileName, "rb");
if (!gci) return OPENFAIL;
@ -653,7 +622,7 @@ int GCMemcard::ImportGci(const char *fileName, const char *fileName2)
std::string fileType;
SplitPath(fileName, NULL, NULL, &fileType);
if( !strcasecmp(fileType.c_str(), ".gci") && !fileName2)
if( !strcasecmp(fileType.c_str(), ".gci"))
offset = GCI;
else
{
@ -687,9 +656,9 @@ int GCMemcard::ImportGci(const char *fileName, const char *fileName2)
DEntry *d = new DEntry;
fread(d, 1, 0x40, gci);
int fStart = ftell(gci);
int fStart = (int) ftell(gci);
fseek(gci, 0, SEEK_END);
int length = ftell(gci) - fStart;
int length = (int) ftell(gci) - fStart;
fseek(gci, offset + 0x40, SEEK_SET);
switch(offset){
@ -723,11 +692,11 @@ int GCMemcard::ImportGci(const char *fileName, const char *fileName2)
default:
break;
}
if (length == BE16(d->BlockCount) * 0x2000)
if (length != BE16(d->BlockCount) * 0x2000)
{
return LENGTHFAIL;
}
if (ftell(gci) == offset + 0x40) // Verify correct file position
if (ftell(gci) != offset + 0x40) // Verify correct file position
{
return OPENFAIL;
}
@ -735,20 +704,21 @@ int GCMemcard::ImportGci(const char *fileName, const char *fileName2)
u8 *t = new u8[size];
fread(t, 1, size, gci);
fclose(gci);
u32 ret = 0;
if(fileName2)
u32 ret;
if(!fileName2.empty())
{
FILE * gci2 = fopen(fileName2, "wb");
FILE * gci2 = fopen(fileName2.c_str(), "wb");
if (!gci2) return OPENFAIL;
fseek(gci2, 0, SEEK_SET);
fwrite(d, 1, 0x40, gci2);
assert(fwrite(d, 1, 0x40, gci2)==0x40);
int fileBlocks = BE16(d->BlockCount);
fseek(gci2, 0x40, SEEK_SET);
fwrite(t, 0, 0x2000 * fileBlocks, gci2);
fclose(gci2);
}
else ret = ImportFile(*d, t);
assert(fwrite(t, 1, 0x2000 * fileBlocks, gci2)==(unsigned) (0x2000*fileBlocks));
fclose(gci2);
ret = GCS;
}
else ret= ImportFile(*d, t,0);
delete []t;
delete []tmp;
@ -764,13 +734,13 @@ bool GCMemcard::ExportGci(u32 index, const char *fileName)
DEntry d;
if (!this->GetFileInfo(index, d)) return false;
fwrite(&d, 1, 0x40, gci);
assert(fwrite(&d, 1, 0x40, gci) == 0x40);
u8 *t = new u8[this->GetFileSize(index) * 0x2000];
if (!this->GetFileData(index, t)) return false;
if (!this->GetFileData(index, t, true)) return false;
fseek(gci, 0x40, SEEK_SET);
fwrite(t, 1, 0x2000 * BE16(d.BlockCount), gci);
assert(fwrite(t, 1, 0x2000 * BE16(d.BlockCount), gci)== (unsigned) (0x2000 * BE16(d.BlockCount)));
fclose(gci);
delete []t;
return true;
@ -782,12 +752,12 @@ bool GCMemcard::Save()
FILE *mcd=(FILE*)mcdFile;
fseek(mcd, 0, SEEK_SET);
fwrite(&hdr,1,0x2000,mcd);
fwrite(&dir,1,0x2000,mcd);
fwrite(&dir_backup,1,0x2000,mcd);
fwrite(&bat,1,0x2000,mcd);
fwrite(&bat_backup,1,0x2000,mcd);
fwrite(mc_data,1,mc_data_size,mcd);
assert(fwrite(&hdr, 1, 0x2000, mcd) == 0x2000);
assert(fwrite(&dir, 1, 0x2000, mcd) == 0x2000);
assert(fwrite(&dir_backup, 1, 0x2000, mcd) == 0x2000);
assert(fwrite(&bat, 1, 0x2000 ,mcd) == 0x2000);
assert(fwrite(&bat_backup, 1, 0x2000, mcd) == 0x2000);
assert(fwrite(mc_data, 1, mc_data_size, mcd) == mc_data_size);
return true;
}
@ -875,9 +845,3 @@ GCMemcard::~GCMemcard()
{
fclose((FILE*)mcdFile);
}
void varSwap(u8 *valueA,u8 *valueB){
u8 temp = *valueA;
*valueA = *valueB;
*valueB = temp;
}

15
Source/Core/DolphinWX/Src/MemoryCards/GCMemcard.h
View File

@ -28,7 +28,10 @@ enum
OPENFAIL,
GCI,
SAV = 0x80,
GCS = 0x110
GCS = 0x110,
OUTOFBLOCKS,
OUTOFDIRENTRIES,
NOMEMCARD
};
class GCMemcard
@ -155,13 +158,17 @@ public:
u32 GetFileSize(u32 index);
// assumes there's enough space in buffer
bool GetFileData(u32 index, u8* buffer);
// old determines if function uses old or new method of copying data
// some functions only work with old way, some only work with new way
// TODO: find a function that works for all calls or split into 2 functions
bool GetFileData(u32 index, u8* buffer, bool old);
// delete a file from the directory
bool RemoveFile(u32 index);
// adds the file to the directory and copies its contents
u32 ImportFile(DEntry& direntry, u8* contents);
// if remove > 0 it will pad bat.map with 0's sifeof remove
u32 ImportFile(DEntry& direntry, u8* contents, int remove);
// reads a save from another memcard, and imports the data into this memcard
u32 CopyFrom(GCMemcard& source, u32 index);
@ -170,7 +177,7 @@ public:
bool ExportGci(u32 index, const char* fileName);
// reads a .gci/.gcs/.sav file and calls ImportFile or saves out a gci file
int ImportGci(const char* fileName, const char* fileName2);
s32 ImportGci(const char* fileName, std::string fileName2);
// reads the banner image
bool ReadBannerRGBA8(u32 index, u32* buffer);