code restructure, revamp filebrowser

Makefile.gc

@@ -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)
 

Makefile.wii

@@ -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)
 

source/ngc/cheatmgr.cpp

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

source/ngc/dvd.cpp

@@ -473,6 +473,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 ***/
 
 			diroffset += dvdbuffer[diroffset];
@@ -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
 		{

source/ngc/filebrowser.cpp

@@ -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
+* Auto-determines and sets the load device
-* Returns method set
+* 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))
+	if(ChangeInterface(DEVICE_SD, SILENT))
-		method = METHOD_SD;
+		device = DEVICE_SD;
-	else if(ChangeInterface(METHOD_USB, SILENT))
+	else if(ChangeInterface(DEVICE_USB, SILENT))
-		method = METHOD_USB;
+		device = DEVICE_USB;
-	else if(ChangeInterface(METHOD_DVD, SILENT))
+	else if(ChangeInterface(DEVICE_DVD, SILENT))
-		method = METHOD_DVD;
+		device = DEVICE_DVD;
-	else if(ChangeInterface(METHOD_SMB, SILENT))
+	else if(ChangeInterface(DEVICE_SMB, SILENT))
-		method = METHOD_SMB;
+		device = DEVICE_SMB;
 	else
-		ErrorPrompt("Unable to auto-determine load method!");
+		ErrorPrompt("Unable to locate a load device!");
 
-	if(GCSettings.LoadMethod == METHOD_AUTO)
+	if(GCSettings.LoadMethod == DEVICE_AUTO)
-		GCSettings.LoadMethod = method; // save method found for later use
+		GCSettings.LoadMethod = device; // save device found for later use
 	CancelAction();
-	return method;
+	return device;
 }
 
 /****************************************************************************
 * autoSaveMethod()
-* Auto-determines and sets the save method
+* Auto-determines and sets the save device
-* Returns method set
+* 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))
+	if(ChangeInterface(DEVICE_SD, SILENT))
-		method = METHOD_SD;
+		device = DEVICE_SD;
-	else if(ChangeInterface(METHOD_USB, SILENT))
+	else if(ChangeInterface(DEVICE_USB, SILENT))
-		method = METHOD_USB;
+		device = DEVICE_USB;
-	else if(ChangeInterface(METHOD_MC_SLOTA, SILENT))
+	else if(ChangeInterface(DEVICE_MC_SLOTA, SILENT))
-		method = METHOD_MC_SLOTA;
+		device = DEVICE_MC_SLOTA;
-	else if(ChangeInterface(METHOD_MC_SLOTB, SILENT))
+	else if(ChangeInterface(DEVICE_MC_SLOTB, SILENT))
-		method = METHOD_MC_SLOTB;
+		device = DEVICE_MC_SLOTB;
-	else if(ChangeInterface(METHOD_SMB, SILENT))
+	else if(ChangeInterface(DEVICE_SMB, SILENT))
-		method = METHOD_SMB;
+		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)
+	if(GCSettings.SaveMethod == DEVICE_AUTO)
-		GCSettings.SaveMethod = method; // save method found for later use
+		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)
+bool IsDeviceRoot(char * path)
-		sprintf(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 */
+		// already at the top level
-		sprintf(temp,"%s",browser.dir);
+		if(IsDeviceRoot(browser.dir))
-		test = strtok(temp,"/");
-		while (test != NULL)
 		{
-			size = strlen(test);
+			browser.dir[0] = 0; // remove device - we are going to the device listing screen
-			test = strtok(NULL,"/");
 		}
+		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 */
+			/* remove last subdirectory name */
-		size = strlen(browser.dir) - size - 1;
+			size = strlen(browser.dir) - size - 1;
-		browser.dir[size] = 0;
+			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 DEVICE_MC_SLOTA:
-			case METHOD_MC_SLOTB:
+			case DEVICE_MC_SLOTB:
-				sprintf (temppath, "%s", file);
+				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
+	int szfiles = SzParse(szpath);
-	if(method != METHOD_DVD)
-	{
-		sprintf(filepath, "%s%s", rootdir, szpath);
-		memcpy(szpath, filepath, MAXPATHLEN);
-	}
-
-	int szfiles = SzParse(szpath, method);
 	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 &&
