The-Homebrew-Cloud/snes9xgx
2
0
Fork 0
mirror of https://github.com/dborth/snes9xgx.git synced 2024-12-24 02:01:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

code restructure, revamp filebrowser

Browse Source
This commit is contained in:
dborth 2009-10-01 22:35:12 +00:00
parent 9b7ecedb9b
commit e78581e845
32 changed files with 827 additions and 987 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.gc
View File

@ -34,7 +34,8 @@ CFLAGS = -g -O3 -Wall $(MACHDEP) $(INCLUDE) \
-DCORRECT_VRAM_READS -DNEW_COLOUR_BLENDING \
-D_SZ_ONE_DIRECTORY -D_LZMA_IN_CB -D_LZMA_OUT_READ \
-fomit-frame-pointer \
-Wno-unused-parameter -Wno-strict-aliasing
-Wno-unused-parameter -Wno-strict-aliasing \
-Wno-write-strings -Wno-parentheses
CXXFLAGS = $(CFLAGS)

3
Makefile.wii
View File

@ -34,7 +34,8 @@ CFLAGS = -g -O3 -Wall $(MACHDEP) $(INCLUDE) \
-DCORRECT_VRAM_READS -DNEW_COLOUR_BLENDING \
-D_SZ_ONE_DIRECTORY -D_LZMA_IN_CB -D_LZMA_OUT_READ \
-fomit-frame-pointer \
-Wno-unused-parameter -Wno-strict-aliasing
-Wno-unused-parameter -Wno-strict-aliasing \
-Wno-write-strings -Wno-parentheses
CXXFLAGS = -save-temps -Xassembler -aln=$@.lst $(CFLAGS)

12
source/ngc/cheatmgr.cpp
View File

@ -64,20 +64,12 @@ SetupCheats()
int offset = 0;
uint16 i;
int method = GCSettings.SaveMethod;
if(method == METHOD_AUTO)
method = autoSaveMethod(SILENT);
if(method == METHOD_AUTO)
return;
if(!MakeFilePath(filepath, FILE_CHEAT, method))
if(!MakeFilePath(filepath, FILE_CHEAT))
return;
AllocSaveBuffer();
offset = LoadFile(filepath, method, SILENT);
offset = LoadFile(filepath, SILENT);
// load cheat file if present
if(offset > 0)

7
source/ngc/dvd.cpp
View File

