major code audit - bugs fixed, vars made static, file browser memory dynamically allocated

source/ngc/audio.cpp

@@ -13,6 +13,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+extern int ConfigRequested;
+
 /** Locals **/
 static int head = 0;
 static int tail = 0;
@@ -23,9 +25,8 @@ static u8 mixerdata[MIXBUFFSIZE];
 #define SWAP(x) ((x>>16)|(x<<16)) // for reversing stereo channels
 
 static u8 soundbuffer[2][3840] ATTRIBUTE_ALIGN(32);
-extern int ConfigRequested;
 static int whichab = 0;
-int IsPlaying = 0;
+static int IsPlaying = 0;
 
 /****************************************************************************
  * MIXER_GetSamples

source/ngc/dvd.cpp

@@ -15,7 +15,7 @@
 #include <string.h>
 #include <malloc.h>
 
-#ifdef WII_DVD
+#ifdef HW_RVL
 extern "C" {
 #include <di/di.h>
 }
@@ -26,11 +26,14 @@ extern "C" {
 #include "filesel.h"
 #include "vba.h"
 
-u64 dvddir = 0; // offset of currently selected file or folder
+#define MAXDVDFILES 2000
-int dvddirlength = 0; // length of currently selected file or folder
+
-u64 dvdrootdir = 0; // offset of DVD root
+static int diroffset = 0;
-int dvdrootlength = 0; // length of DVD root
+static u64 dvddir = 0; // offset of currently selected file or folder
-bool isWii = false;
+static int dvddirlength = 0; // length of currently selected file or folder
+static u64 dvdrootdir = 0; // offset of DVD root
+static int dvdrootlength = 0; // length of DVD root
+static bool isWii = false;
 
 #ifdef HW_DOL
 /** DVD I/O Address base **/
@@ -46,7 +49,7 @@ volatile unsigned long *dvd = (volatile unsigned long *) 0xCC006000;
 #define ALIGN_FORWARD(x,align) 	((typeof(x))((((uint32_t)(x)) + (align) - 1) & (~(align-1))))
 #define ALIGN_BACKWARD(x,align)	((typeof(x))(((uint32_t)(x)) & (~(align-1))))
 
-int
+static int
 dvd_read (void *dst, unsigned int len, u64 offset)
 {
 	if (len > 2048)
@@ -110,30 +113,40 @@ dvd_read (void *dst, unsigned int len, u64 offset)
 #define DVD_MAX_READ_LENGTH 2048
 #define DVD_SECTOR_SIZE 2048
 
-unsigned char dvdsf_buffer[DVD_SECTOR_SIZE];
+static unsigned char dvdsf_buffer[DVD_SECTOR_SIZE];
-u64 dvdsf_last_offset = 0;
+static u64 dvdsf_last_offset = 0;
-u64 dvdsf_last_length = 0;
+static u64 dvdsf_last_length = 0;
 
-int dvd_buffered_read(void *dst, u32 len, u64 offset)
+static int dvd_buffered_read(void *dst, u32 len, u64 offset)
 {
-    int ret = 1;
+	int ret = 1;
 
-    // only read data if the data inside dvdsf_buffer cannot be used
+	// only read data if the data inside dvdsf_buffer cannot be used
-    if(offset != dvdsf_last_offset || len > dvdsf_last_length)
+	if(offset != dvdsf_last_offset || len > dvdsf_last_length)
-    {
+	{
-        memset(&dvdsf_buffer, '\0', DVD_SECTOR_SIZE);
+		memset(&dvdsf_buffer, '\0', DVD_SECTOR_SIZE);
-        ret = dvd_read(&dvdsf_buffer, len, offset);
+		ret = dvd_read(&dvdsf_buffer, len, offset);
-        dvdsf_last_offset = offset;
+		dvdsf_last_offset = offset;
         dvdsf_last_length = len;
-    }
+	}
 
-    memcpy(dst, &dvdsf_buffer, len);
+	memcpy(dst, &dvdsf_buffer, len);
-    return ret;
+	return ret;
 }
 
-int dvd_safe_read(void *dst_v, u32 len, u64 offset)
+/****************************************************************************
+ * dvd_safe_read
+ *
+ * A 'safer' DVD read function
+ * This function relies on dvddir (file offset) being prepopulated!
+ * returns: 1 - ok ; 0 - error
+ ***************************************************************************/
+
+int dvd_safe_read(void *dst_v, u32 len, u64 fileoffset)
 {
-    unsigned char buffer[DVD_SECTOR_SIZE]; // buffer for one dvd sector
+	u64 offset = dvddir + fileoffset;
+
+	unsigned char buffer[DVD_SECTOR_SIZE]; // buffer for one dvd sector
 
     // if read size and length are a multiply of DVD_(OFFSET,LENGTH)_MULTIPLY and length < DVD_MAX_READ_LENGTH
     // we don't need to fix anything
@@ -239,7 +252,7 @@ static int IsJoliet = 0;
  * The PVD should reside between sector 16 and 31.
  * This is for single session DVD only.
  ***************************************************************************/
-int
+static int
 getpvd ()
 {
 	int sector = 16;
@@ -313,7 +326,7 @@ bool MountDVD(bool silent)
 		ShowAction("Loading DVD...");
 		#ifdef HW_DOL
 		DVD_Mount(); // mount the DVD unit again
-		#elif WII_DVD
+		#elif HW_RVL
 		u32 val;
 		DI_GetCoverRegister(&val);
 		if(val & 0x1)	// True if no disc inside, use (val & 0x2) for true if disc inside.
@@ -342,7 +355,7 @@ bool MountDVD(bool silent)
  * Support function to return the next file entry, if any
  * Declared static to avoid accidental external entry.
  ***************************************************************************/
-static int diroffset = 0;
+
 static int
 getentry (int entrycount, unsigned char dvdbuffer[])
 {
@@ -356,7 +369,7 @@ getentry (int entrycount, unsigned char dvdbuffer[])
 	u32 offset32;
 
 	/* Basic checks */
-	if (entrycount >= MAXFILES)
+	if (entrycount >= MAXDVDFILES)
 		return 0;
 
 	if (diroffset >= 2048)
@@ -426,19 +439,26 @@ getentry (int entrycount, unsigned char dvdbuffer[])
 			if (rr != NULL)
 				*rr = 0;
 
-			strcpy (filelist[entrycount].filename, fname);
+			browserList = (BROWSERENTRY *)realloc(browserList, (entrycount+1) * sizeof(BROWSERENTRY));
+			if(!browserList) // failed to allocate required memory
+			{
+				WaitPrompt("Out of memory: too many files!");
+				return 0;
+			}
+			memset(&(browserList[entrycount]), 0, sizeof(BROWSERENTRY)); // clear the new entry
+
+			strcpy (browserList[entrycount].filename, fname);
 			StripExt(tmpname, fname); // hide file extension
-			tmpname[MAXDISPLAY - 1] = 0;
+			strcpy (browserList[entrycount].displayname, tmpname);
-			strcpy (filelist[entrycount].displayname, tmpname);
 
 			memcpy (&offset32, &dvdbuffer[diroffset + EXTENT], 4);
 
-			filelist[entrycount].offset = (u64)offset32;
+			browserList[entrycount].offset = (u64)offset32;
-			memcpy (&filelist[entrycount].length, &dvdbuffer[diroffset + FILE_LENGTH], 4);
+			memcpy (&(browserList[entrycount].length), &dvdbuffer[diroffset + FILE_LENGTH], 4);
-			memcpy (&filelist[entrycount].flags, &dvdbuffer[diroffset + FILE_FLAGS], 1);
+			memcpy (&(browserList[entrycount].isdir), &dvdbuffer[diroffset + FILE_FLAGS], 1);
 
-			filelist[entrycount].offset <<= 11;
+			browserList[entrycount].offset <<= 11;
-			filelist[entrycount].flags = filelist[entrycount].flags & 2;
+			browserList[entrycount].isdir = browserList[entrycount].isdir & 2;
 
 			/*** Prepare for next entry ***/
 
@@ -450,7 +470,7 @@ getentry (int entrycount, unsigned char dvdbuffer[])
 }
 
 /****************************************************************************
- * parseDVDdirectory
+ * ParseDVDdirectory
  *
  * This function will parse the directory tree.
  * It relies on dvddir and dvddirlength being pre-populated by a call to
@@ -468,16 +488,13 @@ ParseDVDdirectory ()
 	int filecount = 0;
 	unsigned char dvdbuffer[2048];
 
-	// initialize selection
+	// reset browser
-	selection = offset = 0;
+	ResetBrowser();
 
 	pdoffset = rdoffset = dvddir;
 	pdlength = dvddirlength;
 	filecount = 0;
 
-	// Clear any existing values
-	memset (&filelist, 0, sizeof (FILEENTRIES) * MAXFILES);
-
 	/*** Get as many files as possible ***/
 	while (len < pdlength)
 	{
@@ -488,7 +505,7 @@ ParseDVDdirectory ()
 
 		while (getentry (filecount, dvdbuffer))
 		{
-			if(strlen(filelist[filecount].filename) > 0 && filecount < MAXFILES)
+			if(strlen(browserList[filecount].filename) > 0 && filecount < MAXDVDFILES)
 				filecount++;
 		}
 
@@ -497,34 +514,45 @@ ParseDVDdirectory ()
 	}
 
 	// Sort the file list
-	qsort(filelist, filecount, sizeof(FILEENTRIES), FileSortCallback);
+	qsort(browserList, filecount, sizeof(BROWSERENTRY), FileSortCallback);
 
 	return filecount;
 }
 
+/****************************************************************************
+ * SetDVDdirectory
+ * Set the current DVD file offset
+ ***************************************************************************/
+
+void SetDVDdirectory(u64 dir, int length)
+{
+	dvddir = dir;
+	dvddirlength = length;
+}
+
 /****************************************************************************
  * DirectorySearch
  *
  * Searches for the directory name specified within the current directory
  * Returns the index of the directory, or -1 if not found
  ***************************************************************************/
-int DirectorySearch(char dir[512])
+static int DirectorySearch(char dir[512])
 {
-	for (int i = 0; i < maxfiles; i++ )
+	for (int i = 0; i < browser.numEntries; i++ )
-		if (strcmp(filelist[i].filename, dir) == 0)
+		if (strcmp(browserList[i].filename, dir) == 0)
 			return i;
 	return -1;
 }
 
 /****************************************************************************
- * SwitchDVDFolder
+ * SwitchDVDFolderR
  *
  * Recursively searches for any directory path 'dir' specified
  * Also can be used to find and set the offset for a file
  * Also loads the directory contents via ParseDVDdirectory()
  * It relies on dvddir, dvddirlength, and filelist being pre-populated
  ***************************************************************************/
-bool SwitchDVDFolder(char * dir, int maxDepth)
+static bool SwitchDVDFolderR(char * dir, int maxDepth)
 {
 	if(maxDepth > 8) // only search to a max depth of 8 levels
 		return false;
@@ -544,17 +572,17 @@ bool SwitchDVDFolder(char * dir, int maxDepth)
 
 	if(dirindex >= 0)
 	{
-		dvddir = filelist[dirindex].offset;
+		dvddir = browserList[dirindex].offset;
-		dvddirlength = filelist[dirindex].length;
+		dvddirlength = browserList[dirindex].length;
-		selection = dirindex;
+		browser.selIndex = dirindex;
 
-		if(filelist[dirindex].flags) // only parse directories
+		if(browserList[dirindex].isdir) // only parse directories
-			maxfiles = ParseDVDdirectory();
+			browser.numEntries = ParseDVDdirectory();
 
 		if(lastdir)
 			return true;
 		else
-			return SwitchDVDFolder(nextdir, maxDepth++);
+			return SwitchDVDFolderR(nextdir, maxDepth++);
 	}
 	return false;
 }
@@ -574,21 +602,18 @@ bool SwitchDVDFolder(char origdir[])
 	if(dir[strlen(dir)-1] == '/')
 		dir[strlen(dir)-1] = 0;
 
-	// start at root of DVD
+	// start searching at root of DVD
 	dvddir = dvdrootdir;
 	dvddirlength = dvdrootlength;
 	ParseDVDdirectory();
 
-	return SwitchDVDFolder(dirptr, 0);
+	return SwitchDVDFolderR(dirptr, 0);
 }
 
 /****************************************************************************
- * LoadDVDFile
+ * LoadDVDFileOffset
  * This function will load a file from DVD
- * The values for offset and length are inherited from dvddir and
+ * It assumes dvddir and dvddirlength are prepopulated
- * dvddirlength.
- *
- * The buffer parameter should re-use the initial ROM buffer
  ***************************************************************************/
 
 int
@@ -650,6 +675,13 @@ LoadDVDFileOffset (unsigned char *buffer, int length)
 	return dvddirlength;
 }
 