+		if(GCSettings.SaveMethod != DEVICE_MC_SLOTA &&
-			GCSettings.SaveMethod != METHOD_MC_SLOTB)
+			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:
+		switch (device)
-			ParseDVDdirectory();
+		{
-			break;
+			case DEVICE_DVD:
+				ParseDVDdirectory();
+				break;
 	
-		default:
+			default:
-			ParseDirectory(method);
+				ParseDirectory();
-			break;
+				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)
+	if(device == DEVICE_AUTO)
-		method = autoLoadMethod();
+		device = autoLoadMethod();
 
 	// change current dir to roms directory
-	switch(method)
+	if(device > 0)
-	{
+		sprintf(browser.dir, "%s%s", pathPrefix[device], GCSettings.LoadFolder);
-		case METHOD_DVD:
+	else
-			browser.dir[0] = 0;
+		browser.dir[0] = 0;
-			if(MountDVD(NOTSILENT))
+	
-				if(ParseDVDdirectory()) // Parse root directory
+	BrowserChangeFolder();
-					SwitchDVDFolder(GCSettings.LoadFolder); // switch to ROM folder
-			break;
-		default:
-			sprintf(browser.dir, "/%s/", GCSettings.LoadFolder);
-			CleanupPath(browser.dir);
-			ParseDirectory(method); // Parse root directory
-			break;
-	}
 	return browser.numEntries;
 }

source/ngc/filebrowser.h

@@ -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);
+bool MakeFilePath(char filepath[], int type, char * filename = NULL, int filenum = -2);
-int UpdateDirName(int method);
+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);
+bool AddBrowserEntry();
-int BrowserChangeFolder(int method);
+bool IsDeviceRoot(char * path);
-int BrowserLoadFile(int method);
+int BrowserLoadSz();
+int BrowserChangeFolder();
+int BrowserLoadFile();
 
 #endif

source/ngc/filelist.h

@@ -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 u8		icon_folder_png[];
-extern const u32	folder_png_size;
+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;

source/ngc/fileop.cpp

@@ -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;
+				unmountRequired[DEVICE_SD] = true;
-				isMounted[METHOD_SD] = false;
+				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;
+				unmountRequired[DEVICE_USB] = true;
-				isMounted[METHOD_USB] = false;
+				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;
+				unmountRequired[DEVICE_SD_SLOTA] = true;
-				isMounted[METHOD_SD_SLOTA] = false;
+				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;
+				unmountRequired[DEVICE_SD_SLOTB] = true;
-				isMounted[METHOD_SD_SLOTB] = false;
+				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,16 +264,14 @@ bool MountFAT(int method)
 			return false; // unknown device
 	}
 
-	sprintf(rootdir, "%s:", name);
+	if(unmountRequired[device])
-
-	if(unmountRequired[method])
 	{
-		unmountRequired[method] = false;
+		unmountRequired[device] = false;
-		fatUnmount(rootdir);
+		fatUnmount(name2);
 		disc->shutdown();
-		isMounted[method] = false;
+		isMounted[device] = false;
 	}
-	if(!isMounted[method])
+	if(!isMounted[device])
 	{
 		if(!disc->startup())
 			mounted = false;
@@ -263,78 +279,159 @@ bool MountFAT(int method)
 			mounted = false;
 	}
 	