@ -472,6 +472,9 @@ getentry (int entrycount, unsigned char dvdbuffer[])
browserList[entrycount].offset <<= 11;
browserList[entrycount].isdir = browserList[entrycount].isdir & 2;
if(browserList[entrycount].isdir)
browserList[entrycount].icon = ICON_FOLDER;
/*** Prepare for next entry ***/
@ -589,7 +592,7 @@ static bool SwitchDVDFolderR(char * dir, int maxDepth)
if(browserList[dirindex].isdir) // only parse directories
{
UpdateDirName(METHOD_DVD);
UpdateDirName();
ParseDVDdirectory();
}
else
@ -668,7 +671,7 @@ LoadDVDFileOffset (unsigned char *buffer, int length)
if (IsZipFile (readbuffer))
{
result = UnZipBuffer (buffer, METHOD_DVD); // unzip from dvd
result = UnZipBuffer (buffer, DEVICE_DVD); // unzip from dvd
}
else
{

329
source/ngc/filebrowser.cpp
View File

@ -46,7 +46,6 @@
BROWSERINFO browser;
BROWSERENTRY * browserList = NULL; // list of files/folders in browser
char rootdir[10];
static char szpath[MAXPATHLEN];
static bool inSz = false;
@ -54,62 +53,62 @@ unsigned long SNESROMSize = 0;
/****************************************************************************
* autoLoadMethod()
* Auto-determines and sets the load method
* Returns method set
* Auto-determines and sets the load device
* Returns device set
****************************************************************************/
int autoLoadMethod()
{
ShowAction ("Attempting to determine load method...");
ShowAction ("Attempting to determine load device...");
int method = METHOD_AUTO;
int device = DEVICE_AUTO;
if(ChangeInterface(METHOD_SD, SILENT))
method = METHOD_SD;
else if(ChangeInterface(METHOD_USB, SILENT))
method = METHOD_USB;
else if(ChangeInterface(METHOD_DVD, SILENT))
method = METHOD_DVD;
else if(ChangeInterface(METHOD_SMB, SILENT))
method = METHOD_SMB;
if(ChangeInterface(DEVICE_SD, SILENT))
device = DEVICE_SD;
else if(ChangeInterface(DEVICE_USB, SILENT))
device = DEVICE_USB;
else if(ChangeInterface(DEVICE_DVD, SILENT))
device = DEVICE_DVD;
else if(ChangeInterface(DEVICE_SMB, SILENT))
device = DEVICE_SMB;
else
ErrorPrompt("Unable to auto-determine load method!");
ErrorPrompt("Unable to locate a load device!");
if(GCSettings.LoadMethod == METHOD_AUTO)
GCSettings.LoadMethod = method; // save method found for later use
if(GCSettings.LoadMethod == DEVICE_AUTO)
GCSettings.LoadMethod = device; // save device found for later use
CancelAction();
return method;
return device;
}
/****************************************************************************
* autoSaveMethod()
* Auto-determines and sets the save method
* Returns method set
* Auto-determines and sets the save device
* Returns device set
****************************************************************************/
int autoSaveMethod(bool silent)
{
if(!silent)
ShowAction ("Attempting to determine save method...");
ShowAction ("Attempting to determine save device...");
int method = METHOD_AUTO;
int device = DEVICE_AUTO;
if(ChangeInterface(METHOD_SD, SILENT))
method = METHOD_SD;
else if(ChangeInterface(METHOD_USB, SILENT))
method = METHOD_USB;
else if(ChangeInterface(METHOD_MC_SLOTA, SILENT))
method = METHOD_MC_SLOTA;
else if(ChangeInterface(METHOD_MC_SLOTB, SILENT))
method = METHOD_MC_SLOTB;
else if(ChangeInterface(METHOD_SMB, SILENT))
method = METHOD_SMB;
if(ChangeInterface(DEVICE_SD, SILENT))
device = DEVICE_SD;
else if(ChangeInterface(DEVICE_USB, SILENT))
device = DEVICE_USB;
else if(ChangeInterface(DEVICE_MC_SLOTA, SILENT))
device = DEVICE_MC_SLOTA;
else if(ChangeInterface(DEVICE_MC_SLOTB, SILENT))
device = DEVICE_MC_SLOTB;
else if(ChangeInterface(DEVICE_SMB, SILENT))
device = DEVICE_SMB;
else if(!silent)
ErrorPrompt("Unable to auto-determine save method!");
ErrorPrompt("Unable to locate a save device!");
if(GCSettings.SaveMethod == METHOD_AUTO)
GCSettings.SaveMethod = method; // save method found for later use
if(GCSettings.SaveMethod == DEVICE_AUTO)
GCSettings.SaveMethod = device; // save device found for later use
CancelAction();
return method;
return device;
}
/****************************************************************************
@ -131,6 +130,26 @@ void ResetBrowser()
// set aside space for 1 entry
browserList = (BROWSERENTRY *)malloc(sizeof(BROWSERENTRY));
memset(browserList, 0, sizeof(BROWSERENTRY));
browser.size = 1;
}
bool AddBrowserEntry()
{
BROWSERENTRY * newBrowserList = (BROWSERENTRY *)realloc(browserList, (browser.size+1) * sizeof(BROWSERENTRY));
if(!newBrowserList) // failed to allocate required memory
{
ResetBrowser();
ErrorPrompt("Out of memory: too many files!");
return false;
}
else
{
browserList = newBrowserList;
}
memset(&(browserList[browser.size]), 0, sizeof(BROWSERENTRY)); // clear the new entry
browser.size++;
return true;
}
/****************************************************************************
@ -139,6 +158,9 @@ void ResetBrowser()
***************************************************************************/
static void CleanupPath(char * path)
{
if(!path || path[0] == 0)
return;
int pathlen = strlen(path);
int j = 0;
for(int i=0; i < pathlen && i < MAXPATHLEN; i++)
@ -150,23 +172,41 @@ static void CleanupPath(char * path)
path[j++] = path[i];
}
path[j] = 0;
}
if(strlen(path) == 0)
sprintf(path, "/");
bool IsDeviceRoot(char * path)
{
if(path == NULL || path[0] == 0)
return false;
if(strcmp(path, "sd:/") == 0 ||
strcmp(path, "usb:/") == 0 ||
strcmp(path, "dvd:/") == 0 ||
strcmp(path, "smb:/") == 0)
{
return true;
}
return false;
}
/****************************************************************************
* UpdateDirName()
* Update curent directory name for file browser
***************************************************************************/
int UpdateDirName(int method)
int UpdateDirName()
{
int size=0;
char * test;
char temp[1024];
int device = 0;
if(browser.numEntries == 0)
return 1;
FindDevice(browser.dir, &device);
// update DVD directory
if(method == METHOD_DVD)
if(device == DEVICE_DVD)
SetDVDdirectory(browserList[browser.selIndex].offset, browserList[browser.selIndex].length);
/* current directory doesn't change */
@ -177,18 +217,26 @@ int UpdateDirName(int method)
/* go up to parent directory */
else if (strcmp(browserList[browser.selIndex].filename,"..") == 0)
{
/* determine last subdirectory namelength */
sprintf(temp,"%s",browser.dir);
test = strtok(temp,"/");
while (test != NULL)
// already at the top level
if(IsDeviceRoot(browser.dir))
{
size = strlen(test);
test = strtok(NULL,"/");
browser.dir[0] = 0; // remove device - we are going to the device listing screen
}
else
{
/* determine last subdirectory namelength */
sprintf(temp,"%s",browser.dir);
test = strtok(temp,"/");
while (test != NULL)
{
size = strlen(test);
test = strtok(NULL,"/");
}
/* remove last subdirectory name */
size = strlen(browser.dir) - size - 1;
browser.dir[size] = 0;
}
/* remove last subdirectory name */
size = strlen(browser.dir) - size - 1;
browser.dir[size] = 0;
return 1;
}
@ -210,7 +258,7 @@ int UpdateDirName(int method)
}
}
bool MakeFilePath(char filepath[], int type, int method, char * filename, int filenum)
bool MakeFilePath(char filepath[], int type, char * filename, int filenum)
{
char file[512];
char folder[1024];
@ -244,7 +292,7 @@ bool MakeFilePath(char filepath[], int type, int method, char * filename, int fi
if(filenum >= -1)
{
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB)
if(GCSettings.SaveMethod == DEVICE_MC_SLOTA || GCSettings.SaveMethod == DEVICE_MC_SLOTB)
{
if(filenum > 9)
{
@ -280,24 +328,16 @@ bool MakeFilePath(char filepath[], int type, int method, char * filename, int fi
sprintf(folder, GCSettings.CheatFolder);
sprintf(file, "%s.cht", Memory.ROMFilename);
break;
case FILE_PREF:
sprintf(folder, appPath);
sprintf(file, "%s", PREF_FILE_NAME);
break;
case FILE_SCREEN:
sprintf(folder, GCSettings.SaveFolder);
sprintf(file, "%s.png", Memory.ROMFilename);
break;
}
switch(method)
switch(GCSettings.SaveMethod)
{
case METHOD_MC_SLOTA:
case METHOD_MC_SLOTB:
sprintf (temppath, "%s", file);
case DEVICE_MC_SLOTA:
case DEVICE_MC_SLOTB:
sprintf (temppath, "%s%s", pathPrefix[GCSettings.SaveMethod], file);
temppath[31] = 0; // truncate filename
break;
default:
sprintf (temppath, "/%s/%s", folder, file);
sprintf (temppath, "%s%s/%s", pathPrefix[GCSettings.SaveMethod], folder, file);
break;
}
}
@ -341,7 +381,7 @@ int FileSortCallback(const void *f1, const void *f2)
* If the file is a zip, we will check the file extension / file size of the
* first file inside
***************************************************************************/
static bool IsValidROM(int method)
static bool IsValidROM()
{
// file size should be between 96K and 8MB
if(browserList[browser.selIndex].length < (1024*96) ||
@ -360,7 +400,7 @@ static bool IsValidROM(int method)
if(stricmp(p, ".zip") == 0 && !inSz)
{
// we need to check the file extension of the first file in the archive
char * zippedFilename = GetFirstZipFilename (method);
char * zippedFilename = GetFirstZipFilename ();
if(zippedFilename == NULL) // we don't want to run strlen on NULL
p = NULL;
@ -428,23 +468,16 @@ void StripExt(char* returnstring, char * inputstring)
*
* Opens the selected 7z file, and parses a listing of the files within
***************************************************************************/
int BrowserLoadSz(int method)
int BrowserLoadSz()
{
char filepath[MAXPATHLEN];
memset(filepath, 0, MAXPATHLEN);
// we'll store the 7z filepath for extraction later
if(!MakeFilePath(szpath, FILE_ROM, method))
if(!MakeFilePath(szpath, FILE_ROM))
return 0;
// add device to filepath
if(method != METHOD_DVD)
{
sprintf(filepath, "%s%s", rootdir, szpath);
memcpy(szpath, filepath, MAXPATHLEN);
}
int szfiles = SzParse(szpath, method);
int szfiles = SzParse(szpath);
if(szfiles)
{
browser.numEntries = szfiles;
@ -461,13 +494,18 @@ int BrowserLoadSz(int method)
*
* Loads the selected ROM
***************************************************************************/
int BrowserLoadFile(int method)
int BrowserLoadFile()
{
char filepath[1024];
int loaded = 0;
int device;
if(!FindDevice(browser.dir, &device))
return 0;
// check that this is a valid ROM
if(!IsValidROM(method))
if(!IsValidROM())
goto done;
// store the filename (w/o ext) - used for sram/freeze naming
@ -478,16 +516,16 @@ int BrowserLoadFile(int method)
if(!inSz)
{
if(!MakeFilePath(filepath, FILE_ROM, method))
if(!MakeFilePath(filepath, FILE_ROM))
goto done;
SNESROMSize = LoadFile ((char *)Memory.ROM, filepath, browserList[browser.selIndex].length, method, NOTSILENT);
SNESROMSize = LoadFile ((char *)Memory.ROM, filepath, browserList[browser.selIndex].length, NOTSILENT);
}
else
{
switch (method)
switch (device)
{
case METHOD_DVD:
case DEVICE_DVD:
SNESROMSize = SzExtractFile(browserList[browser.selIndex].offset, (unsigned char *)Memory.ROM);
break;
default:
@ -497,7 +535,7 @@ int BrowserLoadFile(int method)
if(SNESROMSize <= 0)
{
browser.selIndex = 0;
BrowserChangeFolder(method);
BrowserChangeFolder();
}
}
@ -508,20 +546,20 @@ int BrowserLoadFile(int method)
else
{
// load UPS/IPS/PPF patch
LoadPatch(GCSettings.LoadMethod);
LoadPatch();
Memory.LoadROM ("BLANK.SMC");
Memory.LoadSRAM ("BLANK");
// load SRAM or snapshot
if (GCSettings.AutoLoad == 1)
LoadSRAMAuto(GCSettings.SaveMethod, SILENT);
LoadSRAMAuto(SILENT);
else if (GCSettings.AutoLoad == 2)
NGCUnfreezeGameAuto(GCSettings.SaveMethod, SILENT);
NGCUnfreezeGameAuto(SILENT);
// setup cheats
if(GCSettings.SaveMethod != METHOD_MC_SLOTA &&
GCSettings.SaveMethod != METHOD_MC_SLOTB)
if(GCSettings.SaveMethod != DEVICE_MC_SLOTA &&
GCSettings.SaveMethod != DEVICE_MC_SLOTB)
SetupCheats();
ResetBrowser();
@ -537,37 +575,98 @@ done:
*
* Update current directory and set new entry list if directory has changed
***************************************************************************/
int BrowserChangeFolder(int method)
int BrowserChangeFolder()
{
int device = 0;
FindDevice(browser.dir, &device);
if(inSz && browser.selIndex == 0) // inside a 7z, requesting to leave
{
if(method == METHOD_DVD)
if(device == DEVICE_DVD)
SetDVDdirectory(browserList[0].offset, browserList[0].length);
inSz = false;
SzClose();
}
if(!UpdateDirName(method))
if(!UpdateDirName())
return -1;
CleanupPath(browser.dir);
strcpy(GCSettings.LoadFolder, browser.dir);
HaltParseThread(); // halt parsing
ResetBrowser(); // reset browser
switch (method)
if(browser.dir[0] != 0)
{
case METHOD_DVD:
ParseDVDdirectory();
break;
default:
ParseDirectory(method);
break;
switch (device)
{
case DEVICE_DVD:
ParseDVDdirectory();
break;
default:
ParseDirectory();
break;
}
}
if (!browser.numEntries)
if(browser.numEntries == 0)
{
ErrorPrompt("Error reading directory!");
browser.dir[0] = 0;
int i=0;
AddBrowserEntry();
sprintf(browserList[i].filename, "sd:/");
sprintf(browserList[i].displayname, "SD Card");
browserList[i].length = 0;
browserList[i].mtime = 0;
browserList[i].isdir = 1;
browserList[i].icon = ICON_SD;
i++;
AddBrowserEntry();
sprintf(browserList[i].filename, "usb:/");
sprintf(browserList[i].displayname, "USB Mass Storage");
browserList[i].length = 0;
browserList[i].mtime = 0;
browserList[i].isdir = 1;
browserList[i].icon = ICON_USB;
i++;
#ifdef HW_RVL
AddBrowserEntry();
sprintf(browserList[i].filename, "smb:/");
sprintf(browserList[i].displayname, "Network Share");
browserList[i].length = 0;
browserList[i].mtime = 0;
browserList[i].isdir = 1;
browserList[i].icon = ICON_SMB;
i++;
#endif
AddBrowserEntry();
sprintf(browserList[i].filename, "dvd:/");
sprintf(browserList[i].displayname, "Data DVD");
browserList[i].length = 0;
browserList[i].mtime = 0;
browserList[i].isdir = 1;
browserList[i].icon = ICON_DVD;
i++;
browser.numEntries += i;
}
if(browser.dir[0] == 0)
{
GCSettings.LoadFolder[0] = 0;
GCSettings.LoadMethod = 0;
}
else
{
char * path = StripDevice(browser.dir);
if(path != NULL)
strcpy(GCSettings.LoadFolder, path);
FindDevice(browser.dir, &GCSettings.LoadMethod);
}
return browser.numEntries;
@ -580,25 +679,17 @@ int BrowserChangeFolder(int method)
int
OpenGameList ()
{
int method = GCSettings.LoadMethod;
int device = GCSettings.LoadMethod;
if(method == METHOD_AUTO)
method = autoLoadMethod();
if(device == DEVICE_AUTO)
device = autoLoadMethod();
// change current dir to roms directory
switch(method)
{
case METHOD_DVD:
browser.dir[0] = 0;
if(MountDVD(NOTSILENT))
if(ParseDVDdirectory()) // Parse root directory
SwitchDVDFolder(GCSettings.LoadFolder); // switch to ROM folder
break;
default:
sprintf(browser.dir, "/%s/", GCSettings.LoadFolder);
CleanupPath(browser.dir);
ParseDirectory(method); // Parse root directory
break;
}
if(device > 0)
sprintf(browser.dir, "%s%s", pathPrefix[device], GCSettings.LoadFolder);
else
browser.dir[0] = 0;
BrowserChangeFolder();
return browser.numEntries;
}

25
source/ngc/filebrowser.h
View File

@ -25,6 +25,7 @@ typedef struct
int numEntries; // # of entries in browserList
int selIndex; // currently selected index of browserList
int pageIndex; // starting index of browserList page display
int size; // # of entries browerList has space allocated to store
} BROWSERINFO;
typedef struct
@ -35,16 +36,26 @@ typedef struct
char isdir; // 0 - file, 1 - directory
char filename[MAXJOLIET + 1]; // full filename
char displayname[MAXJOLIET + 1]; // name for browser display
int icon; // icon to display
} BROWSERENTRY;
extern BROWSERINFO browser;
extern BROWSERENTRY * browserList;
extern char rootdir[10];
enum
{
ICON_NONE,
ICON_FOLDER,
ICON_SD,
ICON_USB,
ICON_DVD,
ICON_SMB
};
extern unsigned long SNESROMSize;
bool MakeFilePath(char filepath[], int type, int method, char * filename = NULL, int filenum = -2);
int UpdateDirName(int method);
bool MakeFilePath(char filepath[], int type, char * filename = NULL, int filenum = -2);
int UpdateDirName();
int OpenGameList();
int autoLoadMethod();
int autoSaveMethod(bool silent);
@ -52,8 +63,10 @@ int FileSortCallback(const void *f1, const void *f2);
void StripExt(char* returnstring, char * inputstring);
bool IsSz();
void ResetBrowser();
int BrowserLoadSz(int method);
int BrowserChangeFolder(int method);
int BrowserLoadFile(int method);
bool AddBrowserEntry();
bool IsDeviceRoot(char * path);
int BrowserLoadSz();
int BrowserChangeFolder();
int BrowserLoadFile();
#endif

16
source/ngc/filelist.h
View File

@ -170,8 +170,20 @@ extern const u32 progressbar_outline_png_size;
extern const u8 throbber_png[];
extern const u32 throbber_png_size;
extern const u8 folder_png[];
extern const u32 folder_png_size;
extern const u8 icon_folder_png[];
extern const u32 icon_folder_png_size;
extern const u8 icon_sd_png[];
extern const u32 icon_sd_png_size;
extern const u8 icon_usb_png[];
extern const u32 icon_usb_png_size;
extern const u8 icon_dvd_png[];
extern const u32 icon_dvd_png_size;
extern const u8 icon_smb_png[];
extern const u32 icon_smb_png_size;
extern const u8 battery_png[];
extern const u32 battery_png_size;

412
source/ngc/fileop.cpp
View File

@ -93,6 +93,20 @@ HaltDeviceThread()
usleep(THREAD_SLEEP);
}
/****************************************************************************
* HaltParseThread
*
* Signals the parse thread to stop.
***************************************************************************/
void
HaltParseThread()
{
parseHalt = true;
while(!LWP_ThreadIsSuspended(parsethread))
usleep(THREAD_SLEEP);
}
/****************************************************************************
* devicecallback
*
@ -115,41 +129,41 @@ devicecallback (void *arg)
while (1)
{
#ifdef HW_RVL
if(isMounted[METHOD_SD])
if(isMounted[DEVICE_SD])
{
if(!sd->isInserted()) // check if the device was removed
{
unmountRequired[METHOD_SD] = true;
isMounted[METHOD_SD] = false;
unmountRequired[DEVICE_SD] = true;
isMounted[DEVICE_SD] = false;
}
}
if(isMounted[METHOD_USB])
if(isMounted[DEVICE_USB])
{
if(!usb->isInserted()) // check if the device was removed
{
unmountRequired[METHOD_USB] = true;
isMounted[METHOD_USB] = false;
unmountRequired[DEVICE_USB] = true;
isMounted[DEVICE_USB] = false;
}
}
UpdateCheck();
InitializeNetwork(SILENT);
#else
if(isMounted[METHOD_SD_SLOTA])
if(isMounted[DEVICE_SD_SLOTA])
{
if(!carda->isInserted()) // check if the device was removed
{
unmountRequired[METHOD_SD_SLOTA] = true;
isMounted[METHOD_SD_SLOTA] = false;
unmountRequired[DEVICE_SD_SLOTA] = true;
isMounted[DEVICE_SD_SLOTA] = false;
}
}
if(isMounted[METHOD_SD_SLOTB])
if(isMounted[DEVICE_SD_SLOTB])
{
if(!cardb->isInserted()) // check if the device was removed
{
unmountRequired[METHOD_SD_SLOTB] = true;
isMounted[METHOD_SD_SLOTB] = false;
unmountRequired[DEVICE_SD_SLOTB] = true;
isMounted[DEVICE_SD_SLOTB] = false;
}
}
#endif
@ -214,31 +228,35 @@ void UnmountAllFAT()
* Sets libfat to use the device by default
***************************************************************************/
bool MountFAT(int method)
static bool MountFAT(int device, int silent)
{
bool mounted = true; // assume our disc is already mounted
char name[10];
char name[10], name2[10];
const DISC_INTERFACE* disc = NULL;
switch(method)
switch(device)
{
#ifdef HW_RVL
case METHOD_SD:
case DEVICE_SD:
sprintf(name, "sd");
sprintf(name2, "sd:");
disc = sd;
break;
case METHOD_USB:
case DEVICE_USB:
sprintf(name, "usb");
sprintf(name2, "usb:");
disc = usb;
break;
#else
case METHOD_SD_SLOTA:
case DEVICE_SD_SLOTA:
sprintf(name, "carda");
sprintf(name2, "carda:");
disc = carda;
break;
case METHOD_SD_SLOTB:
case DEVICE_SD_SLOTB:
sprintf(name, "cardb");
sprintf(name2, "cardb:");
disc = cardb;
break;
#endif
@ -246,95 +264,174 @@ bool MountFAT(int method)
return false; // unknown device
}
sprintf(rootdir, "%s:", name);
if(unmountRequired[method])
if(unmountRequired[device])
{
unmountRequired[method] = false;
fatUnmount(rootdir);
unmountRequired[device] = false;
fatUnmount(name2);
disc->shutdown();
isMounted[method] = false;
isMounted[device] = false;
}
if(!isMounted[method])
if(!isMounted[device])
{
if(!disc->startup())
mounted = false;
else if(!fatMountSimple(name, disc))
mounted = false;
}
if(!mounted && !silent)
{
if(device == DEVICE_SD)
ErrorPrompt("SD card not found!");
else
ErrorPrompt("USB drive not found!");
}
isMounted[method] = mounted;
isMounted[device] = mounted;
return mounted;
}
void MountAllFAT()
{
#ifdef HW_RVL
MountFAT(METHOD_SD);
MountFAT(METHOD_USB);
MountFAT(DEVICE_SD, SILENT);
MountFAT(DEVICE_USB, SILENT);
#else
MountFAT(METHOD_SD_SLOTA);
MountFAT(METHOD_SD_SLOTB);
MountFAT(DEVICE_SD_SLOTA, SILENT);
MountFAT(DEVICE_SD_SLOTB, SILENT);
#endif
}
bool FindDevice(char * filepath, int * device)
{
if(!filepath || filepath[0] == 0)
return false;
if(strncmp(filepath, "sd:", 3) == 0)
{
*device = DEVICE_SD;
return true;
}
else if(strncmp(filepath, "usb:", 4) == 0)
{
*device = DEVICE_USB;
return true;
}
else if(strncmp(filepath, "dvd:", 4) == 0)
{
*device = DEVICE_DVD;
return true;
}
else if(strncmp(filepath, "smb:", 4) == 0)
{
*device = DEVICE_SMB;
return true;
}
else if(strncmp(filepath, "carda:", 5) == 0)
{
*device = DEVICE_SD_SLOTA;
return true;
}
else if(strncmp(filepath, "cardb:", 5) == 0)
{
*device = DEVICE_SD_SLOTB;
return true;
}
else if(strncmp(filepath, "mca:", 4) == 0)
{
*device = DEVICE_MC_SLOTA;
return true;
}
else if(strncmp(filepath, "mcb:", 4) == 0)
{
*device = DEVICE_MC_SLOTB;
return true;
}
return false;
}
char * StripDevice(char * path)
{
if(path == NULL)
return NULL;
char * newpath = strchr(path,'/');
if(newpath != NULL)
newpath++;
return newpath;
}
/****************************************************************************
* ChangeInterface
* Attempts to mount/configure the device specified
***************************************************************************/
bool ChangeInterface(int method, bool silent)
bool ChangeInterface(int device, bool silent)
{
bool mounted = false;
if(method == METHOD_SD)
switch(device)
{
#ifdef HW_RVL
mounted = MountFAT(METHOD_SD); // try Wii internal SD
#else
mounted = MountFAT(METHOD_SD_SLOTA); // try SD Gecko on slot A
if(!mounted) // internal SD and SD Gecko (on slot A) not found
mounted = MountFAT(METHOD_SD_SLOTB); // try SD Gecko on slot B
#endif
if(!mounted && !silent) // no SD device found
ErrorPrompt("SD card not found!");
}
else if(method == METHOD_USB)
{
#ifdef HW_RVL
mounted = MountFAT(method);
if(!mounted && !silent)
ErrorPrompt("USB drive not found!");
#endif
}
else if(method == METHOD_DVD)
{
mounted = MountDVD(silent);
}
case DEVICE_SD:
case DEVICE_USB:
mounted = MountFAT(device, silent);
break;
case DEVICE_DVD:
mounted = MountDVD(silent);
break;
#ifdef HW_RVL
else if(method == METHOD_SMB)
{
mounted = ConnectShare(silent);
}
case DEVICE_SMB:
mounted = ConnectShare(silent);
break;
#endif
else if(method == METHOD_MC_SLOTA)
{
mounted = TestMC(CARD_SLOTA, silent);
}
else if(method == METHOD_MC_SLOTB)
{
mounted = TestMC(CARD_SLOTB, silent);
}
if(!mounted)
{
sprintf(browser.dir,"/");
rootdir[0] = 0;
case DEVICE_MC_SLOTA:
mounted = TestMC(CARD_SLOTA, silent);
break;
case DEVICE_MC_SLOTB:
mounted = TestMC(CARD_SLOTB, silent);
break;
}
return mounted;
}
bool ChangeInterface(char * filepath, bool silent)
{
int device = -1;
if(!FindDevice(filepath, &device))
return false;
return ChangeInterface(device, silent);
}
void CreateAppPath(char * origpath)
{
char * path = strdup(origpath); // make a copy so we don't mess up original
if(!path)
return;
char * loc = strrchr(path,'/');
if (loc != NULL)
*loc = 0; // strip file name
int pos = 0;
// replace fat:/ with sd:/
if(strncmp(path, "fat:/", 5) == 0)
{
pos++;
path[1] = 's';
path[2] = 'd';
}
if(ChangeInterface(&path[pos], SILENT))
strncpy(appPath, &path[pos], MAXPATHLEN);
appPath[MAXPATHLEN-1] = 0;
free(path);
}
bool ParseDirEntries()
{
if(!dirIter)
@ -357,37 +454,26 @@ bool ParseDirEntries()
i--;
continue;
}
BROWSERENTRY * newBrowserList = (BROWSERENTRY *)realloc(browserList, (browser.numEntries+i+1) * sizeof(BROWSERENTRY));
if(!newBrowserList) // failed to allocate required memory
if(AddBrowserEntry())
{
ResetBrowser();
ErrorPrompt("Out of memory: too many files!");
break;
}
else
{
browserList = newBrowserList;
}
memset(&(browserList[browser.numEntries+i]), 0, sizeof(BROWSERENTRY)); // clear the new entry
strncpy(browserList[browser.numEntries+i].filename, filename, MAXJOLIET);
browserList[browser.numEntries+i].length = filestat.st_size;
browserList[browser.numEntries+i].mtime = filestat.st_mtime;
browserList[browser.numEntries+i].isdir = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
if(browserList[browser.numEntries+i].isdir)
{
if(strcmp(filename, "..") == 0)
sprintf(browserList[browser.numEntries+i].displayname, "Up One Level");
strncpy(browserList[browser.numEntries+i].filename, filename, MAXJOLIET);
browserList[browser.numEntries+i].length = filestat.st_size;
browserList[browser.numEntries+i].mtime = filestat.st_mtime;
browserList[browser.numEntries+i].isdir = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
if(browserList[browser.numEntries+i].isdir)
{
if(strcmp(filename, "..") == 0)
sprintf(browserList[browser.numEntries+i].displayname, "Up One Level");
else
strncpy(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename, MAXJOLIET);
browserList[browser.numEntries+i].icon = ICON_FOLDER;
}
else
strncpy(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename, MAXJOLIET);
}
else
{
StripExt(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename); // hide file extension
{
StripExt(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename); // hide file extension
}
}
}
@ -411,53 +497,55 @@ bool ParseDirEntries()
* Browse subdirectories
**************************************************************************/
int
ParseDirectory(int method, bool waitParse)
ParseDirectory(bool waitParse)
{
char fulldir[MAXPATHLEN];
char msg[128];
int retry = 1;
bool mounted = false;
// halt parsing
parseHalt = true;
while(!LWP_ThreadIsSuspended(parsethread))
usleep(THREAD_SLEEP);
// reset browser
dirIter = NULL;
ResetBrowser();
ResetBrowser(); // reset browser
// open the directory
while(dirIter == NULL && retry == 1)
{
mounted = ChangeInterface(method, NOTSILENT);
sprintf(fulldir, "%s%s", rootdir, browser.dir); // add device to path
if(mounted) dirIter = diropen(fulldir);
mounted = ChangeInterface(browser.dir, NOTSILENT);
if(mounted)
dirIter = diropen(browser.dir);
else
return -1;
if(dirIter == NULL)
{
unmountRequired[method] = true;
sprintf(msg, "Error opening %s", fulldir);
sprintf(msg, "Error opening %s", browser.dir);
retry = ErrorPromptRetry(msg);
}
}
// if we can't open the dir, try opening the root dir
// if we can't open the dir, try higher levels
if (dirIter == NULL)
{
if(ChangeInterface(method, SILENT))
while(!IsDeviceRoot(browser.dir))
{
sprintf(browser.dir,"/");
sprintf(fulldir, "%s%s", rootdir, browser.dir);
dirIter = diropen(fulldir);
if (dirIter == NULL)
{
sprintf(msg, "Error opening %s", rootdir);
ErrorPrompt(msg);
return -1;
}
char * devEnd = strrchr(browser.dir, '/');
devEnd[0] = 0; // strip remaining file listing
dirIter = diropen(browser.dir);
if (dirIter)
break;
}
}
if(dirIter == NULL)
return -1;
if(IsDeviceRoot(browser.dir))
{
browser.numEntries = 1;
sprintf(browserList[0].filename, "..");
sprintf(browserList[0].displayname, "Up One Level");
browserList[0].length = 0;
browserList[0].mtime = 0;
browserList[0].isdir = 1; // flag this as a dir
}
parseHalt = false;
ParseDirEntries(); // index first 20 entries
@ -540,24 +628,27 @@ LoadSzFile(char * filepath, unsigned char * rbuffer)
* LoadFile
***************************************************************************/
u32
LoadFile (char * rbuffer, char *filepath, u32 length, int method, bool silent)
LoadFile (char * rbuffer, char *filepath, u32 length, bool silent)
{
char zipbuffer[2048];
u32 size = 0;
u32 readsize = 0;
char fullpath[MAXPATHLEN];
int retry = 1;
int device;
if(!FindDevice(filepath, &device))
return 0;
switch(method)
switch(device)
{
case METHOD_DVD:
return LoadDVDFile (rbuffer, filepath, length, silent);
case DEVICE_DVD:
return LoadDVDFile (rbuffer, StripDevice(filepath), length, silent);
break;
case METHOD_MC_SLOTA:
return LoadMCFile (rbuffer, CARD_SLOTA, filepath, silent);
case DEVICE_MC_SLOTA:
return LoadMCFile (rbuffer, CARD_SLOTA, StripDevice(filepath), silent);
break;
case METHOD_MC_SLOTB:
return LoadMCFile (rbuffer, CARD_SLOTB, filepath, silent);
case DEVICE_MC_SLOTB:
return LoadMCFile (rbuffer, CARD_SLOTB, StripDevice(filepath), silent);
break;
}
@ -571,10 +662,9 @@ LoadFile (char * rbuffer, char *filepath, u32 length, int method, bool silent)
// open the file
while(!size && retry == 1)
{
if(ChangeInterface(method, silent))
if(ChangeInterface(device, silent))
{
sprintf(fullpath, "%s%s", rootdir, filepath); // add device to filepath
file = fopen (fullpath, "rb");
file = fopen (filepath, "rb");
if(file > 0)
{
@ -590,7 +680,7 @@ LoadFile (char * rbuffer, char *filepath, u32 length, int method, bool silent)
{
if (IsZipFile (zipbuffer))
{
size = UnZipBuffer ((unsigned char *)rbuffer, method); // unzip
size = UnZipBuffer ((unsigned char *)rbuffer, device); // unzip
}
else
{
@ -631,7 +721,7 @@ LoadFile (char * rbuffer, char *filepath, u32 length, int method, bool silent)
{
if(!silent)
{
unmountRequired[method] = true;
unmountRequired[device] = true;
retry = ErrorPromptRetry("Error loading file!");
}
else
@ -647,9 +737,9 @@ LoadFile (char * rbuffer, char *filepath, u32 length, int method, bool silent)
return size;
}
u32 LoadFile(char * filepath, int method, bool silent)
u32 LoadFile(char * filepath, bool silent)
{
return LoadFile((char *)savebuffer, filepath, 0, method, silent);
return LoadFile((char *)savebuffer, filepath, 0, silent);
}
/****************************************************************************
@ -657,23 +747,26 @@ u32 LoadFile(char * filepath, int method, bool silent)
* Write buffer to file
***************************************************************************/
u32
SaveFile (char * buffer, char *filepath, u32 datasize, int method, bool silent)
SaveFile (char * buffer, char *filepath, u32 datasize, bool silent)
{
char fullpath[MAXPATHLEN];
u32 written = 0;
int retry = 1;
int device;
if(!FindDevice(filepath, &device))
return 0;
if(datasize == 0)
return 0;
ShowAction("Saving...");
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB)
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB)
{
if(method == METHOD_MC_SLOTA)
return SaveMCFile (buffer, CARD_SLOTA, filepath, datasize, silent);
if(device == DEVICE_MC_SLOTA)
return SaveMCFile (buffer, CARD_SLOTA, StripDevice(filepath), datasize, silent);
else
return SaveMCFile (buffer, CARD_SLOTB, filepath, datasize, silent);
return SaveMCFile (buffer, CARD_SLOTB, StripDevice(filepath), datasize, silent);
}
// stop checking if devices were removed/inserted
@ -682,10 +775,9 @@ SaveFile (char * buffer, char *filepath, u32 datasize, int method, bool silent)
while(!written && retry == 1)
{
if(ChangeInterface(method, silent))
if(ChangeInterface(device, silent))
{
sprintf(fullpath, "%s%s", rootdir, filepath); // add device to filepath
file = fopen (fullpath, "wb");
file = fopen (filepath, "wb");
if (file > 0)
{
@ -705,7 +797,7 @@ SaveFile (char * buffer, char *filepath, u32 datasize, int method, bool silent)
}
if(!written)
{
unmountRequired[method] = true;
unmountRequired[device] = true;
if(!silent)
retry = ErrorPromptRetry("Error saving file!");
else
@ -720,7 +812,7 @@ SaveFile (char * buffer, char *filepath, u32 datasize, int method, bool silent)
return written;
}
u32 SaveFile(char * filepath, u32 datasize, int method, bool silent)
u32 SaveFile(char * filepath, u32 datasize, bool silent)
{
return SaveFile((char *)savebuffer, filepath, datasize, method, silent);
return SaveFile((char *)savebuffer, filepath, datasize, silent);
}

17
source/ngc/fileop.h
View File

@ -26,17 +26,22 @@
void InitDeviceThread();
void ResumeDeviceThread();
void HaltDeviceThread();
void HaltParseThread();
void MountAllFAT();
void UnmountAllFAT();
bool ChangeInterface(int method, bool silent);
int ParseDirectory(int method, bool waitParse = false);
bool FindDevice(char * filepath, int * device);
char * StripDevice(char * path);
bool ChangeInterface(int device, bool silent);
bool ChangeInterface(char * filepath, bool silent);
void CreateAppPath(char * origpath);
int ParseDirectory(bool waitParse = false);
void AllocSaveBuffer();
void FreeSaveBuffer();
u32 LoadFile(char * rbuffer, char *filepath, u32 length, int method, bool silent);
u32 LoadFile(char * filepath, int method, bool silent);
u32 LoadFile(char * rbuffer, char *filepath, u32 length, bool silent);
u32 LoadFile(char * filepath, bool silent);
u32 LoadSzFile(char * filepath, unsigned char * rbuffer);
u32 SaveFile(char * buffer, char *filepath, u32 datasize, int method, bool silent);
u32 SaveFile(char * filepath, u32 datasize, int method, bool silent);
u32 SaveFile(char * buffer, char *filepath, u32 datasize, bool silent);
u32 SaveFile(char * filepath, u32 datasize, bool silent);
extern unsigned char savebuffer[SAVEBUFFERSIZE];
extern FILE * file;

59
source/ngc/freeze.cpp
View File

@ -122,21 +122,19 @@ NGCFreezeMemBuffer ()
* Do freeze game for Nintendo Gamecube
***************************************************************************/
int
NGCFreezeGame (char * filepath, int method, bool silent)
NGCFreezeGame (char * filepath, bool silent)
{
int offset = 0; // bytes written (actual)
int woffset = 0; // bytes written (expected)
int imgSize = 0; // image screenshot bytes written
char msg[100];
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
int device;
if(!FindDevice(filepath, &device))
return 0;
// save screenshot - I would prefer to do this from gameScreenTex
if(gameScreenTex2 != NULL && method != METHOD_MC_SLOTA && method != METHOD_MC_SLOTB)
if(gameScreenTex2 != NULL && device != DEVICE_MC_SLOTA && device != DEVICE_MC_SLOTB)
{
AllocSaveBuffer ();
@ -154,7 +152,7 @@ NGCFreezeGame (char * filepath, int method, bool silent)
strncpy(screenpath, filepath, 1024);
screenpath[strlen(screenpath)-4] = 0;
sprintf(screenpath, "%s.png", screenpath);
SaveFile(screenpath, imgSize, method, silent);
SaveFile(screenpath, imgSize, silent);
}
FreeSaveBuffer ();
@ -171,7 +169,7 @@ NGCFreezeGame (char * filepath, int method, bool silent)
S9xPrepareSoundForSnapshotSave (TRUE);
S9xSetSoundMute (FALSE);
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB) // MC Slot A or B
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB) // MC Slot A or B
{
// set freezecomment
char freezecomment[2][32];
@ -204,7 +202,7 @@ NGCFreezeGame (char * filepath, int method, bool silent)
woffset = zippedsize + 8;
}
offset = SaveFile(filepath, woffset, method, silent);
offset = SaveFile(filepath, woffset, silent);
done:
@ -220,20 +218,14 @@ done:
}
int
NGCFreezeGameAuto (int method, bool silent)
NGCFreezeGameAuto (bool silent)
{
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
return false;
char filepath[1024];
if(!MakeFilePath(filepath, FILE_SNAPSHOT, method, Memory.ROMFilename, 0))
if(!MakeFilePath(filepath, FILE_SNAPSHOT, Memory.ROMFilename, 0))
return false;
return NGCFreezeGame(filepath, method, silent);
return NGCFreezeGame(filepath, silent);
}
/****************************************************************************
@ -278,25 +270,22 @@ NGCUnFreezeBlock (char *name, uint8 * block, int size)
* NGCUnfreezeGame
***************************************************************************/
int
NGCUnfreezeGame (char * filepath, int method, bool silent)
NGCUnfreezeGame (char * filepath, bool silent)
{
int offset = 0;
int result = 0;
char msg[80];
bufoffset = 0;
if(method == METHOD_AUTO)
method = autoSaveMethod(silent); // we use 'Save' because snapshot needs R/W
if(method == METHOD_AUTO)
int device;
if(!FindDevice(filepath, &device))
return 0;
AllocSaveBuffer();
offset = LoadFile(filepath, method, silent);
offset = LoadFile(filepath, silent);
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB) // MC in slot A or slot B
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB) // MC in slot A or slot B
{
if (offset)
{
@ -348,18 +337,12 @@ NGCUnfreezeGame (char * filepath, int method, bool silent)
}
int
NGCUnfreezeGameAuto (int method, bool silent)
NGCUnfreezeGameAuto (bool silent)
{
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
return false;
char filepath[1024];
if(!MakeFilePath(filepath, FILE_SNAPSHOT, method, Memory.ROMFilename, 0))
if(!MakeFilePath(filepath, FILE_SNAPSHOT, Memory.ROMFilename, 0))
return false;
return NGCUnfreezeGame(filepath, method, silent);
return NGCUnfreezeGame(filepath, silent);
}

8
source/ngc/freeze.h
View File

@ -28,9 +28,9 @@ typedef struct
}
MEMFILE;
int NGCFreezeGame (char * filepath, int method, bool silent);
int NGCFreezeGameAuto (int method, bool silent);
int NGCUnfreezeGame (char * filepath, int method, bool silent);
int NGCUnfreezeGameAuto (int method, bool silent);
int NGCFreezeGame (char * filepath, bool silent);
int NGCFreezeGameAuto (bool silent);
int NGCUnfreezeGame (char * filepath, bool silent);
int NGCUnfreezeGameAuto (bool silent);
#endif

47
source/ngc/gcunzip.cpp
View File

@ -103,7 +103,7 @@ IsZipFile (char *buffer)
******************************************************************************/
int
UnZipBuffer (unsigned char *outbuffer, int method)
UnZipBuffer (unsigned char *outbuffer, int device)
{
PKZIPHEADER pkzip;
int zipoffset = 0;
@ -118,9 +118,9 @@ UnZipBuffer (unsigned char *outbuffer, int method)
int sizeread = 0;
// Read Zip Header
switch (method)
switch (device)
{
case METHOD_DVD:
case DEVICE_DVD:
sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, 0);
break;
default:
@ -190,9 +190,9 @@ UnZipBuffer (unsigned char *outbuffer, int method)
zipoffset = 0;
zipchunk = ZIPCHUNK;
switch (method)
switch (device)
{
case METHOD_DVD:
case DEVICE_DVD:
readoffset += ZIPCHUNK;
sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, readoffset);
break;
@ -225,17 +225,17 @@ done:
***************************************************************************/
char *
GetFirstZipFilename (int method)
GetFirstZipFilename ()
{
char * firstFilename = NULL;
char tempbuffer[ZIPCHUNK];
char filepath[1024];
if(!MakeFilePath(filepath, FILE_ROM, method))
if(!MakeFilePath(filepath, FILE_ROM))
return NULL;
// read start of ZIP
if(LoadFile (tempbuffer, filepath, ZIPCHUNK, method, NOTSILENT))
if(LoadFile (tempbuffer, filepath, ZIPCHUNK, NOTSILENT))
{
tempbuffer[28] = 0; // truncate - filename length is 2 bytes long (bytes 26-27)
int namelength = tempbuffer[26]; // filename length starts 26 bytes in
@ -340,7 +340,7 @@ static SZ_RESULT SzFileReadImp(void *object, void **buffer, size_t maxRequiredSi
// read data
switch (szMethod)
{
case METHOD_DVD:
case DEVICE_DVD:
sizeread = dvd_safe_read(sz_buffer, maxRequiredSize, offset);
break;
default:
@ -385,10 +385,15 @@ static SZ_RESULT SzFileSeekImp(void *object, CFileSize pos)
* It parses the entire 7z for full browsing capability
***************************************************************************/
int SzParse(char * filepath, int method)
int SzParse(char * filepath)
{
if(!filepath)
return 0;
int device;
if(!FindDevice(browser.dir, &device))
return 0;
int nbfiles = 0;
@ -402,22 +407,22 @@ int SzParse(char * filepath, int method)
SzArchiveStream.pos = 0;
// open file
switch (method)
switch (device)
{
case METHOD_SD:
case METHOD_USB:
case METHOD_SMB:
case DEVICE_SD:
case DEVICE_USB:
case DEVICE_SMB:
file = fopen (filepath, "rb");
if(!file)
return 0;
break;
case METHOD_DVD:
case DEVICE_DVD:
SwitchDVDFolder(filepath);
break;
}
// set szMethod to current chosen load method
szMethod = method;
// set szMethod to current chosen load device
szMethod = device;
// set handler functions for reading data from SD/USB/SMB/DVD
SzArchiveStream.InStream.Read = SzFileReadImp;
@ -504,11 +509,11 @@ int SzParse(char * filepath, int method)
CancelAction();
// close file
switch (method)
switch (device)
{
case METHOD_SD:
case METHOD_USB:
case METHOD_SMB:
case DEVICE_SD:
case DEVICE_USB:
case DEVICE_SMB:
fclose(file);
break;
}

6
source/ngc/gcunzip.h
View File

@ -13,9 +13,9 @@
#define _GCUNZIP_H_
int IsZipFile (char *buffer);
char * GetFirstZipFilename(int method);
int UnZipBuffer (unsigned char *outbuffer, int method);
int SzParse(char * filepath, int method);
char * GetFirstZipFilename();
int UnZipBuffer (unsigned char *outbuffer, int device);
int SzParse(char * filepath);
int SzExtractFile(int i, unsigned char *buffer);
void SzClose();

8
source/ngc/gui/gui.h
View File

@ -920,7 +920,7 @@ class GuiFileBrowser : public GuiElement
GuiText * fileListText[FILE_PAGESIZE];
GuiImage * fileListBg[FILE_PAGESIZE];
GuiImage * fileListFolder[FILE_PAGESIZE];
GuiImage * fileListIcon[FILE_PAGESIZE];
GuiButton * arrowUpBtn;
GuiButton * arrowDownBtn;
@ -937,7 +937,11 @@ class GuiFileBrowser : public GuiElement
GuiImageData * bgFileSelection;
GuiImageData * bgFileSelectionEntry;
GuiImageData * fileFolder;
GuiImageData * iconFolder;
GuiImageData * iconSD;
GuiImageData * iconUSB;
GuiImageData * iconDVD;
GuiImageData * iconSMB;
GuiImageData * scrollbar;
GuiImageData * arrowDown;
GuiImageData * arrowDownOver;

51
source/ngc/gui/gui_filebrowser.cpp
View File

@ -42,7 +42,12 @@ GuiFileBrowser::GuiFileBrowser(int w, int h)
bgFileSelectionImg->SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
bgFileSelectionEntry = new GuiImageData(bg_game_selection_entry_png);
fileFolder = new GuiImageData(folder_png);
iconFolder = new GuiImageData(icon_folder_png);
iconSD = new GuiImageData(icon_sd_png);
iconUSB = new GuiImageData(icon_usb_png);
iconDVD = new GuiImageData(icon_dvd_png);
iconSMB = new GuiImageData(icon_smb_png);
scrollbar = new GuiImageData(scrollbar_png);
scrollbarImg = new GuiImage(scrollbar);
@ -107,7 +112,7 @@ GuiFileBrowser::GuiFileBrowser(int w, int h)
fileListText[i]->SetMaxWidth(380);
fileListBg[i] = new GuiImage(bgFileSelectionEntry);
fileListFolder[i] = new GuiImage(fileFolder);
fileListIcon[i] = NULL;
fileList[i] = new GuiButton(380, 26);
fileList[i]->SetParent(this);
@ -139,7 +144,11 @@ GuiFileBrowser::~GuiFileBrowser()
delete bgFileSelection;
delete bgFileSelectionEntry;
delete fileFolder;
delete iconFolder;
delete iconSD;
delete iconUSB;
delete iconDVD;
delete iconSMB;
delete scrollbar;
delete arrowDown;
delete arrowDownOver;
@ -158,7 +167,9 @@ GuiFileBrowser::~GuiFileBrowser()
delete fileListText[i];
delete fileList[i];
delete fileListBg[i];
delete fileListFolder[i];
if(fileListIcon[i])
delete fileListIcon[i];
}
}
@ -341,16 +352,34 @@ void GuiFileBrowser::Update(GuiTrigger * t)
fileListText[i]->SetText(browserList[browser.pageIndex+i].displayname);
if(browserList[browser.pageIndex+i].isdir) // directory
if(fileListIcon[i])
{
fileList[i]->SetIcon(fileListFolder[i]);
fileListText[i]->SetPosition(30,0);
}
else
{
fileList[i]->SetIcon(NULL);
delete fileListIcon[i];
fileListIcon[i] = NULL;
fileListText[i]->SetPosition(10,0);
}
switch(browserList[browser.pageIndex+i].icon)
{
case ICON_FOLDER:
fileListIcon[i] = new GuiImage(iconFolder);
break;
case ICON_SD:
fileListIcon[i] = new GuiImage(iconSD);
break;
case ICON_USB:
fileListIcon[i] = new GuiImage(iconUSB);
break;
case ICON_DVD:
fileListIcon[i] = new GuiImage(iconDVD);
break;
case ICON_SMB:
fileListIcon[i] = new GuiImage(iconSMB);
break;
}
fileList[i]->SetIcon(fileListIcon[i]);
if(fileListIcon[i] != NULL)
fileListText[i]->SetPosition(30,0);
}
else
{

BIN
source/ngc/images/icon_dvd.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.2 KiB

0
source/ngc/images/folder.png → source/ngc/images/icon_folder.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.3 KiB

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
source/ngc/images/icon_sd.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 644 B

BIN
source/ngc/images/icon_smb.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.0 KiB

BIN
source/ngc/images/icon_usb.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 888 B

195
source/ngc/menu.cpp
View File

@ -565,19 +565,19 @@ void AutoSave()
{
if (GCSettings.AutoSave == 1)
{
SaveSRAMAuto(GCSettings.SaveMethod, SILENT);
SaveSRAMAuto(SILENT);
}
else if (GCSettings.AutoSave == 2)
{
if (WindowPrompt("Save", "Save Snapshot?", "Save", "Don't Save") )
NGCFreezeGameAuto(GCSettings.SaveMethod, NOTSILENT);
NGCFreezeGameAuto(NOTSILENT);
}
else if (GCSettings.AutoSave == 3)
{
if (WindowPrompt("Save", "Save SRAM and Snapshot?", "Save", "Don't Save") )
{
SaveSRAMAuto(GCSettings.SaveMethod, NOTSILENT);
NGCFreezeGameAuto(GCSettings.SaveMethod, NOTSILENT);
SaveSRAMAuto(NOTSILENT);
NGCFreezeGameAuto(NOTSILENT);
}
}
}
@ -975,76 +975,63 @@ static int MenuGameSelection()
#endif
// populate initial directory listing
if(OpenGameList() <= 0)
{
int choice = WindowPrompt(
"Error",
"Games directory is inaccessible on selected load device.",
"Retry",
"Check Settings");
OpenGameList();
gameBrowser.ResetState();
gameBrowser.fileList[0]->SetState(STATE_SELECTED);
gameBrowser.TriggerUpdate();
if(choice)
menu = MENU_GAMESELECTION;
else
menu = MENU_SETTINGS_FILE;
}
else
while(menu == MENU_NONE)
{
gameBrowser.ResetState();
gameBrowser.fileList[0]->SetState(STATE_SELECTED);
gameBrowser.TriggerUpdate();
usleep(THREAD_SLEEP);
while(menu == MENU_NONE)
// update gameWindow based on arrow buttons
// set MENU_EXIT if A button pressed on a game
for(i=0; i < FILE_PAGESIZE; i++)
{
usleep(THREAD_SLEEP);
// update gameWindow based on arrow buttons
// set MENU_EXIT if A button pressed on a game
for(i=0; i < FILE_PAGESIZE; i++)
if(gameBrowser.fileList[i]->GetState() == STATE_CLICKED)
{
if(gameBrowser.fileList[i]->GetState() == STATE_CLICKED)
gameBrowser.fileList[i]->ResetState();
// check corresponding browser entry
if(browserList[browser.selIndex].isdir || IsSz())
{
gameBrowser.fileList[i]->ResetState();
// check corresponding browser entry
if(browserList[browser.selIndex].isdir || IsSz())
{
if(IsSz())
res = BrowserLoadSz(GCSettings.LoadMethod);
else
res = BrowserChangeFolder(GCSettings.LoadMethod);
if(IsSz())
res = BrowserLoadSz();
else
res = BrowserChangeFolder();
if(res)
{
gameBrowser.ResetState();
gameBrowser.fileList[0]->SetState(STATE_SELECTED);
gameBrowser.TriggerUpdate();
}
else
{
menu = MENU_GAMESELECTION;
break;
}
if(res)
{
gameBrowser.ResetState();
gameBrowser.fileList[0]->SetState(STATE_SELECTED);
gameBrowser.TriggerUpdate();
}
else
{
#ifdef HW_RVL
ShutoffRumble();
#endif
mainWindow->SetState(STATE_DISABLED);
if(BrowserLoadFile(GCSettings.LoadMethod))
menu = MENU_EXIT;
else
mainWindow->SetState(STATE_DEFAULT);
menu = MENU_GAMESELECTION;
break;
}
}
else
{
#ifdef HW_RVL
ShutoffRumble();
#endif
mainWindow->SetState(STATE_DISABLED);
if(BrowserLoadFile())
menu = MENU_EXIT;
else
mainWindow->SetState(STATE_DEFAULT);
}
}
if(settingsBtn.GetState() == STATE_CLICKED)
menu = MENU_SETTINGS;
else if(exitBtn.GetState() == STATE_CLICKED)
ExitRequested = 1;
}
if(settingsBtn.GetState() == STATE_CLICKED)
menu = MENU_SETTINGS;
else if(exitBtn.GetState() == STATE_CLICKED)
ExitRequested = 1;
}
HaltGui();
mainWindow->Remove(&titleTxt);
mainWindow->Remove(&buttonWindow);
@ -1497,13 +1484,13 @@ static int MenuGame()
* Determines the save file number of the given file name
* Returns -1 if none is found
***************************************************************************/
static int FindGameSaveNum(char * savefile, int method)
static int FindGameSaveNum(char * savefile, int device)
{
int n = -1;
int romlen = strlen(Memory.ROMFilename);
int savelen = strlen(savefile);
if(romlen > 26 && (method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB))
if(romlen > 26 && (device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB))
romlen = 26; // memory card filenames are a maximum of 32 chars
int diff = savelen-romlen;
@ -1511,7 +1498,7 @@ static int FindGameSaveNum(char * savefile, int method)
if(strncmp(savefile, Memory.ROMFilename, romlen) != 0)
return -1;
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB)
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB)
{
if(diff == 2)
n = atoi(&savefile[savelen-2]);
@ -1549,12 +1536,12 @@ static int MenuGameSaves(int action)
char tmp[MAXJOLIET];
struct stat filestat;
struct tm * timeinfo;
int method = GCSettings.SaveMethod;
int device = GCSettings.SaveMethod;
if(method == METHOD_AUTO)
if(device == DEVICE_AUTO)
autoSaveMethod(NOTSILENT);
if(!ChangeInterface(method, NOTSILENT))
if(!ChangeInterface(device, NOTSILENT))
return MENU_GAME;
GuiText titleTxt(NULL, 28, (GXColor){255, 255, 255, 255});
@ -1621,18 +1608,18 @@ static int MenuGameSaves(int action)
memset(&saves, 0, sizeof(saves));
if(method == METHOD_MC_SLOTA)
if(device == DEVICE_MC_SLOTA)
{
ParseMCDirectory(CARD_SLOTA);
}
else if(method == METHOD_MC_SLOTB)
else if(device == DEVICE_MC_SLOTB)
{
ParseMCDirectory(CARD_SLOTB);
}
else
{
strncpy(browser.dir, GCSettings.SaveFolder, 200);
ParseDirectory(GCSettings.SaveMethod, true);
sprintf(browser.dir, "%s%s", pathPrefix[GCSettings.SaveMethod], GCSettings.SaveFolder);
ParseDirectory(true);
}
len = strlen(Memory.ROMFilename);
@ -1654,7 +1641,7 @@ static int MenuGameSaves(int action)
strncpy(tmp, browserList[i].filename, MAXJOLIET);
tmp[len2-4] = 0;
n = FindGameSaveNum(tmp, method);
n = FindGameSaveNum(tmp, device);
if(n >= 0)
{
@ -1662,18 +1649,18 @@ static int MenuGameSaves(int action)
saves.files[saves.type[j]][n] = 1;
strncpy(saves.filename[j], browserList[i].filename, MAXJOLIET);
if(method != METHOD_MC_SLOTA && method != METHOD_MC_SLOTB)
if(device != DEVICE_MC_SLOTA && device != DEVICE_MC_SLOTB)
{
if(saves.type[j] == FILE_SNAPSHOT)
{
sprintf(scrfile, "%s/%s.png", GCSettings.SaveFolder, tmp);
sprintf(scrfile, "%s%s/%s.png", pathPrefix[GCSettings.SaveMethod], GCSettings.SaveFolder, tmp);
AllocSaveBuffer();
if(LoadFile(scrfile, GCSettings.SaveMethod, SILENT))
if(LoadFile(scrfile, SILENT))
saves.previewImg[j] = new GuiImageData(savebuffer);
FreeSaveBuffer();
}
snprintf(filepath, 1024, "%s%s/%s", rootdir, GCSettings.SaveFolder, saves.filename[j]);
snprintf(filepath, 1024, "%s%s/%s", pathPrefix[GCSettings.SaveMethod], GCSettings.SaveFolder, saves.filename[j]);
if (stat(filepath, &filestat) == 0)
{
timeinfo = localtime(&filestat.st_mtime);
@ -1715,14 +1702,14 @@ static int MenuGameSaves(int action)
if(action == 0) // load
{
MakeFilePath(filepath, saves.type[ret], method, saves.filename[ret]);
MakeFilePath(filepath, saves.type[ret], saves.filename[ret]);
switch(saves.type[ret])
{
case FILE_SRAM:
result = LoadSRAM(filepath, GCSettings.SaveMethod, NOTSILENT);
result = LoadSRAM(filepath, NOTSILENT);
break;
case FILE_SNAPSHOT:
result = NGCUnfreezeGame (filepath, GCSettings.SaveMethod, NOTSILENT);
result = NGCUnfreezeGame (filepath, NOTSILENT);
break;
}
if(result)
@ -1738,8 +1725,8 @@ static int MenuGameSaves(int action)
if(i < 100)
{
MakeFilePath(filepath, FILE_SRAM, method, Memory.ROMFilename, i);
SaveSRAM(filepath, GCSettings.SaveMethod, NOTSILENT);
MakeFilePath(filepath, FILE_SRAM, Memory.ROMFilename, i);
SaveSRAM(filepath, NOTSILENT);
menu = MENU_GAME_SAVE;
}
}
@ -1751,21 +1738,21 @@ static int MenuGameSaves(int action)
if(i < 100)
{
MakeFilePath(filepath, FILE_SNAPSHOT, method, Memory.ROMFilename, i);
NGCFreezeGame (filepath, GCSettings.SaveMethod, NOTSILENT);
MakeFilePath(filepath, FILE_SNAPSHOT, Memory.ROMFilename, i);
NGCFreezeGame (filepath, NOTSILENT);
menu = MENU_GAME_SAVE;
}
}
else // overwrite SRAM/Snapshot
{
MakeFilePath(filepath, saves.type[ret], method, saves.filename[ret]);
MakeFilePath(filepath, saves.type[ret], saves.filename[ret]);
switch(saves.type[ret])
{
case FILE_SRAM:
SaveSRAM(filepath, GCSettings.SaveMethod, NOTSILENT);
SaveSRAM(filepath, NOTSILENT);
break;
case FILE_SNAPSHOT:
NGCFreezeGame (filepath, GCSettings.SaveMethod, NOTSILENT);
NGCFreezeGame (filepath, NOTSILENT);
break;
}
menu = MENU_GAME_SAVE;
@ -3375,56 +3362,56 @@ static int MenuSettingsFile()
{
firstRun = false;
// some load/save methods are not implemented - here's where we skip them
// some load/save devices are not implemented - here's where we skip them
// they need to be skipped in the order they were enumerated in snes9xGX.h
// no USB ports on GameCube
#ifdef HW_DOL
if(GCSettings.LoadMethod == METHOD_USB)
if(GCSettings.LoadMethod == DEVICE_USB)
GCSettings.LoadMethod++;
if(GCSettings.SaveMethod == METHOD_USB)
if(GCSettings.SaveMethod == DEVICE_USB)
GCSettings.SaveMethod++;
#endif
// saving to DVD is impossible
if(GCSettings.SaveMethod == METHOD_DVD)
if(GCSettings.SaveMethod == DEVICE_DVD)
GCSettings.SaveMethod++;
// disable SMB in GC mode (stalls out)
#ifdef HW_DOL
if(GCSettings.LoadMethod == METHOD_SMB)
if(GCSettings.LoadMethod == DEVICE_SMB)
GCSettings.LoadMethod++;
if(GCSettings.SaveMethod == METHOD_SMB)
if(GCSettings.SaveMethod == DEVICE_SMB)
GCSettings.SaveMethod++;
#endif
// disable MC saving in Wii mode - does not work for some reason!
#ifdef HW_RVL
if(GCSettings.SaveMethod == METHOD_MC_SLOTA)
if(GCSettings.SaveMethod == DEVICE_MC_SLOTA)
GCSettings.SaveMethod++;
if(GCSettings.SaveMethod == METHOD_MC_SLOTB)
if(GCSettings.SaveMethod == DEVICE_MC_SLOTB)
GCSettings.SaveMethod++;
options.name[7][0] = 0;
#endif
// correct load/save methods out of bounds
// correct load/save devices out of bounds
if(GCSettings.LoadMethod > 4)
GCSettings.LoadMethod = 0;
if(GCSettings.SaveMethod > 6)
GCSettings.SaveMethod = 0;
if (GCSettings.LoadMethod == METHOD_AUTO) sprintf (options.value[0],"Auto Detect");
else if (GCSettings.LoadMethod == METHOD_SD) sprintf (options.value[0],"SD");
else if (GCSettings.LoadMethod == METHOD_USB) sprintf (options.value[0],"USB");
else if (GCSettings.LoadMethod == METHOD_DVD) sprintf (options.value[0],"DVD");
else if (GCSettings.LoadMethod == METHOD_SMB) sprintf (options.value[0],"Network");
if (GCSettings.LoadMethod == DEVICE_AUTO) sprintf (options.value[0],"Auto Detect");
else if (GCSettings.LoadMethod == DEVICE_SD) sprintf (options.value[0],"SD");
else if (GCSettings.LoadMethod == DEVICE_USB) sprintf (options.value[0],"USB");
else if (GCSettings.LoadMethod == DEVICE_DVD) sprintf (options.value[0],"DVD");
else if (GCSettings.LoadMethod == DEVICE_SMB) sprintf (options.value[0],"Network");
if (GCSettings.SaveMethod == METHOD_AUTO) sprintf (options.value[1],"Auto Detect");
else if (GCSettings.SaveMethod == METHOD_SD) sprintf (options.value[1],"SD");
else if (GCSettings.SaveMethod == METHOD_USB) sprintf (options.value[1],"USB");
else if (GCSettings.SaveMethod == METHOD_SMB) sprintf (options.value[1],"Network");
else if (GCSettings.SaveMethod == METHOD_MC_SLOTA) sprintf (options.value[1],"MC Slot A");
else if (GCSettings.SaveMethod == METHOD_MC_SLOTB) sprintf (options.value[1],"MC Slot B");
if (GCSettings.SaveMethod == DEVICE_AUTO) sprintf (options.value[1],"Auto Detect");
else if (GCSettings.SaveMethod == DEVICE_SD) sprintf (options.value[1],"SD");
else if (GCSettings.SaveMethod == DEVICE_USB) sprintf (options.value[1],"USB");
else if (GCSettings.SaveMethod == DEVICE_SMB) sprintf (options.value[1],"Network");
else if (GCSettings.SaveMethod == DEVICE_MC_SLOTA) sprintf (options.value[1],"MC Slot A");
else if (GCSettings.SaveMethod == DEVICE_MC_SLOTB) sprintf (options.value[1],"MC Slot B");
snprintf (options.value[2], 30, "%s", GCSettings.LoadFolder);
snprintf (options.value[3], 30, "%s", GCSettings.SaveFolder);

7
source/ngc/networkop.cpp
View File

@ -38,7 +38,7 @@ bool updateFound = false; // true if an app update was found
void UpdateCheck()
{
// we can only check for the update if we have internet + SD
if(!updateChecked && networkInit && isMounted[METHOD_SD])
if(!updateChecked && networkInit && isMounted[DEVICE_SD])
{
static char url[128];
int retval;
@ -262,7 +262,7 @@ ConnectShare (bool silent)
return false;
}
if(unmountRequired[METHOD_SMB])
if(unmountRequired[DEVICE_SMB])
CloseShare();
if(!networkInit)
@ -289,9 +289,6 @@ ConnectShare (bool silent)
ErrorPrompt("Failed to connect to network share.");
}
if(networkShareInit)
sprintf(rootdir, "smb:");
return networkShareInit;
}

4
source/ngc/patch.cpp
View File

@ -406,7 +406,7 @@ bool patchApplyPPF(MFILE *f, u8 **rom, int *size)
return res;
}
void LoadPatch(int method)
void LoadPatch()
{
int patchsize = 0;
int patchtype;
@ -421,7 +421,7 @@ void LoadPatch(int method)
for(patchtype=0; patchtype<3; patchtype++)
{
patchsize = LoadFile(patchpath[patchtype], method, SILENT);
patchsize = LoadFile(patchpath[patchtype], SILENT);
if(patchsize)
break;

2
source/ngc/patch.h
View File

@ -13,6 +13,6 @@
#include "memfile.h"
void LoadPatch(int method);
void LoadPatch();
#endif

114
source/ngc/preferences.cpp
View File

@ -34,13 +34,14 @@ static mxml_node_t *section = NULL;
static mxml_node_t *item = NULL;
static mxml_node_t *elem = NULL;
static char temp[20];
static char temp[200];
static const char * toStr(int i)
{
sprintf(temp, "%d", i);
return temp;
}
static const char * FtoStr(float i)
{
sprintf(temp, "%.2f", i);
@ -104,9 +105,8 @@ static const char * XMLSaveCallback(mxml_node_t *node, int where)
return (NULL);
}
static int
preparePrefsData (int method)
preparePrefsData ()
{
xml = mxmlNewXML("1.0");
mxmlSetWrapMargin(0); // disable line wrapping
@ -243,7 +243,7 @@ static void loadXMLController(unsigned int controller[], const char * name)
***************************************************************************/
static bool
decodePrefsData (int method)
decodePrefsData ()
{
bool result = false;
@ -252,7 +252,6 @@ decodePrefsData (int method)
if(xml)
{
// check settings version
// we don't do anything with the version #, but we'll store it anyway
item = mxmlFindElement(xml, xml, "file", "version", NULL, MXML_DESCEND);
if(item) // a version entry exists
{
@ -346,23 +345,40 @@ decodePrefsData (int method)
/****************************************************************************
* Save Preferences
***************************************************************************/
static char prefpath[MAXPATHLEN] = { 0 };
bool
SavePrefs (bool silent)
{
char filepath[1024];
char filepath[MAXPATHLEN];
int datasize;
int offset = 0;
int method = appLoadMethod;
// We'll save using the first available method (probably SD) since this
// is the method preferences will be loaded from by default
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
return false;
if(!MakeFilePath(filepath, FILE_PREF, method))
int device = 0;
if(prefpath[0] != 0)
{
strcpy(filepath, prefpath);
FindDevice(filepath, &device);
}
else if(appPath[0] != 0)
{
sprintf(filepath, "%s%s", appPath, PREF_FILE_NAME);
FindDevice(filepath, &device);
}
else
{
device = autoLoadMethod();
if(device == 0)
return false;
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB)
sprintf(filepath, "%s%s", pathPrefix[device], PREF_FILE_NAME);
else
sprintf(filepath, "%ssnes9x/%s", pathPrefix[device], PREF_FILE_NAME);
}
if(device == 0)
return false;
if (!silent)
@ -371,9 +387,9 @@ SavePrefs (bool silent)
FixInvalidSettings();
AllocSaveBuffer ();
datasize = preparePrefsData (method);
datasize = preparePrefsData ();
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB)
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB)
{
// Set the comments
char prefscomment[2][32];
@ -383,7 +399,7 @@ SavePrefs (bool silent)
SetMCSaveComments(prefscomment);
}
offset = SaveFile(filepath, datasize, method, silent);
offset = SaveFile(filepath, datasize, silent);
FreeSaveBuffer ();
@ -399,26 +415,27 @@ SavePrefs (bool silent)
}
/****************************************************************************
* Load Preferences from specified method
* Load Preferences from specified filepath
***************************************************************************/
bool
LoadPrefsFromMethod (int method)
LoadPrefsFromMethod (char * filepath)
{
bool retval = false;
char filepath[1024];
int offset = 0;
if(!MakeFilePath(filepath, FILE_PREF, method))
return false;
AllocSaveBuffer ();
offset = LoadFile(filepath, method, SILENT);
offset = LoadFile(filepath, SILENT);
if (offset > 0)
retval = decodePrefsData (method);
retval = decodePrefsData ();
FreeSaveBuffer ();
if(retval)
{
strcpy(prefpath, filepath);
}
return retval;
}
@ -435,29 +452,28 @@ bool LoadPrefs()
return true;
bool prefFound = false;
char filepath[4][MAXPATHLEN];
int numDevices;
#ifdef HW_RVL
numDevices = 3;
sprintf(filepath[0], "%s/%s", appPath, PREF_FILE_NAME);
sprintf(filepath[1], "sd:/%s/%s", APPFOLDER, PREF_FILE_NAME);
sprintf(filepath[2], "usb:/%s/%s", APPFOLDER, PREF_FILE_NAME);
#else
numDevices = 4;
sprintf(filepath[0], "carda:/%s/%s", APPFOLDER, PREF_FILE_NAME);
sprintf(filepath[1], "cardb:/%s/%s", APPFOLDER, PREF_FILE_NAME);
sprintf(filepath[2], "mca:/%s", PREF_FILE_NAME);
sprintf(filepath[3], "mcb:/%s", PREF_FILE_NAME);
#endif
if(appLoadMethod == METHOD_SD)
for(int i=0; i<numDevices; i++)
{
if(ChangeInterface(METHOD_SD, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_SD);
}
else if(appLoadMethod == METHOD_USB)
{
if(ChangeInterface(METHOD_USB, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_USB);
}
else
{
if(ChangeInterface(METHOD_SD, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_SD);
if(!prefFound && ChangeInterface(METHOD_USB, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_USB);
if(!prefFound && TestMC(CARD_SLOTA, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_MC_SLOTA);
if(!prefFound && TestMC(CARD_SLOTB, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_MC_SLOTB);
if(!prefFound && ChangeInterface(METHOD_SMB, SILENT))
prefFound = LoadPrefsFromMethod(METHOD_SMB);
prefFound = LoadPrefsFromMethod(filepath[i]);
if(prefFound)
break;
}
prefLoaded = true; // attempted to load preferences

4
source/ngc/s9xconfig.cpp
View File

@ -58,8 +58,8 @@ DefaultSettings ()
/************** GameCube/Wii Settings *********************/
ResetControls(); // controller button mappings
GCSettings.LoadMethod = METHOD_AUTO; // Auto, SD, DVD, USB, Network (SMB)
GCSettings.SaveMethod = METHOD_AUTO; // Auto, SD, Memory Card Slot A, Memory Card Slot B, USB, Network (SMB)
GCSettings.LoadMethod = DEVICE_AUTO; // Auto, SD, DVD, USB, Network (SMB)
GCSettings.SaveMethod = DEVICE_AUTO; // Auto, SD, Memory Card Slot A, Memory Card Slot B, USB, Network (SMB)
sprintf (GCSettings.LoadFolder,"snes9x/roms"); // Path to game files
sprintf (GCSettings.SaveFolder,"snes9x/saves"); // Path to save files
sprintf (GCSettings.CheatFolder,"snes9x/cheats"); // Path to cheat files

39
source/ngc/snes9xGX.cpp
View File

@ -63,8 +63,7 @@ int ConfigRequested = 0;
int ShutdownRequested = 0;
int ResetRequested = 0;
int ExitRequested = 0;
char appPath[1024];
int appLoadMethod = METHOD_AUTO;
char appPath[1024] = { 0 };
extern "C" {
extern void __exception_setreload(int t);
@ -101,7 +100,7 @@ void ExitApp()
SavePrefs(SILENT);
if (SNESROMSize > 0 && !ConfigRequested && GCSettings.AutoSave == 1)
SaveSRAMAuto(GCSettings.SaveMethod, SILENT);
SaveSRAMAuto(SILENT);
ExitCleanup();
@ -290,35 +289,6 @@ emulate ()
} // main loop
}
static void CreateAppPath(char origpath[])
{
#ifdef HW_DOL
sprintf(appPath, GCSettings.SaveFolder);
#else
char path[1024];
strncpy(path, origpath, 1024); // make a copy so we don't mess up original
char * loc;
int pos = -1;
if(strncmp(path, "sd:/", 5) == 0 || strncmp(path, "fat:/", 5) == 0)
appLoadMethod = METHOD_SD;
else if(strncmp(path, "usb:/", 5) == 0)
appLoadMethod = METHOD_USB;
loc = strrchr(path,'/');
if (loc != NULL)
*loc = 0; // strip file name
loc = strchr(path,'/'); // looking for first / (after sd: or usb:)
if (loc != NULL)
pos = loc - path + 1;
if(pos >= 0 && pos < 1024)
sprintf(appPath, &(path[pos]));
#endif
}
/****************************************************************************
* USB Gecko Debugging
***************************************************************************/
@ -390,7 +360,7 @@ void USBGeckoOutput()
int
main(int argc, char *argv[])
{
//USBGeckoOutput(); // uncomment to enable USB gecko output
USBGeckoOutput(); // uncomment to enable USB gecko output
__exception_setreload(8);
#ifdef HW_DOL
@ -460,9 +430,10 @@ main(int argc, char *argv[])
#endif
// store path app was loaded from
sprintf(appPath, "snes9x");
#ifdef HW_RVL
if(argc > 0 && argv[0] != NULL)
CreateAppPath(argv[0]);
#endif
// Initialize libFAT for SD and USB
MountAllFAT();

27
source/ngc/snes9xGX.h
View File

@ -21,30 +21,32 @@
#define APPNAME "Snes9x GX"
#define APPVERSION "4.1.1"
#define APPFOLDER "snes9x"
#define PREF_FILE_NAME "settings.xml"
#define NOTSILENT 0
#define SILENT 1
const char pathPrefix[9][8] =
{ "", "sd:/", "usb:/", "dvd:/", "smb:/", "mca:/", "mcb:/", "carda:/", "cardb:/" };
enum {
METHOD_AUTO,
METHOD_SD,
METHOD_USB,
METHOD_DVD,
METHOD_SMB,
METHOD_MC_SLOTA,
METHOD_MC_SLOTB,
METHOD_SD_SLOTA,
METHOD_SD_SLOTB
DEVICE_AUTO,
DEVICE_SD,
DEVICE_USB,
DEVICE_DVD,
DEVICE_SMB,
DEVICE_MC_SLOTA,
DEVICE_MC_SLOTB,
DEVICE_SD_SLOTA,
DEVICE_SD_SLOTB
};
enum {
FILE_SRAM,
FILE_SNAPSHOT,
FILE_ROM,
FILE_CHEAT,
FILE_PREF,
FILE_SCREEN
FILE_CHEAT
};
enum
@ -99,7 +101,6 @@ extern int ConfigRequested;
extern int ShutdownRequested;
extern int ExitRequested;
extern char appPath[];
extern int appLoadMethod;
extern FreeTypeGX *fontSystem[];
#endif

64
source/ngc/sram.cpp
View File

@ -30,19 +30,17 @@
* Load SRAM
***************************************************************************/
bool
LoadSRAM (char * filepath, int method, bool silent)
LoadSRAM (char * filepath, bool silent)
{
int offset = 0;
if(method == METHOD_AUTO)
method = autoSaveMethod(silent); // we use 'Save' because SRAM needs R/W
if(method == METHOD_AUTO)
return false;
int device;
if(!FindDevice(filepath, &device))
return 0;
AllocSaveBuffer();
offset = LoadFile(filepath, method, silent);
offset = LoadFile(filepath, silent);
if (offset > 0)
{
@ -51,7 +49,7 @@ LoadSRAM (char * filepath, int method, bool silent)
if (size > 0x20000)
size = 0x20000;
if (method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB ||
if (device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB ||
offset == size + 512 || offset == size + 512 + SRTC_SRAM_PAD)
{
// SRAM has a 512 byte header - remove it, then import the SRAM,
@ -86,36 +84,26 @@ LoadSRAM (char * filepath, int method, bool silent)
}
bool
LoadSRAMAuto (int method, bool silent)
LoadSRAMAuto (bool silent)
{
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
return false;
char filepath[MAXPATHLEN];
char fullpath[MAXPATHLEN];
char filepath2[MAXPATHLEN];
char fullpath2[MAXPATHLEN];
// look for Auto save file
if(!MakeFilePath(filepath, FILE_SRAM, method, Memory.ROMFilename, 0))
if(!MakeFilePath(filepath, FILE_SRAM, Memory.ROMFilename, 0))
return false;
if (LoadSRAM(filepath, method, silent))
if (LoadSRAM(filepath, silent))
return true;
// look for file with no number or Auto appended
if(!MakeFilePath(filepath2, FILE_SRAM, method, Memory.ROMFilename, -1))
if(!MakeFilePath(filepath2, FILE_SRAM, Memory.ROMFilename, -1))
return false;
if(LoadSRAM(filepath2, method, silent))
if(LoadSRAM(filepath2, silent))
{
// rename this file - append Auto
sprintf(fullpath, "%s%s", rootdir, filepath); // add device to path
sprintf(fullpath2, "%s%s", rootdir, filepath2); // add device to path
rename(fullpath2, fullpath); // rename file (to avoid duplicates)
rename(filepath2, filepath); // rename file (to avoid duplicates)
return true;
}
return false;
@ -125,16 +113,14 @@ LoadSRAMAuto (int method, bool silent)
* Save SRAM
***************************************************************************/
bool
SaveSRAM (char * filepath, int method, bool silent)
SaveSRAM (char * filepath, bool silent)
{
bool retval = false;
int offset = 0;
int device;
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
return false;
if(!FindDevice(filepath, &device))
return 0;
// determine SRAM size
int size = Memory.SRAMSize ? (1 << (Memory.SRAMSize + 3)) * 128 : 0;
@ -144,7 +130,7 @@ SaveSRAM (char * filepath, int method, bool silent)
if (size > 0)
{
if(method == METHOD_MC_SLOTA || method == METHOD_MC_SLOTB)
if(device == DEVICE_MC_SLOTA || device == DEVICE_MC_SLOTB)
{
// Set the sramcomments
char sramcomment[2][32];
@ -157,7 +143,7 @@ SaveSRAM (char * filepath, int method, bool silent)
AllocSaveBuffer ();
// copy in the SRAM, leaving a 512 byte header (for compatibility with other platforms)
memcpy(savebuffer+512, Memory.SRAM, size);
offset = SaveFile(filepath, size+512, method, silent);
offset = SaveFile(filepath, size+512, silent);
FreeSaveBuffer ();
if (offset > 0)
@ -176,18 +162,12 @@ SaveSRAM (char * filepath, int method, bool silent)
}
bool
SaveSRAMAuto (int method, bool silent)
SaveSRAMAuto (bool silent)
{
if(method == METHOD_AUTO)
method = autoSaveMethod(silent);
if(method == METHOD_AUTO)
return false;
char filepath[1024];
if(!MakeFilePath(filepath, FILE_SRAM, method, Memory.ROMFilename, 0))
if(!MakeFilePath(filepath, FILE_SRAM, Memory.ROMFilename, 0))
return false;
return SaveSRAM(filepath, method, silent);
return SaveSRAM(filepath, silent);
}

8
source/ngc/sram.h
View File

@ -10,7 +10,7 @@
* SRAM save/load/import/export handling
***************************************************************************/
bool SaveSRAM (char * filepath, int method, bool silent);
bool SaveSRAMAuto (int method, bool silent);
bool LoadSRAM (char * filepath, int method, bool silent);
bool LoadSRAMAuto (int method, bool silent);
bool SaveSRAM (char * filepath, bool silent);
bool SaveSRAMAuto (bool silent);
bool LoadSRAM (char * filepath, bool silent);
bool LoadSRAMAuto (bool silent);

4
source/snes9x/gfx.cpp
View File

@ -490,10 +490,10 @@ void S9xEndScreenRefresh() {
PPU.CGDATA[0] = saved;
}
//#ifndef NGC
#ifndef NGC
if(Settings.TakeScreenshot)
S9xDoScreenshot(IPPU.RenderedScreenWidth, IPPU.RenderedScreenHeight);
//#endif
#endif
S9xControlEOF();
if(Settings.AutoDisplayMessages || Settings.OpenGLEnable || Settings.GlideEnable)

343
source/snes9x/ngcscreenshot.cpp
View File

@ -1,343 +0,0 @@
/**********************************************************************************
Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
(c) Copyright 1996 - 2002 Gary Henderson (gary.henderson@ntlworld.com),
Jerremy Koot (jkoot@snes9x.com)
(c) Copyright 2002 - 2004 Matthew Kendora
(c) Copyright 2002 - 2005 Peter Bortas (peter@bortas.org)
(c) Copyright 2004 - 2005 Joel Yliluoma (http://iki.fi/bisqwit/)
(c) Copyright 2001 - 2006 John Weidman (jweidman@slip.net)
(c) Copyright 2002 - 2006 funkyass (funkyass@spam.shaw.ca),
Kris Bleakley (codeviolation@hotmail.com)
(c) Copyright 2002 - 2007 Brad Jorsch (anomie@users.sourceforge.net),
Nach (n-a-c-h@users.sourceforge.net),
zones (kasumitokoduck@yahoo.com)
(c) Copyright 2006 - 2007 nitsuja
BS-X C emulator code
(c) Copyright 2005 - 2006 Dreamer Nom,
zones
C4 x86 assembler and some C emulation code
(c) Copyright 2000 - 2003 _Demo_ (_demo_@zsnes.com),
Nach,
zsKnight (zsknight@zsnes.com)
C4 C++ code
(c) Copyright 2003 - 2006 Brad Jorsch,
Nach
DSP-1 emulator code
(c) Copyright 1998 - 2006 _Demo_,
Andreas Naive (andreasnaive@gmail.com)
Gary Henderson,
Ivar (ivar@snes9x.com),
John Weidman,
Kris Bleakley,
Matthew Kendora,
Nach,
neviksti (neviksti@hotmail.com)
DSP-2 emulator code
(c) Copyright 2003 John Weidman,
Kris Bleakley,
Lord Nightmare (lord_nightmare@users.sourceforge.net),
Matthew Kendora,
neviksti
DSP-3 emulator code
(c) Copyright 2003 - 2006 John Weidman,
Kris Bleakley,
Lancer,
z80 gaiden
DSP-4 emulator code
(c) Copyright 2004 - 2006 Dreamer Nom,
John Weidman,
Kris Bleakley,
Nach,
z80 gaiden
OBC1 emulator code
(c) Copyright 2001 - 2004 zsKnight,
pagefault (pagefault@zsnes.com),
Kris Bleakley,
Ported from x86 assembler to C by sanmaiwashi
SPC7110 and RTC C++ emulator code
(c) Copyright 2002 Matthew Kendora with research by
zsKnight,
John Weidman,
Dark Force
S-DD1 C emulator code
(c) Copyright 2003 Brad Jorsch with research by
Andreas Naive,
John Weidman
S-RTC C emulator code
(c) Copyright 2001-2006 byuu,
John Weidman
ST010 C++ emulator code
(c) Copyright 2003 Feather,
John Weidman,
Kris Bleakley,
Matthew Kendora
Super FX x86 assembler emulator code
(c) Copyright 1998 - 2003 _Demo_,
pagefault,
zsKnight,
Super FX C emulator code
(c) Copyright 1997 - 1999 Ivar,
Gary Henderson,
John Weidman
Sound DSP emulator code is derived from SNEeSe and OpenSPC:
(c) Copyright 1998 - 2003 Brad Martin
(c) Copyright 1998 - 2006 Charles Bilyue'
SH assembler code partly based on x86 assembler code
(c) Copyright 2002 - 2004 Marcus Comstedt (marcus@mc.pp.se)
2xSaI filter
(c) Copyright 1999 - 2001 Derek Liauw Kie Fa
HQ2x, HQ3x, HQ4x filters
(c) Copyright 2003 Maxim Stepin (maxim@hiend3d.com)
Win32 GUI code
(c) Copyright 2003 - 2006 blip,
funkyass,
Matthew Kendora,
Nach,
nitsuja
Mac OS GUI code
(c) Copyright 1998 - 2001 John Stiles
(c) Copyright 2001 - 2007 zones
Specific ports contains the works of other authors. See headers in
individual files.
Snes9x homepage: http://www.snes9x.com
Permission to use, copy, modify and/or distribute Snes9x in both binary
and source form, for non-commercial purposes, is hereby granted without
fee, providing that this license information and copyright notice appear
with all copies and any derived work.
This software is provided 'as-is', without any express or implied
warranty. In no event shall the authors be held liable for any damages
arising from the use of this software or it's derivatives.
Snes9x is freeware for PERSONAL USE only. Commercial users should
seek permission of the copyright holders first. Commercial use includes,
but is not limited to, charging money for Snes9x or software derived from
Snes9x, including Snes9x or derivatives in commercial game bundles, and/or
using Snes9x as a promotion for your commercial product.
The copyright holders request that bug fixes and improvements to the code
should be forwarded to them so everyone can benefit from the modifications
in future versions.
Super NES and Super Nintendo Entertainment System are trademarks of
Nintendo Co., Limited and its subsidiary companies.
**********************************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#ifndef __WIN32__
#include <unistd.h>
#else
#include <direct.h>
#endif
#include <string.h>
#include <fcntl.h>
#include <pngu/pngu.h>
#include <png.h>
#include "snes9xGX.h"
#include "fileop.h"
#include "filebrowser.h"
#include "snes9x.h"
#include "memmap.h"
#include "display.h"
#include "gfx.h"
#include "ppu.h"
#include "screenshot.h"
#define ShowFailure() S9xSetInfoString("Failed to take screenshot.")
#if 0
//
// Need png.c from libpng to access the follow functions (and the code in s9xdoscreenshot)
//
// Constants
#define PNGU_SOURCE_BUFFER 1
#define PNGU_SOURCE_DEVICE 2
//extern struct _IMGCTX;
extern "C" {
// Prototypes of helper functions
int pngu_info (IMGCTX ctx);
//int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha);
void pngu_free_info (IMGCTX ctx);
//void pngu_read_data_from_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
void pngu_write_data_to_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
void pngu_flush_data_to_buffer (png_structp png_ptr);
//int pngu_clamp (int value, int min, int max);
}
#endif
bool8 S9xDoScreenshot(int width, int height)
{
{
static char str [64];
sprintf(str, "Saving screenshot");
S9xSetInfoString(str);
return true;
}
#if 0 // disable screenshots for now. Code is not quite right.
IMGCTX ctx;
png_color_8 sig_bit;
uint16 *screen = GFX.Screen; // source
int method = GCSettings.SaveMethod;
// Erase from the context any info
pngu_free_info (ctx);
ctx->propRead = 0;
// Set some defaults
ctx->source = PNGU_SOURCE_DEVICE; // or PNGU_SOURCE_BUFFER;
if ( !MakeFilePath(ctx->filename, FILE_SCREEN, method) )
return FALSE;
// init destination file
if (ctx->source == PNGU_SOURCE_BUFFER);
else if (ctx->source == PNGU_SOURCE_DEVICE)
{
// Open file
if (!(ctx->fd = fopen (ctx->filename, "wb")))
return PNGU_CANT_OPEN_FILE;
}
else
return PNGU_NO_FILE_SELECTED;
// Allocation of libpng structs
ctx->png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!(ctx->png_ptr))
{
if (ctx->source == PNGU_SOURCE_DEVICE)
fclose (ctx->fd);
return PNGU_LIB_ERROR;
}
ctx->info_ptr = png_create_info_struct (ctx->png_ptr);
if (!(ctx->info_ptr))
{
png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
if (ctx->source == PNGU_SOURCE_DEVICE)
fclose (ctx->fd);
return PNGU_LIB_ERROR;
}
if (ctx->source == PNGU_SOURCE_BUFFER)
{
// Installation of our custom data writer function
ctx->cursor = 0;
png_set_write_fn (ctx->png_ptr, ctx, pngu_write_data_to_buffer, pngu_flush_data_to_buffer);
}
else if (ctx->source == PNGU_SOURCE_DEVICE)
{
// Default data writer uses function fwrite, so it needs to use our FILE*
png_init_io (ctx->png_ptr, ctx->fd);
}
// Setup output file properties
png_set_IHDR (ctx->png_ptr, ctx->info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
// 5 bits per color
sig_bit.red=5;
sig_bit.green=5;
sig_bit.blue=5;
png_set_sBIT(ctx->png_ptr, ctx->info_ptr, &sig_bit);
png_set_shift(ctx->png_ptr, &sig_bit);
png_write_info(ctx->png_ptr, ctx->info_ptr);
png_set_packing(ctx->png_ptr);
*(ctx->row_pointers) = new png_byte [png_get_rowbytes(ctx->png_ptr, ctx->info_ptr)]; // alloc mem
for(int y=0; y<height; y++, screen+=GFX.RealPPL)
{
png_byte *rowpix = *(ctx->row_pointers);
for(int x=0; x<width; x++)
{
uint32 r, g, b;
DECOMPOSE_PIXEL(screen[x], r, g, b);
*(rowpix++) = r;
*(rowpix++) = g;
*(rowpix++) = b;
}
png_write_row(ctx->png_ptr, *(ctx->row_pointers));
}
delete [] ctx->row_pointers;
// Tell libpng we have no more data to write
png_write_end (ctx->png_ptr, (png_infop) NULL);
// Free resources
free (ctx->img_data);
free (ctx->row_pointers);
png_destroy_write_struct (&(ctx->png_ptr), &(ctx->info_ptr));
if (ctx->source == PNGU_SOURCE_DEVICE)
fclose (ctx->fd);
//fprintf(stderr, "%s saved.\n", fname);
{
static char str [64];
sprintf(str, "Saved screenshot");
S9xSetInfoString(str);
}
return TRUE;
#else
Settings.TakeScreenshot=FALSE;
fprintf(stderr, "Screenshot support not available (libpng was not found at build time)\n");
return FALSE;
#endif
}