+/****************************************************************************
+ * LoadDVDFile
+ * This function will load a file from DVD, given a filepath
+ * It will attempt to find the offset of the file, and if successful it
+ * will populate dvddir and dvddirlength, and load the file
+ ***************************************************************************/
+
 int
 LoadDVDFile(char * buffer, char *filepath, int datasize, bool silent)
 {

source/ngc/dvd.h

@@ -11,20 +11,18 @@
 #ifndef _NGCDVD_
 #define _NGCDVD_
 
-int getpvd ();
 bool MountDVD(bool silent);
-int ParseDVDdirectory ();
+int ParseDVDdirectory();
+void SetDVDdirectory(u64 dir, int length);
+bool SwitchDVDFolder(char dir[]);
+
 int LoadDVDFileOffset(unsigned char *buffer, int length);
 int LoadDVDFile(char * buffer, char *filepath, int datasize, bool silent);
-int dvd_read (void *dst, unsigned int len, u64 offset);
 int dvd_safe_read (void *dst, unsigned int len, u64 offset);
-bool SwitchDVDFolder(char dir[]);
+
 void SetDVDDriveType();
 #ifdef HW_DOL
 void dvd_motor_off ();
 #endif
 
-extern u64 dvddir;
-extern int dvddirlength;
-
 #endif

source/ngc/fileop.cpp

@@ -16,6 +16,7 @@
 #include <sys/dir.h>
 #include <sys/stat.h>
 #include <zlib.h>
+#include <malloc.h>
 #include <sdcard/wiisd_io.h>
 #include <sdcard/gcsd.h>
 #include <ogc/usbstorage.h>
@@ -32,8 +33,8 @@
 #include "filesel.h"
 #include "preferences.h"
 
-// file pointer - the only one we should ever use!
+unsigned char * savebuffer = NULL;
-FILE * file;
+FILE * file; // file pointer - the only one we should ever use!
 bool unmountRequired[9] = { false, false, false, false, false, false, false, false, false };
 bool isMounted[9] = { false, false, false, false, false, false, false, false, false };
 
@@ -255,7 +256,6 @@ bool ChangeInterface(int method, bool silent)
 int
 ParseDirectory()
 {
-	int nbfiles = 0;
 	DIR_ITER *dir;
 	char fulldir[MAXPATHLEN];
 	char filename[MAXPATHLEN];
@@ -263,14 +263,11 @@ ParseDirectory()
 	struct stat filestat;
 	char msg[128];
 
-	// initialize selection
+	// reset browser
-	selection = offset = 0;
+	ResetBrowser();
-
-	// Clear any existing values
-	memset (&filelist, 0, sizeof (FILEENTRIES) * MAXFILES);
 
 	// add device to path
-	sprintf(fulldir, "%s%s", rootdir, currentdir);
+	sprintf(fulldir, "%s%s", rootdir, browser.dir);
 
 	// open the directory
 	dir = diropen(fulldir);
@@ -283,7 +280,7 @@ ParseDirectory()
 		// if we can't open the dir, open root dir
 		sprintf(fulldir,"%s",rootdir);
 
-		dir = diropen(currentdir);
+		dir = diropen(browser.dir);
 
 		if (dir == NULL)
 		{
@@ -294,17 +291,29 @@ ParseDirectory()
 	}
 
 	// index files/folders
+	int entryNum = 0;
+
 	while(dirnext(dir,filename,&filestat) == 0)
 	{
 		if(strcmp(filename,".") != 0)
 		{
-			memset(&filelist[nbfiles], 0, sizeof(FILEENTRIES));
+			browserList = (BROWSERENTRY *)realloc(browserList, (entryNum+1) * sizeof(BROWSERENTRY));
-			strncpy(filelist[nbfiles].filename, filename, MAXPATHLEN);
+
+			if(!browserList) // failed to allocate required memory
+			{
+				WaitPrompt("Out of memory: too many files!");
+				entryNum = 0;
+				break;
+			}
+			memset(&(browserList[entryNum]), 0, sizeof(BROWSERENTRY)); // clear the new entry
+
+			strncpy(browserList[entryNum].filename, filename, MAXJOLIET);
 			StripExt(tmpname, filename); // hide file extension
-			strncpy(filelist[nbfiles].displayname, tmpname, MAXDISPLAY+1);	// crop name for display
+			strncpy(browserList[entryNum].displayname, tmpname, MAXDISPLAY);	// crop name for display
-			filelist[nbfiles].length = filestat.st_size;
+			browserList[entryNum].length = filestat.st_size;
-			filelist[nbfiles].flags = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
+			browserList[entryNum].isdir = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
-			nbfiles++;
+
+			entryNum++;
 		}
 	}
 
@@ -312,9 +321,36 @@ ParseDirectory()
 	dirclose(dir);
 
 	// Sort the file list
-	qsort(filelist, nbfiles, sizeof(FILEENTRIES), FileSortCallback);
+	qsort(browserList, entryNum, sizeof(BROWSERENTRY), FileSortCallback);
 
-	return nbfiles;
+	return entryNum;
+}
+
+/****************************************************************************
+ * AllocSaveBuffer ()
+ * Clear and allocate the savebuffer
+ ***************************************************************************/
+void
+AllocSaveBuffer ()
+{
+	if (savebuffer != NULL)
+		free(savebuffer);
+
+	savebuffer = (unsigned char *) memalign(32, SAVEBUFFERSIZE);
+	memset (savebuffer, 0, SAVEBUFFERSIZE);
+}
+
+/****************************************************************************
+ * FreeSaveBuffer ()
+ * Free the savebuffer memory
+ ***************************************************************************/
+void
+FreeSaveBuffer ()
+{
+	if (savebuffer != NULL)
+		free(savebuffer);
+
+	savebuffer = NULL;
 }
 
 /****************************************************************************
@@ -334,7 +370,7 @@ LoadSzFile(char * filepath, unsigned char * rbuffer)
 	file = fopen (filepath, "rb");
 	if (file > 0)
 	{
-		size = SzExtractFile(filelist[selection].offset, rbuffer);
+		size = SzExtractFile(browserList[browser.selIndex].offset, rbuffer);
 		fclose (file);
 	}
 	else

source/ngc/fileop.h

@@ -18,18 +18,22 @@
 #include <fat.h>
 #include <unistd.h>
 
+#define SAVEBUFFERSIZE (1024 * 1024 * 2)
+
 void InitDeviceThread();
 void MountAllFAT();
 void UnmountAllFAT();
 bool ChangeInterface(int method, bool silent);
 int ParseDirectory();
+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 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);
 
-extern char currdir[MAXPATHLEN];
+extern unsigned char * savebuffer;
 extern FILE * file;
 extern bool unmountRequired[];
 extern bool isMounted[];

source/ngc/filesel.cpp

@@ -16,7 +16,7 @@
 #include <sys/dir.h>
 #include <malloc.h>
 
-#ifdef WII_DVD
+#ifdef HW_RVL
 extern "C" {
 #include <di/di.h>
 }
@@ -28,62 +28,23 @@ extern "C" {
 #include "menudraw.h"
 #include "video.h"
 #include "fileop.h"
+#include "filesel.h"
 #include "memcardop.h"
 #include "input.h"
 #include "dvd.h"
 #include "networkop.h"
 #include "gcunzip.h"
 
-int offset;
+BROWSERINFO browser;
-int selection;
+BROWSERENTRY * browserList = NULL; // list of files/folders in browser
+
 char rootdir[10];
-char currentdir[MAXPATHLEN];
 char szpath[MAXPATHLEN];
-int maxfiles;
-extern int screenheight;
-
-int havedir = -1;
-extern u64 dvddir;
-extern int dvddirlength;
-
-int hasloaded = 0;
-
-// Global file entry table
-FILEENTRIES filelist[MAXFILES];
 bool inSz = false;
 
 char ROMFilename[512];
 bool ROMLoaded = false;
 
-unsigned char *savebuffer = NULL;
-
-/****************************************************************************
- * AllocSaveBuffer ()
- * Clear and allocate the savebuffer
- ***************************************************************************/
-void
-AllocSaveBuffer ()
-{
-	if (savebuffer != NULL)
-		free(savebuffer);
-
-	savebuffer = (unsigned char *) memalign(32, SAVEBUFFERSIZE);
-	memset (savebuffer, 0, SAVEBUFFERSIZE);
-}
-
-/****************************************************************************
- * FreeSaveBuffer ()
- * Free the savebuffer memory
- ***************************************************************************/
-void
-FreeSaveBuffer ()
-{
-	if (savebuffer != NULL)
-		free(savebuffer);
-
-	savebuffer = NULL;
-}
-
 /****************************************************************************
 * autoLoadMethod()
 * Auto-determines and sets the load method
@@ -141,6 +102,25 @@ int autoSaveMethod(bool silent)
 	return method;
 }
 
+/****************************************************************************
+ * ResetBrowser()
+ * Clears the file browser memory, and allocates one initial entry
+ ***************************************************************************/
+void ResetBrowser()
+{
+	browser.selIndex = browser.pageIndex = 0;
+
+	// Clear any existing values
+	if(browserList != NULL)
+	{
+		free(browserList);
+		browserList = NULL;
+	}
+	// set aside space for 1 entry
+	browserList = (BROWSERENTRY *)malloc(sizeof(BROWSERENTRY));
+	memset(browserList, 0, sizeof(BROWSERENTRY));
+}
+
 /****************************************************************************
  * UpdateDirName()
  * Update curent directory name for file browser
@@ -153,21 +133,18 @@ int UpdateDirName(int method)
 
 	// update DVD directory
 	if(method == METHOD_DVD)
-	{
+		SetDVDdirectory(browserList[browser.selIndex].offset, browserList[browser.selIndex].length);
-		dvddir = filelist[selection].offset;
-		dvddirlength = filelist[selection].length;
-	}
 
 	/* current directory doesn't change */
-	if (strcmp(filelist[selection].filename,".") == 0)
+	if (strcmp(browserList[browser.selIndex].filename,".") == 0)
 	{
 		return 0;
 	}
 	/* go up to parent directory */
-	else if (strcmp(filelist[selection].filename,"..") == 0)
+	else if (strcmp(browserList[browser.selIndex].filename,"..") == 0)
 	{
 		/* determine last subdirectory namelength */
-		sprintf(temp,"%s",currentdir);
+		sprintf(temp,"%s",browser.dir);
 		test = strtok(temp,"/");
 		while (test != NULL)
 		{
@@ -176,8 +153,8 @@ int UpdateDirName(int method)
 		}
 
 		/* remove last subdirectory name */
-		size = strlen(currentdir) - size - 1;
+		size = strlen(browser.dir) - size - 1;
-		currentdir[size] = 0;
+		browser.dir[size] = 0;
 
 		return 1;
 	}
@@ -185,10 +162,10 @@ int UpdateDirName(int method)
 	else
 	{
 		/* test new directory namelength */
-		if ((strlen(currentdir)+1+strlen(filelist[selection].filename)) < MAXPATHLEN)
+		if ((strlen(browser.dir)+1+strlen(browserList[browser.selIndex].filename)) < MAXPATHLEN)
 		{
 			/* update current directory name */
-			sprintf(currentdir, "%s/%s",currentdir, filelist[selection].filename);
+			sprintf(browser.dir, "%s/%s",browser.dir, browserList[browser.selIndex].filename);
 			return 1;
 		}
 		else
@@ -208,7 +185,7 @@ bool MakeFilePath(char filepath[], int type, int method)
 	if(type == FILE_ROM)
 	{
 		// Check path length
-		if ((strlen(currentdir)+1+strlen(filelist[selection].filename)) >= MAXPATHLEN)
+		if ((strlen(browser.dir)+1+strlen(browserList[browser.selIndex].filename)) >= MAXPATHLEN)
 		{
 			WaitPrompt("Maximum filepath length reached!");
 			filepath[0] = 0;
@@ -216,7 +193,7 @@ bool MakeFilePath(char filepath[], int type, int method)
 		}
 		else
 		{
-			sprintf(temppath, "%s/%s",currentdir,filelist[selection].filename);
+			sprintf(temppath, "%s/%s",browser.dir,browserList[browser.selIndex].filename);
 		}
 	}
 	else
@@ -268,19 +245,19 @@ bool MakeFilePath(char filepath[], int type, int method)
 int FileSortCallback(const void *f1, const void *f2)
 {
 	/* Special case for implicit directories */
-	if(((FILEENTRIES *)f1)->filename[0] == '.' || ((FILEENTRIES *)f2)->filename[0] == '.')
+	if(((BROWSERENTRY *)f1)->filename[0] == '.' || ((BROWSERENTRY *)f2)->filename[0] == '.')
 	{
-		if(strcmp(((FILEENTRIES *)f1)->filename, ".") == 0) { return -1; }
+		if(strcmp(((BROWSERENTRY *)f1)->filename, ".") == 0) { return -1; }
-		if(strcmp(((FILEENTRIES *)f2)->filename, ".") == 0) { return 1; }
+		if(strcmp(((BROWSERENTRY *)f2)->filename, ".") == 0) { return 1; }
-		if(strcmp(((FILEENTRIES *)f1)->filename, "..") == 0) { return -1; }
+		if(strcmp(((BROWSERENTRY *)f1)->filename, "..") == 0) { return -1; }
-		if(strcmp(((FILEENTRIES *)f2)->filename, "..") == 0) { return 1; }
+		if(strcmp(((BROWSERENTRY *)f2)->filename, "..") == 0) { return 1; }
 	}
 
 	/* If one is a file and one is a directory the directory is first. */
-	if(((FILEENTRIES *)f1)->flags && !(((FILEENTRIES *)f2)->flags)) return -1;
+	if(((BROWSERENTRY *)f1)->isdir && !(((BROWSERENTRY *)f2)->isdir)) return -1;
-	if(!(((FILEENTRIES *)f1)->flags) && ((FILEENTRIES *)f2)->flags) return 1;
+	if(!(((BROWSERENTRY *)f1)->isdir) && ((BROWSERENTRY *)f2)->isdir) return 1;
 
-	return stricmp(((FILEENTRIES *)f1)->filename, ((FILEENTRIES *)f2)->filename);
+	return stricmp(((BROWSERENTRY *)f1)->filename, ((BROWSERENTRY *)f2)->filename);
 }
 
 /****************************************************************************
@@ -291,9 +268,9 @@ int FileSortCallback(const void *f1, const void *f2)
 
 bool IsSz()
 {
-	if (strlen(filelist[selection].filename) > 4)
+	if (strlen(browserList[browser.selIndex].filename) > 4)
 	{
-		char * p = strrchr(filelist[selection].filename, '.');
+		char * p = strrchr(browserList[browser.selIndex].filename, '.');
 
 		if (p != NULL)
 			if(stricmp(p, ".7z") == 0)
@@ -346,7 +323,7 @@ int FileSelector (int method)
     while (haverom == 0)
     {
         if (redraw)
-            ShowFiles (filelist, maxfiles, offset, selection);
+            ShowFiles (browserList, browser.numEntries, browser.pageIndex, browser.selIndex);
         redraw = 0;
 
 		VIDEO_WaitVSync();	// slow things down a bit so we don't overread the pads
@@ -373,19 +350,16 @@ int FileSelector (int method)
 		{
 			if ( selectit )
 				selectit = 0;
-			if (filelist[selection].flags) // This is directory
+			if (browserList[browser.selIndex].isdir) // This is directory
 			{
 				/* update current directory and set new entry list if directory has changed */
 				int status;
 
-				if(inSz && selection == 0) // inside a 7z, requesting to leave
+				if(inSz && browser.selIndex == 0) // inside a 7z, requesting to leave
 				{
 					if(method == METHOD_DVD)
-					{
+						SetDVDdirectory(browserList[0].offset, browserList[0].length);
-						// go to directory the 7z was in
+
-						dvddir = filelist[0].offset;
-						dvddirlength = filelist[0].length;
-					}
 					inSz = false;
 					status = 1;
 					SzClose();
@@ -400,15 +374,15 @@ int FileSelector (int method)
 					switch (method)
 					{
 						case METHOD_DVD:
-							maxfiles = ParseDVDdirectory();
+							browser.numEntries = ParseDVDdirectory();
 							break;
 
 						default:
-							maxfiles = ParseDirectory();
+							browser.numEntries = ParseDirectory();
 							break;
 					}
 
-					if (!maxfiles)
+					if (!browser.numEntries)
 					{
 						WaitPrompt ("Error reading directory!");
 						haverom = 1; // quit menu
@@ -436,7 +410,7 @@ int FileSelector (int method)
 					int szfiles = SzParse(szpath, method);
 					if(szfiles)
 					{
-						maxfiles = szfiles;
+						browser.numEntries = szfiles;
 						inSz = true;
 					}
 					else
@@ -445,7 +419,7 @@ int FileSelector (int method)
 				else
 				{
 					// store the filename (w/o ext) - used for sram/freeze naming
-					StripExt(ROMFilename, filelist[selection].filename);
+					StripExt(ROMFilename, browserList[browser.selIndex].filename);
 
 					ShowAction ("Loading...");
 
@@ -468,14 +442,14 @@ int FileSelector (int method)
 #endif
 					)
                 VIDEO_WaitVSync();
-			if ( strcmp(filelist[0].filename,"..") == 0 )
+			if ( strcmp(browserList[0].filename,"..") == 0 )
 			{
-				selection = 0;
+				browser.selIndex = 0;
 				selectit = 1;
 			}
-			else if ( strcmp(filelist[1].filename,"..") == 0 )
+			else if ( strcmp(browserList[1].filename,"..") == 0 )
 			{
-                selection = selectit = 1;
+                browser.selIndex = selectit = 1;
 			} else {
                 return 0;
 			}
@@ -495,11 +469,11 @@ int FileSelector (int method)
 
 			if (move_selection)
 			{
-	            selection++;
+	            browser.selIndex++;
-	            if (selection == maxfiles)
+	            if (browser.selIndex == browser.numEntries)
-	                selection = offset = 0;
+	                browser.selIndex = browser.pageIndex = 0;
-	            if ((selection - offset) >= PAGESIZE)
+	            if ((browser.selIndex - browser.pageIndex) >= PAGESIZE)
-	                offset += PAGESIZE;
+	                browser.pageIndex += PAGESIZE;
 	            redraw = 1;
 				move_selection = 0;
 			}
@@ -519,15 +493,15 @@ int FileSelector (int method)
 
 			if (move_selection)
 			{
-	            selection--;
+	            browser.selIndex--;
-	            if (selection < 0) {
+	            if (browser.selIndex < 0) {
-	                selection = maxfiles - 1;
+	                browser.selIndex = browser.numEntries - 1;
-	                offset = selection - PAGESIZE + 1;
+	                browser.pageIndex = browser.selIndex - PAGESIZE + 1;
 	            }
-	            if (selection < offset)
+	            if (browser.selIndex < browser.pageIndex)
-	                offset -= PAGESIZE;
+	                browser.pageIndex -= PAGESIZE;
-	            if (offset < 0)
+	            if (browser.pageIndex < 0)
-	                offset = 0;
+	                browser.pageIndex = 0;
 	            redraw = 1;
 				move_selection = 0;
 			}
@@ -535,26 +509,26 @@ int FileSelector (int method)
         if ( (p & PAD_BUTTON_LEFT) || (wp & (WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT)) )
         {
             /*** Go back a page ***/
-            selection -= PAGESIZE;
+            browser.selIndex -= PAGESIZE;
-            if (selection < 0)
+            if (browser.selIndex < 0)
             {
-                selection = maxfiles - 1;
+                browser.selIndex = browser.numEntries - 1;
-                offset = selection - PAGESIZE + 1;
+                browser.pageIndex = browser.selIndex - PAGESIZE + 1;
             }
-            if (selection < offset)
+            if (browser.selIndex < browser.pageIndex)
-                offset -= PAGESIZE;
+                browser.pageIndex -= PAGESIZE;
-            if (offset < 0)
+            if (browser.pageIndex < 0)
-                offset = 0;
+                browser.pageIndex = 0;
             redraw = 1;
         }
         if ( (p & PAD_BUTTON_RIGHT) || (wp & (WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT)) )
         {
             /*** Go forward a page ***/
-            selection += PAGESIZE;
+            browser.selIndex += PAGESIZE;
-            if (selection > maxfiles - 1)
+            if (browser.selIndex > browser.numEntries - 1)
-                selection = offset = 0;
+                browser.selIndex = browser.pageIndex = 0;
-            if ((selection - offset) >= PAGESIZE)
+            if ((browser.selIndex - browser.pageIndex) >= PAGESIZE)
-                offset += PAGESIZE;
+                browser.pageIndex += PAGESIZE;
             redraw = 1;
         }
     }
@@ -578,17 +552,17 @@ OpenROM (int method)
 		switch(method)
 		{
 			case METHOD_DVD:
-				currentdir[0] = 0;
+				browser.dir[0] = 0;
-				maxfiles = ParseDVDdirectory (); // Parse root directory
+				browser.numEntries = ParseDVDdirectory(); // Parse root directory
 				SwitchDVDFolder(GCSettings.LoadFolder); // switch to ROM folder
 				break;
 			default:
-				sprintf(currentdir, "/%s", GCSettings.LoadFolder);
+				sprintf(browser.dir, "/%s", GCSettings.LoadFolder);
-				maxfiles = ParseDirectory(); // Parse root directory
+				browser.numEntries = ParseDirectory(); // Parse root directory
 				break;
 		}
 
-		if (maxfiles > 0)
+		if (browser.numEntries > 0)
 		{
 			// Select an entry
 			return FileSelector (method);

source/ngc/filesel.h

@@ -13,38 +13,40 @@
 
 #include <unistd.h>
 
-#define SAVEBUFFERSIZE (1024 * 1024 * 2)
 #define MAXJOLIET 255
 #define MAXDISPLAY 40
 
 typedef struct
 {
-  u64 offset;
+	char dir[MAXPATHLEN]; // directory path of browserList
-  unsigned int length;
+	int numEntries; // # of entries in browserList
-  char flags;
+	int selIndex; // currently selected index of browserList
-  char filename[MAXJOLIET + 1];
+	int pageIndex; // starting index of browserList page display
-  char displayname[MAXDISPLAY + 1];
+} BROWSERINFO;
-} FILEENTRIES;
 
-#define MAXFILES 2000 // Restrict to 2000 files per dir
+typedef struct
-extern FILEENTRIES filelist[MAXFILES];
+{
-extern unsigned char *savebuffer;
+	u64 offset; // DVD offset
-extern int offset;
+	unsigned int length; // file length
-extern int selection;
+	char isdir; // 0 - file, 1 - directory
+	char filename[MAXJOLIET + 1]; // full filename
+	char displayname[MAXDISPLAY + 1]; // name for browser display
+} BROWSERENTRY;
+
+extern BROWSERINFO browser;
+extern BROWSERENTRY * browserList;
 extern char rootdir[10];
-extern char currentdir[MAXPATHLEN];
 extern char szpath[MAXPATHLEN];
 extern bool inSz;
-extern int maxfiles;
 extern char ROMFilename[512];
 
-void AllocSaveBuffer();
-void FreeSaveBuffer();
 bool MakeFilePath(char filepath[], int type, int method);
 int OpenROM (int method);
 int autoLoadMethod();
 int autoSaveMethod(bool silent);
 int FileSortCallback(const void *f1, const void *f2);
 void StripExt(char* returnstring, char * inputstring);
+void ResetBrowser();
+
 
 #endif

source/ngc/gcunzip.cpp

@@ -28,18 +28,32 @@ extern "C" {
 #include "gcunzip.h"
 #include "vba.h"
 
-/*
-  * PKWare Zip Header - adopted into zip standard
-  */
-#define PKZIPID 0x504b0304
-#define MAXROM 0x500000
 #define ZIPCHUNK 2048
 
+/*
+ * Zip file header definition
+ */
+typedef struct
+{
+  unsigned int zipid __attribute__ ((__packed__));	// 0x04034b50
+  unsigned short zipversion __attribute__ ((__packed__));
+  unsigned short zipflags __attribute__ ((__packed__));
+  unsigned short compressionMethod __attribute__ ((__packed__));
+  unsigned short lastmodtime __attribute__ ((__packed__));
+  unsigned short lastmoddate __attribute__ ((__packed__));
+  unsigned int crc32 __attribute__ ((__packed__));
+  unsigned int compressedSize __attribute__ ((__packed__));
+  unsigned int uncompressedSize __attribute__ ((__packed__));
+  unsigned short filenameLength __attribute__ ((__packed__));
+  unsigned short extraDataLength __attribute__ ((__packed__));
+}
+PKZIPHEADER;
+
 /*
  * Zip files are stored little endian
  * Support functions for short and int types
  */
-u32
+static u32
 FLIP32 (u32 b)
 {
 	unsigned int c;
@@ -52,7 +66,7 @@ FLIP32 (u32 b)
 	return c;
 }
 
-u16
+static u16
 FLIP16 (u16 b)
 {
 	u16 c;
@@ -66,7 +80,7 @@ FLIP16 (u16 b)
 /****************************************************************************
  * IsZipFile
  *
- * Returns TRUE when PKZIPID is first four characters of buffer
+ * Returns TRUE when 0x504b0304 is first four characters of buffer
  ***************************************************************************/
 int
 IsZipFile (char *buffer)
@@ -75,7 +89,7 @@ IsZipFile (char *buffer)
 
 	check = (unsigned int *) buffer;
 
-	if (check[0] == PKZIPID)
+	if (check[0] == 0x504b0304)
 		return 1;
 
 	return 0;
@@ -83,8 +97,6 @@ IsZipFile (char *buffer)
 
 /*****************************************************************************
 * UnZipBuffer
-*
-* It should be noted that there is a limit of 5MB total size for any ROM
 ******************************************************************************/
 
 int
@@ -100,15 +112,13 @@ UnZipBuffer (unsigned char *outbuffer, int method)
 	int readoffset = 0;
 	int have = 0;
 	char readbuffer[ZIPCHUNK];
-	u64 discoffset = 0;
 	int sizeread = 0;
 
 	// Read Zip Header
 	switch (method)
 	{
 		case METHOD_DVD:
-			discoffset = dvddir;
+			sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, 0);
-			sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, discoffset);
 			break;
 		default:
 			fseek(file, 0, SEEK_SET);
@@ -182,7 +192,7 @@ UnZipBuffer (unsigned char *outbuffer, int method)
 		{
 			case METHOD_DVD:
 				readoffset += ZIPCHUNK;
-				sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, discoffset+readoffset);
+				sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, readoffset);
 				break;
 			default:
 				sizeread = fread (readbuffer, 1, ZIPCHUNK, file);
@@ -258,7 +268,7 @@ typedef struct _SzFileInStream
 } SzFileInStream;
 
 // 7zip error list
-char szerrormsg[][30] = {
+static char szerrormsg[][30] = {
    "7z: Data error",
    "7z: Out of memory",
    "7z: CRC Error",
@@ -269,20 +279,19 @@ char szerrormsg[][30] = {
    "7z: Dictionary too large",
 };
 
-SZ_RESULT SzRes;
+static SZ_RESULT SzRes;
+static SzFileInStream SzArchiveStream;
+static CArchiveDatabaseEx SzDb;
+static ISzAlloc SzAllocImp;
+static ISzAlloc SzAllocTempImp;
+static UInt32 SzBlockIndex = 0xFFFFFFFF;
+static size_t SzBufferSize;
+static size_t SzOffset;
+static size_t SzOutSizeProcessed;
+static CFileItem *SzF;
 
-SzFileInStream SzArchiveStream;
+static char sz_buffer[2048];
-CArchiveDatabaseEx SzDb;
+static int szMethod = 0;
-ISzAlloc SzAllocImp;
-ISzAlloc SzAllocTempImp;
-UInt32 SzBlockIndex = 0xFFFFFFFF;
-size_t SzBufferSize;
-size_t SzOffset;
-size_t SzOutSizeProcessed;
-CFileItem *SzF;
-
-char sz_buffer[2048];
-int szMethod = 0;
 
 /****************************************************************************
 * Is7ZipFile
@@ -307,13 +316,13 @@ Is7ZipFile (char *buffer)
 }
 
 // display an error message
-void SzDisplayError(SZ_RESULT res)
+static void SzDisplayError(SZ_RESULT res)
 {
 	WaitPrompt(szerrormsg[(res - 1)]);
 }
 
 // function used by the 7zip SDK to read data from SD/USB/DVD/SMB
-SZ_RESULT SzFileReadImp(void *object, void **buffer, size_t maxRequiredSize, size_t *processedSize)
+static SZ_RESULT SzFileReadImp(void *object, void **buffer, size_t maxRequiredSize, size_t *processedSize)
 {
 	u32 seekok = 0;
 	u32 sizeread = 0;
@@ -340,12 +349,7 @@ SZ_RESULT SzFileReadImp(void *object, void **buffer, size_t maxRequiredSize, siz
 	}
 
 	if(seekok != 0 || sizeread <= 0)
-	{
-		char msg[150];
-		sprintf(msg, "sizeread: %u", sizeread);
-		WaitPrompt(msg);
 		return SZE_FAILREAD;
-	}
 
 	*buffer = sz_buffer;
 	*processedSize = maxRequiredSize;
@@ -353,13 +357,13 @@ SZ_RESULT SzFileReadImp(void *object, void **buffer, size_t maxRequiredSize, siz
 
 	if(maxRequiredSize > 1024) // only show progress for large reads
 		// this isn't quite right, but oh well
-		ShowProgress ("Loading...", s->pos, filelist[selection].length);
+		ShowProgress ("Loading...", s->pos, browserList[browser.selIndex].length);
 
 	return SZ_OK;
 }
 
 // function used by the 7zip SDK to change the filepointer
-SZ_RESULT SzFileSeekImp(void *object, CFileSize pos)
+static SZ_RESULT SzFileSeekImp(void *object, CFileSize pos)
 {
 	// the void* object is a SzFileInStream
 	SzFileInStream *s = (SzFileInStream *) object;
@@ -377,17 +381,23 @@ SZ_RESULT SzFileSeekImp(void *object, CFileSize pos)
 * SzParse
 *
 * Opens a 7z file, and parses it
-* Right now doesn't parse 7z, since we'll always use the first file
+* It parses the entire 7z for full browsing capability
-* But it could parse the entire 7z for full browsing capability
 ***************************************************************************/
 
 int SzParse(char * filepath, int method)
 {
+	if(!filepath)
+		return 0;
+
 	int nbfiles = 0;
 
-	// save the offset and the length of this file inside the archive stream structure
+	// save the length/offset of this file
-	SzArchiveStream.offset = filelist[selection].offset;
+	unsigned int filelen = browserList[browser.selIndex].length;
-	SzArchiveStream.len = filelist[selection].length;
+	u64 fileoff = browserList[browser.selIndex].offset;
+
+	// setup archive stream
+	SzArchiveStream.offset = 0;
+	SzArchiveStream.len = filelen;
 	SzArchiveStream.pos = 0;
 
 	// open file
@@ -400,6 +410,9 @@ int SzParse(char * filepath, int method)
 			if(!file)
 				return 0;
 			break;
+		case METHOD_DVD:
+			SwitchDVDFolder(filepath);
+			break;
 	}
 
 	// set szMethod to current chosen load method
@@ -435,14 +448,14 @@ int SzParse(char * filepath, int method)
 		{
 			// Parses the 7z into a full file listing
 
-			// erase all previous entries
+			// reset browser
-			memset(&filelist, 0, sizeof(FILEENTRIES) * MAXFILES);
+			ResetBrowser();
 
 			// add '..' folder in case the user wants exit the 7z
-			strncpy(filelist[0].displayname, "..", 2);
+			strncpy(browserList[0].displayname, "..", 2);
-			filelist[0].flags = 1;
+			browserList[0].isdir = 1;
-			filelist[0].offset = dvddir;
+			browserList[0].offset = fileoff;
-			filelist[0].length = dvddirlength;
+			browserList[0].length = filelen;
 
 			// get contents and parse them into file list structure
 			unsigned int SzI, SzJ;
@@ -455,22 +468,25 @@ int SzParse(char * filepath, int method)
 				if (SzF->IsDirectory)
 					continue;
 
-				// do not exceed MAXFILES to avoid possible buffer overflows
+				browserList = (BROWSERENTRY *)realloc(browserList, (SzJ+1) * sizeof(BROWSERENTRY));
-				if (SzJ == (MAXFILES - 1))
+
+				if(!browserList) // failed to allocate required memory
+				{
+					WaitPrompt("Out of memory: too many files!");
+					nbfiles = 0;
 					break;
+				}
+				memset(&(browserList[SzJ]), 0, sizeof(BROWSERENTRY)); // clear the new entry
 
 				// parse information about this file to the dvd file list structure
-				strncpy(filelist[SzJ].filename, SzF->Name, MAXJOLIET); // copy joliet name (useless...)
+				strncpy(browserList[SzJ].filename, SzF->Name, MAXJOLIET); // copy joliet name (useless...)
-				filelist[SzJ].filename[MAXJOLIET] = 0; // terminate string
+				strncpy(browserList[SzJ].displayname, SzF->Name, MAXDISPLAY);	// crop name for display
-				strncpy(filelist[SzJ].displayname, SzF->Name, MAXDISPLAY+1);	// crop name for display
+				browserList[SzJ].length = SzF->Size; // filesize
-				filelist[SzJ].length = SzF->Size; // filesize
+				browserList[SzJ].offset = SzI; // the extraction function identifies the file with this number
-				filelist[SzJ].offset = SzI; // the extraction function identifies the file with this number
+				browserList[SzJ].isdir = 0; // only files will be displayed (-> no flags)
-				filelist[SzJ].flags = 0; // only files will be displayed (-> no flags)
 				SzJ++;
 			}
 
-			// update maxfiles and select the first entry
-			offset = selection = 0;
 			nbfiles = SzJ;
 		}
 		else

source/ngc/gcunzip.h

@@ -3,14 +3,12 @@
  *
  * Tantric September 2008
  *
- * unzip.h
+ * gcunzip.h
  *
  * File unzip routines
  ***************************************************************************/
-#ifndef _UNZIP_
+#ifndef _GCUNZIP_H_
-#define _UNZIP_
+#define _GCUNZIP_H_
-
-#include <smb.h>
 
 int IsZipFile (char *buffer);
 char * GetFirstZipFilename(int method);
@@ -19,26 +17,4 @@ int SzParse(char * filepath, int method);
 int SzExtractFile(int i, unsigned char *buffer);
 void SzClose();
 
-/*
- * Zip file header definition
- */
-typedef struct
-{
-  unsigned int zipid __attribute__ ((__packed__));	// 0x04034b50
-  unsigned short zipversion __attribute__ ((__packed__));
-  unsigned short zipflags __attribute__ ((__packed__));
-  unsigned short compressionMethod __attribute__ ((__packed__));
-  unsigned short lastmodtime __attribute__ ((__packed__));
-  unsigned short lastmoddate __attribute__ ((__packed__));
-  unsigned int crc32 __attribute__ ((__packed__));
-  unsigned int compressedSize __attribute__ ((__packed__));
-  unsigned int uncompressedSize __attribute__ ((__packed__));
-  unsigned short filenameLength __attribute__ ((__packed__));
-  unsigned short extraDataLength __attribute__ ((__packed__));
-}
-PKZIPHEADER;
-
-u32 FLIP32 (u32 b);
-u16 FLIP16 (u16 b);
-
 #endif

source/ngc/input.cpp

@@ -175,7 +175,7 @@ s8 WPAD_Stick(u8 chan, u8 right, int axis)
  * these changes to VBA
  ****************************************************************************/
 
-u32 DecodeJoy(unsigned short pad)
+static u32 DecodeJoy(unsigned short pad)
 {
 	signed char pad_x = PAD_StickX (pad);
 	signed char pad_y = PAD_StickY (pad);

source/ngc/memcardop.cpp

@@ -20,25 +20,18 @@
 #include "menudraw.h"
 #include "menu.h"
 #include "preferences.h"
-#include "memcardop.h"
 #include "fileop.h"
 
-#define VERIFBUFFERSIZE 65536
-static u8 SysArea[CARD_WORKAREA] ATTRIBUTE_ALIGN (32);
-unsigned char verifbuffer[VERIFBUFFERSIZE] ATTRIBUTE_ALIGN (32);
-card_dir CardDir;
-card_file CardFile;
-card_stat CardStatus;
-
 /****************************************************************************
  * CardFileExists
  *
  * Wrapper to search through the files on the card.
  * Returns TRUE if found.
  ***************************************************************************/
-int
+static int
 CardFileExists (char *filename, int slot)
 {
+	card_dir CardDir;
 	int CardError;
 
 	CardError = CARD_FindFirst (slot, &CardDir, TRUE);
@@ -53,6 +46,28 @@ CardFileExists (char *filename, int slot)
 	return 0;
 }
 
+/****************************************************************************
+ * MountCard
+ *
+ * Mounts the memory card in the given slot.
+ * Returns the result of the last attempted CARD_Mount command.
+ ***************************************************************************/
+static int MountCard(int cslot, bool silent, u8 * SysArea)
+{
+	int ret = -1;
+	int tries = 0;
+
+	// Mount the card
+	while ( tries < 10 && ret != 0)
+	{
+		EXI_ProbeReset ();
+		ret = CARD_Mount (cslot, &SysArea, NULL);
+		VIDEO_WaitVSync ();
+		tries++;
+	}
+	return ret;
+}
+
 /****************************************************************************
  * TestCard
  *
@@ -66,11 +81,12 @@ bool TestCard(int slot, bool silent)
 	#endif
 
 	/*** Initialize Card System ***/
+	u8 SysArea[CARD_WORKAREA] ATTRIBUTE_ALIGN (32);
 	memset (SysArea, 0, CARD_WORKAREA);
 	CARD_Init ("VBA0", "00");
 
 	/*** Try to mount the card ***/
-	if (MountCard(slot, silent) == 0)
+	if (MountCard(slot, silent, (u8 *)SysArea) == 0)
 	{
 		// Mount successful!
 		if(!silent)
@@ -97,35 +113,14 @@ bool TestCard(int slot, bool silent)
 	}
 }
 
-/****************************************************************************
- * MountCard
- *
- * Mounts the memory card in the given slot.
- * Returns the result of the last attempted CARD_Mount command.
- ***************************************************************************/
-int MountCard(int cslot, bool silent)
-{
-	int ret = -1;
-	int tries = 0;
-
-	// Mount the card
-	while ( tries < 10 && ret != 0)
-	{
-		EXI_ProbeReset ();
-		ret = CARD_Mount (cslot, SysArea, NULL);
-		VIDEO_WaitVSync ();
-		tries++;
-	}
-	return ret;
-}
-
-
 /****************************************************************************
  * Verify Memory Card file against buffer
  ***************************************************************************/
-int
+static int
 VerifyMCFile (char *buf, int slot, char *filename, int datasize)
 {
+	card_file CardFile;
+	unsigned char verifbuffer[65536] ATTRIBUTE_ALIGN (32);
 	int CardError;
 	unsigned int blocks;
 	unsigned int SectorSize;
@@ -134,11 +129,12 @@ VerifyMCFile (char *buf, int slot, char *filename, int datasize)
     int bytesread = 0;
 
 	/*** Initialize Card System ***/
+    u8 SysArea[CARD_WORKAREA] ATTRIBUTE_ALIGN (32);
 	memset (SysArea, 0, CARD_WORKAREA);
 	CARD_Init ("VBA0", "00");
 
 	/*** Try to mount the card ***/
-	CardError = MountCard(slot, NOTSILENT);
+	CardError = MountCard(slot, NOTSILENT, (u8 *)SysArea);
 
 	if (CardError == 0)
 	{
@@ -166,7 +162,7 @@ VerifyMCFile (char *buf, int slot, char *filename, int datasize)
         if (blocks > (unsigned int)datasize)
             blocks = datasize;
 
-		memset (verifbuffer, 0, VERIFBUFFERSIZE);
+        memset (verifbuffer, 0, 65536);
 		bytesleft = blocks;
 		bytesread = 0;
 		while (bytesleft > 0)
@@ -207,6 +203,7 @@ VerifyMCFile (char *buf, int slot, char *filename, int datasize)
 int
 LoadMCFile (char *buf, int slot, char *filename, bool silent)
 {
+	card_file CardFile;
 	int CardError;
 	unsigned int blocks;
 	unsigned int SectorSize;
@@ -214,11 +211,12 @@ LoadMCFile (char *buf, int slot, char *filename, bool silent)
     int bytesread = 0;
 
 	/*** Initialize Card System ***/
+    u8 SysArea[CARD_WORKAREA] ATTRIBUTE_ALIGN (32);
 	memset (SysArea, 0, CARD_WORKAREA);
 	CARD_Init ("VBA0", "00");
 
 	/*** Try to mount the card ***/
-	CardError = MountCard(slot, NOTSILENT);
+	CardError = MountCard(slot, NOTSILENT, (u8 *)SysArea);
 
 	if (CardError == 0)
 	{
@@ -272,6 +270,8 @@ LoadMCFile (char *buf, int slot, char *filename, bool silent)
 int
 SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent)
 {
+	card_file CardFile;
+	card_stat CardStatus;
 	int CardError;
 	unsigned int blocks;
 	unsigned int SectorSize;
@@ -281,11 +281,12 @@ SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent)
 		return 0;
 
 	/*** Initialize Card System ***/
+	u8 SysArea[CARD_WORKAREA] ATTRIBUTE_ALIGN (32);
 	memset (SysArea, 0, CARD_WORKAREA);
 	CARD_Init ("VBA0", "00");
 
 	/*** Try to mount the card ***/
-	CardError = MountCard(slot, NOTSILENT);
+	CardError = MountCard(slot, NOTSILENT, (u8 *)SysArea);
 
 	if (CardError == 0)
 	{

source/ngc/memcardop.h

@@ -11,10 +11,8 @@
 #ifndef _NGCMCSAVE_
 #define _NGCMCSAVE_
 
-int VerifyMCFile (char *buf, int slot, char *filename, int datasize);
 int LoadMCFile (char *buf, int slot, char *filename, bool silent);
 int SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent);
-int MountCard(int cslot, bool silent);
 bool TestCard(int slot, bool silent);
 
 #endif

source/ngc/menu.cpp

@@ -15,7 +15,7 @@
 #include <string.h>
 #include <wiiuse/wpad.h>
 
-#ifdef WII_DVD
+#ifdef HW_RVL
 extern "C" {
 #include <di/di.h>
 }
@@ -42,8 +42,6 @@ extern "C"
 #include "tbtime.h"
 }
 
-extern void DrawMenu (char items[][50], char *title, int maxitems, int selected, int fontsize);
-
 extern int menu;
 extern bool ROMLoaded;
 
@@ -51,7 +49,7 @@ extern bool ROMLoaded;
  * Load Manager
  ***************************************************************************/
 
-int
+static int
 LoadManager ()
 {
 	int loadROM = OpenROM(GCSettings.LoadMethod);
@@ -73,28 +71,29 @@ LoadManager ()
 /****************************************************************************
  * Preferences Menu
  ***************************************************************************/
-static int prefmenuCount = 12;
-static char prefmenu[][50] = {
 
-	"Load Method",
+static void
-	"Load Folder",
-	"Save Method",
-	"Save Folder",
-
-	"Auto Load",
-	"Auto Save",
-	"Verify MC Saves",
-	"Enable Zooming",
-	"Video Rendering",
-	"Video Scaling",
-
-	"Reset Preferences",
-	"Back to Main Menu"
-};
-
-void
 PreferencesMenu ()
 {
+	int prefmenuCount = 12;
+	char prefmenu[][50] = {
+
+		"Load Method",
+		"Load Folder",
+		"Save Method",
+		"Save Folder",
+
+		"Auto Load",
+		"Auto Save",
+		"Verify MC Saves",
+		"Enable Zooming",
+		"Video Rendering",
+		"Video Scaling",
+
+		"Reset Preferences",
+		"Back to Main Menu"
+	};
+
 	int ret = 0;
 	int quit = 0;
 	int oldmenu = menu;
@@ -264,7 +263,7 @@ PreferencesMenu ()
  * Game Options Menu
  ***************************************************************************/
 
-int
+static int
 GameMenu ()
 {
 	int gamemenuCount = 8;
@@ -355,7 +354,7 @@ GameMenu ()
 /****************************************************************************
  * Controller Configuration
  ***************************************************************************/
-u32
+static u32
 GetInput (u16 ctrlr_type)
 {
 	//u32 exp_type;
@@ -397,20 +396,20 @@ GetInput (u16 ctrlr_type)
 	return pressed;
 }	// end GetInput()
 
-int cfg_text_count = 7;
+static u32
-char cfg_text[][50] = {
-"Remapping          ",
-"Press Any Button",
-"on the",
-"       ",	// identify controller
-"                   ",
-"Press C-Left or",
-"Home to exit"
-};
-
-u32
 GetButtonMap(u16 ctrlr_type, char* btn_name)
 {
+	int cfg_text_count = 7;
+	char cfg_text[][50] = {
+	"Remapping          ",
+	"Press Any Button",
+	"on the",
+	"       ",	// identify controller
+	"                   ",
+	"Press C-Left or",
+	"Home to exit"
+	};
+
 	u32 pressed, previous;
 	char temp[50] = "";
 	uint k;
@@ -443,29 +442,24 @@ GetButtonMap(u16 ctrlr_type, char* btn_name)
 	return pressed;
 }	// end getButtonMap()
 
-int cfg_btns_count = 11;
+static void
-char cfg_btns_menu[][50] = {
-	"B        -         ",
-	"A        -         ",
-	"SELECT   -         ",
-	"START    -         ",
-	"UP       -         ",
-	"DOWN     -         ",
-	"LEFT     -         ",
-	"RIGHT    -         ",
-	"L TRIG   -         ",
-	"R TRIG   -         ",
-	"Return to previous"
-};
-
-extern unsigned int gcpadmap[];
-extern unsigned int wmpadmap[];
-extern unsigned int ccpadmap[];
-extern unsigned int ncpadmap[];
-
-void
 ConfigureButtons (u16 ctrlr_type)
 {
+	int cfg_btns_count = 11;
+	char cfg_btns_menu[][50] = {
+		"B        -         ",
+		"A        -         ",
+		"SELECT   -         ",
+		"START    -         ",
+		"UP       -         ",
+		"DOWN     -         ",
+		"LEFT     -         ",
+		"RIGHT    -         ",
+		"L TRIG   -         ",
+		"R TRIG   -         ",
+		"Return to previous"
+	};
+
 	int quit = 0;
 	int ret = 0;
 	int oldmenu = menu;
@@ -556,19 +550,19 @@ ConfigureButtons (u16 ctrlr_type)
 	menu = oldmenu;
 }	// end configurebuttons()
 
-int ctlrmenucount = 6;
-char ctlrmenu[][50] = {
-	"Nunchuk",
-	"Classic Controller",
-	"Wiimote",
-	"Gamecube Pad",
-	"Save Preferences",
-	"Go Back"
-};
-
 void
 ConfigureControllers ()
 {
+	int ctlrmenucount = 6;
+	char ctlrmenu[][50] = {
+		"Nunchuk",
+		"Classic Controller",
+		"Wiimote",
+		"Gamecube Pad",
+		"Save Preferences",
+		"Go Back"
+	};
+
 	int quit = 0;
 	int ret = 0;
 	int oldmenu = menu;
@@ -629,21 +623,22 @@ ConfigureControllers ()
 /****************************************************************************
  * Main Menu
  ***************************************************************************/
-int menucount = 8;
-char menuitems[][50] = {
-  "Choose Game",
-  "Controller Configuration",
-  "Preferences",
-  "Game Menu",
-  "Credits",
-  "DVD Motor Off",
-  "Reset System",
-  "Return to Loader"
-};
 
 void
 MainMenu (int selectedMenu)
 {
+	int menucount = 8;
+	char menuitems[][50] = {
+	  "Choose Game",
+	  "Controller Configuration",
+	  "Preferences",
+	  "Game Menu",
+	  "Credits",
+	  "DVD Motor Off",
+	  "Reset System",
+	  "Return to Loader"
+	};
+
 	tb_t start,end;
 	mftb(&start);
 

source/ngc/menudraw.cpp

@@ -28,10 +28,9 @@
 #include "networkop.h"
 
 /*** Globals ***/
-FT_Library ftlibrary;
+static FT_Library ftlibrary;
-FT_Face face;
+static FT_Face face;
-FT_GlyphSlot slot;
+static FT_GlyphSlot slot;
-FT_UInt glyph_index;
 static unsigned int fonthi, fontlo;
 
 extern char fontface[];		/*** From fontface.s ***/
@@ -607,7 +606,7 @@ RunMenu (char items[][50], int maxitems, const char *title, int fontsize, int x)
  ***************************************************************************/
 
 void
-ShowFiles (FILEENTRIES filelist[], int maxfiles, int offset, int selection)
+ShowFiles (BROWSERENTRY * browserList, int maxfiles, int offset, int selection)
 {
 	int i, j;
 	char text[MAXPATHLEN];
@@ -633,15 +632,15 @@ ShowFiles (FILEENTRIES filelist[], int maxfiles, int offset, int selection)
 	j = 0;
 	for (i = offset; i < (offset + PAGESIZE) && (i < maxfiles); i++)
 	{
-		if (filelist[i].flags)	// if a dir
+		if (browserList[i].isdir)	// if a dir
 		{
 			strcpy (text, "[");
-			strcat (text, filelist[i].displayname);
+			strcat (text, browserList[i].displayname);
 			strcat (text, "]");
 		}
 		else
 		{
-			sprintf(text, filelist[i].displayname);
+			sprintf(text, browserList[i].displayname);
 		}
 		if (j == (selection - offset))
 		{

source/ngc/menudraw.h

@@ -31,7 +31,7 @@ void WaitButtonA ();
 int RunMenu (char items[][50], int maxitems, const char *title, int fontsize = 20, int x = -1);
 void DrawMenu (char items[][50], const char *title, int maxitems, int selected, int fontsize = 20, int x = -1);
 void ShowCheats (char items[][50], char itemvalues[][50], int maxitems, int offset, int selection);
-void ShowFiles (FILEENTRIES filelist[], int maxfiles, int offset, int selection);
+void ShowFiles (BROWSERENTRY * browserList, int maxfiles, int offset, int selection);
 
 void WaitPrompt (const char *msg);
 int WaitPromptChoice (const char *msg, const char* bmsg, const char* amsg);

source/ngc/networkop.cpp

@@ -20,10 +20,10 @@
 #include "fileop.h"
 #include "http.h"
 
-bool networkInit = false;
+static bool networkInit = false;
-bool autoNetworkInit = true;
+static bool autoNetworkInit = true;
-bool networkShareInit = false;
+static bool networkShareInit = false;
-bool updateChecked = false; // true if checked for app update
+static bool updateChecked = false; // true if checked for app update
 static char updateURL[128]; // URL of app update
 bool updateFound = false; // true if an app update was found
 
@@ -89,7 +89,7 @@ void UpdateCheck()
 	}
 }
 
-bool unzipArchive(char * zipfilepath, char * unzipfolderpath)
+static bool unzipArchive(char * zipfilepath, char * unzipfolderpath)
 {
 	unzFile uf = unzOpen(zipfilepath);
 	if (uf==NULL)

source/ngc/preferences.cpp

@@ -22,42 +22,40 @@
 #include "filesel.h"
 #include "input.h"
 
-extern int currconfig[4];
+static char prefscomment[2][32];
-
-char prefscomment[2][32];
 
 /****************************************************************************
  * Prepare Preferences Data
  *
  * This sets up the save buffer for saving.
  ***************************************************************************/
-mxml_node_t *xml;
+static mxml_node_t *xml;
-mxml_node_t *data;
+static mxml_node_t *data;
-mxml_node_t *section;
+static mxml_node_t *section;
-mxml_node_t *item;
+static mxml_node_t *item;
-mxml_node_t *elem;
+static mxml_node_t *elem;
 
-char temp[20];
+static char temp[20];
 
-const char * toStr(int i)
+static const char * toStr(int i)
 {
 	sprintf(temp, "%d", i);
 	return temp;
 }
-const char * FtoStr(float i)
+static const char * FtoStr(float i)
 {
 	sprintf(temp, "%.2f", i);
 	return temp;
 }
 
-void createXMLSection(const char * name, const char * description)
+static void createXMLSection(const char * name, const char * description)
 {
 	section = mxmlNewElement(data, "section");
 	mxmlElementSetAttr(section, "name", name);
 	mxmlElementSetAttr(section, "description", description);
 }
 
-void createXMLSetting(const char * name, const char * description, const char * value)
+static void createXMLSetting(const char * name, const char * description, const char * value)
 {
 	item = mxmlNewElement(section, "setting");
 	mxmlElementSetAttr(item, "name", name);
@@ -65,7 +63,7 @@ void createXMLSetting(const char * name, const char * description, const char *
 	mxmlElementSetAttr(item, "description", description);
 }
 
-void createXMLController(unsigned int controller[], const char * name, const char * description)
+static void createXMLController(unsigned int controller[], const char * name, const char * description)
 {
 	item = mxmlNewElement(section, "controller");
 	mxmlElementSetAttr(item, "name", name);
@@ -80,7 +78,7 @@ void createXMLController(unsigned int controller[], const char * name, const cha
 	}
 }
 
-const char * XMLSaveCallback(mxml_node_t *node, int where)
+static const char * XMLSaveCallback(mxml_node_t *node, int where)
 {
 	const char *name;
 
@@ -108,7 +106,7 @@ const char * XMLSaveCallback(mxml_node_t *node, int where)
 }
 
 
-int
+static int
 preparePrefsData (int method)
 {
 	int offset = 0;
@@ -182,30 +180,24 @@ preparePrefsData (int method)
  * Load XML elements into variables for an individual variable
  ***************************************************************************/
 
-void loadXMLSetting(char * var, const char * name, int maxsize)
+static void loadXMLSetting(char * var, const char * name, int maxsize)
 {
 	item = mxmlFindElement(xml, xml, "setting", "name", name, MXML_DESCEND);
 	if(item)
 		snprintf(var, maxsize, "%s", mxmlElementGetAttr(item, "value"));
 }
-void loadXMLSetting(int * var, const char * name)
+static void loadXMLSetting(int * var, const char * name)
 {
 	item = mxmlFindElement(xml, xml, "setting", "name", name, MXML_DESCEND);
 	if(item)
 		*var = atoi(mxmlElementGetAttr(item, "value"));
 }
-void loadXMLSetting(float * var, const char * name)
+static void loadXMLSetting(float * var, const char * name)
 {
 	item = mxmlFindElement(xml, xml, "setting", "name", name, MXML_DESCEND);
 	if(item)
 		*var = atof(mxmlElementGetAttr(item, "value"));
 }
-void loadXMLSetting(bool * var, const char * name)
-{
-	item = mxmlFindElement(xml, xml, "setting", "name", name, MXML_DESCEND);
-	if(item)
-		*var = atoi(mxmlElementGetAttr(item, "value"));
-}
 
 /****************************************************************************
  * loadXMLController
@@ -213,7 +205,7 @@ void loadXMLSetting(bool * var, const char * name)
  * Load XML elements into variables for a controller mapping
  ***************************************************************************/
 
-void loadXMLController(unsigned int controller[], const char * name)
+static void loadXMLController(unsigned int controller[], const char * name)
 {
 	item = mxmlFindElement(xml, xml, "controller", "name", name, MXML_DESCEND);
 
@@ -235,7 +227,7 @@ void loadXMLController(unsigned int controller[], const char * name)
  * Decodes preferences - parses XML and loads preferences into the variables
  ***************************************************************************/
 
-bool
+static bool
 decodePrefsData (int method)
 {
 	int offset = 0;

source/ngc/vba.cpp

@@ -16,7 +16,7 @@
 #include <unistd.h>
 #include <wiiuse/wpad.h>
 
-#ifdef WII_DVD
+#ifdef HW_RVL
 extern "C" {
 #include <di/di.h>
 }
@@ -46,7 +46,7 @@ char appPath[1024];
  * Shutdown / Reboot / Exit
  ***************************************************************************/
 
-void ExitCleanup()
+static void ExitCleanup()
 {
 	LWP_SuspendThread (devicethread);
 	UnmountAllFAT();
@@ -109,7 +109,7 @@ void ShutdownWii()
  * lowlevel Qoob Modchip disable
  ***************************************************************************/
 
-void ipl_set_config(unsigned char c)
+static void ipl_set_config(unsigned char c)
 {
 	volatile unsigned long* exi = (volatile unsigned long*)0xCC006800;
 	unsigned long val,addr;
@@ -129,10 +129,10 @@ void ipl_set_config(unsigned char c)
 }
 #endif
 
-void CreateAppPath(char origpath[])
+static void CreateAppPath(char origpath[])
 {
 #ifdef HW_DOL
-	sprintf(appPath, GCSettings.SaveFolder);
+	snprintf(appPath, 1024, GCSettings.SaveFolder);
 #else
 	char path[1024];
 	strcpy(path, origpath); // make a copy so we don't mess up original
@@ -164,7 +164,7 @@ int main(int argc, char *argv[])
 	ipl_set_config(6); // disable Qoob modchip
 	#endif
 
-	#ifdef WII_DVD
+	#ifdef HW_RVL
 	DI_Init();	// first
 	#endif
 

source/ngc/vbasupport.cpp

@@ -635,9 +635,9 @@ void LoadPatch(int method)
 
 	char patchpath[3][512];
 	memset(patchpath, 0, sizeof(patchpath));
-	sprintf(patchpath[0], "%s/%s.ips",currentdir,ROMFilename);
+	sprintf(patchpath[0], "%s/%s.ips",browser.dir,ROMFilename);
-	sprintf(patchpath[1], "%s/%s.ups",currentdir,ROMFilename);
+	sprintf(patchpath[1], "%s/%s.ups",browser.dir,ROMFilename);
-	sprintf(patchpath[2], "%s/%s.ppf",currentdir,ROMFilename);
+	sprintf(patchpath[2], "%s/%s.ppf",browser.dir,ROMFilename);
 
 	for(patchtype=0; patchtype<3; patchtype++)
 	{
@@ -694,7 +694,7 @@ bool LoadGBROM(int method)
 		if(!MakeFilePath(filepath, FILE_ROM, method))
 			return false;
 
-		gbRomSize = LoadFile ((char *)gbRom, filepath, filelist[selection].length, method, NOTSILENT);
+		gbRomSize = LoadFile ((char *)gbRom, filepath, browserList[browser.selIndex].length, method, NOTSILENT);
 	}
 	else
 	{
@@ -706,7 +706,7 @@ bool LoadGBROM(int method)
 				gbRomSize = LoadSzFile(szpath, (unsigned char *)gbRom);
 				break;
 			case METHOD_DVD:
-				gbRomSize = SzExtractFile(filelist[selection].offset, (unsigned char *)gbRom);
+				gbRomSize = SzExtractFile(browserList[browser.selIndex].offset, (unsigned char *)gbRom);
 				break;
 		}
 	}
@@ -723,11 +723,11 @@ bool LoadVBAROM(int method)
 	bool loaded = false;
 
 	// image type (checks file extension)
-	if(utilIsGBAImage(filelist[selection].filename))
+	if(utilIsGBAImage(browserList[browser.selIndex].filename))
 		type = 2;
-	else if(utilIsGBImage(filelist[selection].filename))
+	else if(utilIsGBImage(browserList[browser.selIndex].filename))
 		type = 1;
-	else if(utilIsZipFile(filelist[selection].filename))
+	else if(utilIsZipFile(browserList[browser.selIndex].filename))
 	{
 		// we need to check the file extension of the first file in the archive
 		char * zippedFilename = GetFirstZipFilename (method);

source/ngc/video.cpp

@@ -79,8 +79,8 @@ static camera cam = { {0.0F, 0.0F, 0.0F},
  * VideoThreading
  ***************************************************************************/
 #define TSTACK 16384
-lwpq_t videoblankqueue;
+static lwpq_t videoblankqueue;
-lwp_t vbthread;
+static lwp_t vbthread;
 static unsigned char vbstack[TSTACK];
 
 /****************************************************************************

source/ngc/vmmem.cpp

@@ -179,7 +179,7 @@ bool VMCPULoadROM(int method)
 		if(!MakeFilePath(filepath, FILE_ROM, method))
 			return false;
 
-		GBAROMSize = LoadFile ((char *)rom, filepath, filelist[selection].length, method, NOTSILENT);
+		GBAROMSize = LoadFile ((char *)rom, filepath, browserList[browser.selIndex].length, method, NOTSILENT);
 	}
 	else
 	{
@@ -191,7 +191,7 @@ bool VMCPULoadROM(int method)
 				GBAROMSize = LoadSzFile(szpath, (unsigned char *)rom);
 				break;
 			case METHOD_DVD:
-				GBAROMSize = SzExtractFile(filelist[selection].offset, (unsigned char *)rom);
+				GBAROMSize = SzExtractFile(browserList[browser.selIndex].offset, (unsigned char *)rom);
 				break;
 		}
 	}

source/unzip/unzip.c

@@ -84,12 +84,6 @@ woven in by Terry Thorsen 1/2003.
 #define SIZECENTRALDIRITEM (0x2e)
 #define SIZEZIPLOCALHEADER (0x1e)
 
-
-
-
-const char unz_copyright[] =
-   " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
-
 /* unz_file_info_interntal contain internal info about a file in zipfile*/
 typedef struct unz_file_info_internal_s
 {
@@ -412,9 +406,6 @@ extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
 
     int err=UNZ_OK;
 
-    if (unz_copyright[0]!=' ')
-        return NULL;
-
     if (pzlib_filefunc_def==NULL)
         fill_fopen_filefunc(&us.z_filefunc);
     else