-	isMounted[method] = mounted;
+	if(!mounted && !silent)
+	{
+		if(device == DEVICE_SD)
+			ErrorPrompt("SD card not found!");
+		else
+			ErrorPrompt("USB drive not found!");
+	}
+
+	isMounted[device] = mounted;
 	return mounted;
 }
 
 void MountAllFAT()
 {
 #ifdef HW_RVL
-	MountFAT(METHOD_SD);
+	MountFAT(DEVICE_SD, SILENT);
-	MountFAT(METHOD_USB);
+	MountFAT(DEVICE_USB, SILENT);
 #else
-	MountFAT(METHOD_SD_SLOTA);
+	MountFAT(DEVICE_SD_SLOTA, SILENT);
-	MountFAT(METHOD_SD_SLOTB);
+	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
+		case DEVICE_SD:
-		mounted = MountFAT(METHOD_SD); // try Wii internal SD
+		case DEVICE_USB:
-		#else
+			mounted = MountFAT(device, silent);
-		mounted = MountFAT(METHOD_SD_SLOTA); // try SD Gecko on slot A
+			break;
-		if(!mounted) // internal SD and SD Gecko (on slot A) not found
+		case DEVICE_DVD:
-			mounted = MountFAT(METHOD_SD_SLOTB); // try SD Gecko on slot B
+			mounted = MountDVD(silent);
-		#endif
+			break;
-		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);
-	}
 #ifdef HW_RVL
-	else if(method == METHOD_SMB)
+		case DEVICE_SMB:
-	{
+			mounted = ConnectShare(silent);
-		mounted = ConnectShare(silent);
+			break;
-	}
 #endif
-	else if(method == METHOD_MC_SLOTA)
+		case DEVICE_MC_SLOTA:
-	{
+			mounted = TestMC(CARD_SLOTA, silent);
-		mounted = TestMC(CARD_SLOTA, silent);
+			break;
-	}
+		case DEVICE_MC_SLOTB:
-	else if(method == METHOD_MC_SLOTB)
+			mounted = TestMC(CARD_SLOTB, silent);
-	{
+			break;
-		mounted = TestMC(CARD_SLOTB, silent);
-	}
-
-	if(!mounted)
-	{
-		sprintf(browser.dir,"/");
-		rootdir[0] = 0;
 	}
 
 	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)
@@ -358,36 +455,25 @@ bool ParseDirEntries()
 			continue;
 		}
 		
-		BROWSERENTRY * newBrowserList = (BROWSERENTRY *)realloc(browserList, (browser.numEntries+i+1) * sizeof(BROWSERENTRY));
+		if(AddBrowserEntry())
-
-		if(!newBrowserList) // failed to allocate required memory
 		{
-			ResetBrowser();
+			strncpy(browserList[browser.numEntries+i].filename, filename, MAXJOLIET);
-			ErrorPrompt("Out of memory: too many files!");
+			browserList[browser.numEntries+i].length = filestat.st_size;
-			break;
+			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
-		else
-		{
-			browserList = newBrowserList;
-		}
 	
-		memset(&(browserList[browser.numEntries+i]), 0, sizeof(BROWSERENTRY)); // clear the new entry
+			if(browserList[browser.numEntries+i].isdir)
-
+			{
-		strncpy(browserList[browser.numEntries+i].filename, filename, MAXJOLIET);
+				if(strcmp(filename, "..") == 0)
-		browserList[browser.numEntries+i].length = filestat.st_size;
+					sprintf(browserList[browser.numEntries+i].displayname, "Up One Level");
-		browserList[browser.numEntries+i].mtime = filestat.st_mtime;
+				else
-		browserList[browser.numEntries+i].isdir = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
+					strncpy(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename, MAXJOLIET);
-
+				browserList[browser.numEntries+i].icon = ICON_FOLDER;
-		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);
+			{
-		}
+				StripExt(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename); // hide file extension
-		else
+			}
-		{
-			StripExt(browserList[browser.numEntries+i].displayname, browserList[browser.numEntries+i].filename); // hide file extension
 		}
 	}
 
@@ -411,54 +497,56 @@ 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
+	ResetBrowser(); // reset browser
-	parseHalt = true;
-
-	while(!LWP_ThreadIsSuspended(parsethread))
-		usleep(THREAD_SLEEP);
-
-	// reset browser
-	dirIter = NULL;
-	ResetBrowser();
 	
 	// open the directory
 	while(dirIter == NULL && retry == 1)
 	{
-		mounted = ChangeInterface(method, NOTSILENT);
+		mounted = ChangeInterface(browser.dir, NOTSILENT);
-		sprintf(fulldir, "%s%s", rootdir, browser.dir); // add device to path
+		if(mounted)
-		if(mounted) dirIter = diropen(fulldir);
+			dirIter = diropen(browser.dir);
+		else
+			return -1;
+
 		if(dirIter == NULL)
 		{
-			unmountRequired[method] = true;
+			sprintf(msg, "Error opening %s", browser.dir);
-			sprintf(msg, "Error opening %s", fulldir);
 			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,"/");
+			char * devEnd = strrchr(browser.dir, '/');
-			sprintf(fulldir, "%s%s", rootdir, browser.dir);
+			devEnd[0] = 0; // strip remaining file listing
-			dirIter = diropen(fulldir);
+			dirIter = diropen(browser.dir);
-			if (dirIter == NULL)
+			if (dirIter)
-			{
+				break;
-				sprintf(msg, "Error opening %s", rootdir);
-				ErrorPrompt(msg);
-				return -1;
-			}
 		}
 	}
 	
+	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
 	LWP_ResumeThread(parsethread); // index remaining 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;
 	
-	switch(method)
+	if(!FindDevice(filepath, &device))
+		return 0;
+
+	switch(device)
 	{
-		case METHOD_DVD:
+		case DEVICE_DVD:
-			return LoadDVDFile (rbuffer, filepath, length, silent);
+			return LoadDVDFile (rbuffer, StripDevice(filepath), length, silent);
 			break;
-		case METHOD_MC_SLOTA:
+		case DEVICE_MC_SLOTA:
-			return LoadMCFile (rbuffer, CARD_SLOTA, filepath, silent);
+			return LoadMCFile (rbuffer, CARD_SLOTA, StripDevice(filepath), silent);
 			break;
-		case METHOD_MC_SLOTB:
+		case DEVICE_MC_SLOTB:
-			return LoadMCFile (rbuffer, CARD_SLOTB, filepath, silent);
+			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 (filepath, "rb");
-			file = fopen (fullpath, "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)
+		if(device == DEVICE_MC_SLOTA)
-			return SaveMCFile (buffer, CARD_SLOTA, filepath, datasize, silent);
+			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 (filepath, "wb");
-			file = fopen (fullpath, "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);
 }

source/ngc/fileop.h

@@ -26,17 +26,22 @@
 void InitDeviceThread();
 void ResumeDeviceThread();
 void HaltDeviceThread();
+void HaltParseThread();
 void MountAllFAT();
 void UnmountAllFAT();
-bool ChangeInterface(int method, bool silent);
+bool FindDevice(char * filepath, int * device);
-int ParseDirectory(int method, bool waitParse = false);
+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 * rbuffer, char *filepath, u32 length, bool silent);
-u32 LoadFile(char * filepath, int method, 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 * buffer, char *filepath, u32 datasize, bool silent);
-u32 SaveFile(char * filepath, u32 datasize, int method, bool silent);
+u32 SaveFile(char * filepath, u32 datasize, bool silent);
 
 extern unsigned char savebuffer[SAVEBUFFERSIZE];
 extern FILE * file;

source/ngc/freeze.cpp

@@ -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];
+	int device;
 				
-	if(method == METHOD_AUTO)
+	if(!FindDevice(filepath, &device))
-		method = autoSaveMethod(silent);
-
-	if(method == METHOD_AUTO)
 		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;
+	int device;
 				
-	if(method == METHOD_AUTO)
+	if(!FindDevice(filepath, &device))
-		method = autoSaveMethod(silent); // we use 'Save' because snapshot needs R/W
-
-	if(method == METHOD_AUTO)
 		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);
 }

source/ngc/freeze.h

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

source/ngc/gcunzip.cpp

@@ -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,11 +385,16 @@ 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;
 
 	// save the length/offset of this file
@@ -402,22 +407,22 @@ int SzParse(char * filepath, int method)
 	SzArchiveStream.pos = 0;
 
 	// open file
-	switch (method)
+	switch (device)
 	{
-		case METHOD_SD:
+		case DEVICE_SD:
-		case METHOD_USB:
+		case DEVICE_USB:
-		case METHOD_SMB:
+		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
+	// set szMethod to current chosen load device
-	szMethod = method;
+	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 DEVICE_SD:
-		case METHOD_USB:
+		case DEVICE_USB:
-		case METHOD_SMB:
+		case DEVICE_SMB:
 			fclose(file);
 			break;
 	}

source/ngc/gcunzip.h

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

source/ngc/gui/gui.h

@@ -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;

source/ngc/gui/gui_filebrowser.cpp

@@ -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]);
+					delete fileListIcon[i];
-					fileListText[i]->SetPosition(30,0);
+					fileListIcon[i] = NULL;
-				}
-				else
-				{
-					fileList[i]->SetIcon(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
 			{

source/ngc/menu.cpp

@@ -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);
+			SaveSRAMAuto(NOTSILENT);
-			NGCFreezeGameAuto(GCSettings.SaveMethod, NOTSILENT);
+			NGCFreezeGameAuto(NOTSILENT);
 		}
 	}
 }
@@ -975,76 +975,63 @@ static int MenuGameSelection()
 	#endif
 
 	// populate initial directory listing
-	if(OpenGameList() <= 0)
+	OpenGameList();
-	{
-		int choice = WindowPrompt(
-		"Error",
-		"Games directory is inaccessible on selected load device.",
-		"Retry",
-		"Check Settings");
 	
-		if(choice)
+	gameBrowser.ResetState();
-			menu = MENU_GAMESELECTION;
+	gameBrowser.fileList[0]->SetState(STATE_SELECTED);
-		else
+	gameBrowser.TriggerUpdate();
-			menu = MENU_SETTINGS_FILE;
-	}
-	else
-	{
-		gameBrowser.ResetState();
-		gameBrowser.fileList[0]->SetState(STATE_SELECTED);
-		gameBrowser.TriggerUpdate();
 
-		while(menu == MENU_NONE)
+	while(menu == MENU_NONE)
+	{
+		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++)
 		{
-			usleep(THREAD_SLEEP);
+			if(gameBrowser.fileList[i]->GetState() == STATE_CLICKED)
-
-			// 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)
+				gameBrowser.fileList[i]->ResetState();
+				// check corresponding browser entry
+				if(browserList[browser.selIndex].isdir || IsSz())
 				{
-					gameBrowser.fileList[i]->ResetState();
+					if(IsSz())
-					// check corresponding browser entry
+						res = BrowserLoadSz();
-					if(browserList[browser.selIndex].isdir || IsSz())
+					else
-					{
+						res = BrowserChangeFolder();
-						if(IsSz())
-							res = BrowserLoadSz(GCSettings.LoadMethod);
-						else
-							res = BrowserChangeFolder(GCSettings.LoadMethod);
 
-						if(res)
+					if(res)
-						{
+					{
-							gameBrowser.ResetState();
+						gameBrowser.ResetState();
-							gameBrowser.fileList[0]->SetState(STATE_SELECTED);
+						gameBrowser.fileList[0]->SetState(STATE_SELECTED);
-							gameBrowser.TriggerUpdate();
+						gameBrowser.TriggerUpdate();
-						}
-						else
-						{
-							menu = MENU_GAMESELECTION;
-							break;
-						}
 					}
 					else
 					{
-						#ifdef HW_RVL
+						menu = MENU_GAMESELECTION;
-						ShutoffRumble();
+						break;
-						#endif
-						mainWindow->SetState(STATE_DISABLED);
-						if(BrowserLoadFile(GCSettings.LoadMethod))
-							menu = MENU_EXIT;
-						else
-							mainWindow->SetState(STATE_DEFAULT);
 					}
 				}
+				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);
+		sprintf(browser.dir, "%s%s", pathPrefix[GCSettings.SaveMethod], GCSettings.SaveFolder);
-		ParseDirectory(GCSettings.SaveMethod, true);
+		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);
+						MakeFilePath(filepath, FILE_SRAM, Memory.ROMFilename, i);
-						SaveSRAM(filepath, GCSettings.SaveMethod, NOTSILENT);
+						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);
+						MakeFilePath(filepath, FILE_SNAPSHOT, Memory.ROMFilename, i);
-						NGCFreezeGame (filepath, GCSettings.SaveMethod, NOTSILENT);
+						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");
+			if (GCSettings.LoadMethod == DEVICE_AUTO) sprintf (options.value[0],"Auto Detect");
-			else if (GCSettings.LoadMethod == METHOD_SD) sprintf (options.value[0],"SD");
+			else if (GCSettings.LoadMethod == DEVICE_SD) sprintf (options.value[0],"SD");
-			else if (GCSettings.LoadMethod == METHOD_USB) sprintf (options.value[0],"USB");
+			else if (GCSettings.LoadMethod == DEVICE_USB) sprintf (options.value[0],"USB");
-			else if (GCSettings.LoadMethod == METHOD_DVD) sprintf (options.value[0],"DVD");
+			else if (GCSettings.LoadMethod == DEVICE_DVD) sprintf (options.value[0],"DVD");
-			else if (GCSettings.LoadMethod == METHOD_SMB) sprintf (options.value[0],"Network");
+			else if (GCSettings.LoadMethod == DEVICE_SMB) sprintf (options.value[0],"Network");
 
-			if (GCSettings.SaveMethod == METHOD_AUTO) sprintf (options.value[1],"Auto Detect");
+			if (GCSettings.SaveMethod == DEVICE_AUTO) sprintf (options.value[1],"Auto Detect");
-			else if (GCSettings.SaveMethod == METHOD_SD) sprintf (options.value[1],"SD");
+			else if (GCSettings.SaveMethod == DEVICE_SD) sprintf (options.value[1],"SD");
-			else if (GCSettings.SaveMethod == METHOD_USB) sprintf (options.value[1],"USB");
+			else if (GCSettings.SaveMethod == DEVICE_USB) sprintf (options.value[1],"USB");
-			else if (GCSettings.SaveMethod == METHOD_SMB) sprintf (options.value[1],"Network");
+			else if (GCSettings.SaveMethod == DEVICE_SMB) sprintf (options.value[1],"Network");
-			else if (GCSettings.SaveMethod == METHOD_MC_SLOTA) sprintf (options.value[1],"MC Slot A");
+			else if (GCSettings.SaveMethod == DEVICE_MC_SLOTA) sprintf (options.value[1],"MC Slot A");
-			else if (GCSettings.SaveMethod == METHOD_MC_SLOTB) sprintf (options.value[1],"MC Slot B");
+			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);

source/ngc/networkop.cpp

@@ -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;
 }
 

source/ngc/patch.cpp

@@ -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;

source/ngc/patch.h

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

source/ngc/preferences.cpp

@@ -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;
+	int device = 0;
 	
-	// We'll save using the first available method (probably SD) since this
+	if(prefpath[0] != 0)
-	// is the method preferences will be loaded from by default
+	{
-	if(method == METHOD_AUTO)
+		strcpy(filepath, prefpath);
-		method = autoSaveMethod(silent);
+		FindDevice(filepath, &device);
+	}
+	else if(appPath[0] != 0)
+	{
+		sprintf(filepath, "%s%s", appPath, PREF_FILE_NAME);
+		FindDevice(filepath, &device);
+	}
+	else
+	{
+		device = autoLoadMethod();
 		
-	if(method == METHOD_AUTO)
+		if(device == 0)
-		return false;
+			return false;
 		
-	if(!MakeFilePath(filepath, FILE_PREF, method))
+		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,27 +415,28 @@ 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;
 	
-	if(appLoadMethod == METHOD_SD)
+#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
+
+	for(int i=0; i<numDevices; i++)
 	{
-		if(ChangeInterface(METHOD_SD, SILENT))
+		prefFound = LoadPrefsFromMethod(filepath[i]);
-			prefFound = LoadPrefsFromMethod(METHOD_SD);
+		
-	}
+		if(prefFound)
-	else if(appLoadMethod == METHOD_USB)
+			break;
-	{
-		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);
 	}
 
 	prefLoaded = true; // attempted to load preferences

source/ngc/s9xconfig.cpp

@@ -58,8 +58,8 @@ DefaultSettings ()
 	/************** GameCube/Wii Settings *********************/
 	ResetControls(); // controller button mappings
 
-	GCSettings.LoadMethod = METHOD_AUTO; // Auto, SD, DVD, USB, Network (SMB)
+	GCSettings.LoadMethod = DEVICE_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.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

source/ngc/snes9xGX.cpp

@@ -63,8 +63,7 @@ int ConfigRequested = 0;
 int ShutdownRequested = 0;
 int ResetRequested = 0;
 int ExitRequested = 0;
-char appPath[1024];
+char appPath[1024] = { 0 };
-int appLoadMethod = METHOD_AUTO;
 
 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();

source/ngc/snes9xGX.h

@@ -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,
+	DEVICE_AUTO,
-	METHOD_SD,
+	DEVICE_SD,
-	METHOD_USB,
+	DEVICE_USB,
-	METHOD_DVD,
+	DEVICE_DVD,
-	METHOD_SMB,
+	DEVICE_SMB,
-	METHOD_MC_SLOTA,
+	DEVICE_MC_SLOTA,
-	METHOD_MC_SLOTB,
+	DEVICE_MC_SLOTB,
-	METHOD_SD_SLOTA,
+	DEVICE_SD_SLOTA,
-	METHOD_SD_SLOTB
+	DEVICE_SD_SLOTB
 };
 
 enum {
 	FILE_SRAM,
 	FILE_SNAPSHOT,
 	FILE_ROM,
-	FILE_CHEAT,
+	FILE_CHEAT
-	FILE_PREF,
-	FILE_SCREEN
 };
 
 enum
@@ -99,7 +101,6 @@ extern int ConfigRequested;
 extern int ShutdownRequested;
 extern int ExitRequested;
 extern char appPath[];
-extern int appLoadMethod;
 extern FreeTypeGX *fontSystem[];
 
 #endif

source/ngc/sram.cpp

@@ -30,19 +30,17 @@
  * Load SRAM
  ***************************************************************************/
 bool
-LoadSRAM (char * filepath, int method, bool silent)
+LoadSRAM (char * filepath, bool silent)
 {
 	int offset = 0;
+	int device;
 			
-	if(method == METHOD_AUTO)
+	if(!FindDevice(filepath, &device))
-		method = autoSaveMethod(silent); // we use 'Save' because SRAM needs R/W
+		return 0;
-
-	if(method == METHOD_AUTO)
-		return false;
 
 	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
+		rename(filepath2, filepath); // rename file (to avoid duplicates)
-		sprintf(fullpath2, "%s%s", rootdir, filepath2); // add device to path
-		rename(fullpath2, fullpath); // 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)
+	if(!FindDevice(filepath, &device))
-		method = autoSaveMethod(silent);
+		return 0;
-
-	if(method == METHOD_AUTO)
-		return false;
 
 	// 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);
 }

source/ngc/sram.h

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

source/snes9x/gfx.cpp

@@ -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)

source/snes9x/ngcscreenshot.cpp

@@ -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
-}
-