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

This commit is contained in:
dborth 2008-12-30 00:10:12 +00:00
parent 947ca0582a
commit 093dca1d66
22 changed files with 510 additions and 495 deletions

View File

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

View File

@ -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
int dvddirlength = 0; // length of currently selected file or folder
u64 dvdrootdir = 0; // offset of DVD root
int dvdrootlength = 0; // length of DVD root
bool isWii = false;
#define MAXDVDFILES 2000
static int diroffset = 0;
static u64 dvddir = 0; // offset of currently selected file or folder
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];
u64 dvdsf_last_offset = 0;
u64 dvdsf_last_length = 0;
static unsigned char dvdsf_buffer[DVD_SECTOR_SIZE];
static u64 dvdsf_last_offset = 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
if(offset != dvdsf_last_offset || len > dvdsf_last_length)
{
memset(&dvdsf_buffer, '\0', DVD_SECTOR_SIZE);
ret = dvd_read(&dvdsf_buffer, len, offset);
dvdsf_last_offset = offset;
// only read data if the data inside dvdsf_buffer cannot be used
if(offset != dvdsf_last_offset || len > dvdsf_last_length)
{
memset(&dvdsf_buffer, '\0', DVD_SECTOR_SIZE);
ret = dvd_read(&dvdsf_buffer, len, offset);
dvdsf_last_offset = offset;
dvdsf_last_length = len;
}
}
memcpy(dst, &dvdsf_buffer, len);
return ret;
memcpy(dst, &dvdsf_buffer, len);
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 (filelist[entrycount].displayname, tmpname);
strcpy (browserList[entrycount].displayname, tmpname);
memcpy (&offset32, &dvdbuffer[diroffset + EXTENT], 4);
filelist[entrycount].offset = (u64)offset32;
memcpy (&filelist[entrycount].length, &dvdbuffer[diroffset + FILE_LENGTH], 4);
memcpy (&filelist[entrycount].flags, &dvdbuffer[diroffset + FILE_FLAGS], 1);
browserList[entrycount].offset = (u64)offset32;
memcpy (&(browserList[entrycount].length), &dvdbuffer[diroffset + FILE_LENGTH], 4);
memcpy (&(browserList[entrycount].isdir), &dvdbuffer[diroffset + FILE_FLAGS], 1);
filelist[entrycount].offset <<= 11;
filelist[entrycount].flags = filelist[entrycount].flags & 2;
browserList[entrycount].offset <<= 11;
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
selection = offset = 0;
// reset browser
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++ )
if (strcmp(filelist[i].filename, dir) == 0)
for (int i = 0; i < browser.numEntries; i++ )
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;
dvddirlength = filelist[dirindex].length;
selection = dirindex;
dvddir = browserList[dirindex].offset;
dvddirlength = browserList[dirindex].length;
browser.selIndex = dirindex;
if(filelist[dirindex].flags) // only parse directories
maxfiles = ParseDVDdirectory();
if(browserList[dirindex].isdir) // only parse directories
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
* dvddirlength.
*
* The buffer parameter should re-use the initial ROM buffer
* It assumes dvddir and dvddirlength are prepopulated
***************************************************************************/
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)
{

View File

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

View File

@ -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!
FILE * file;
unsigned char * savebuffer = NULL;
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
selection = offset = 0;
// Clear any existing values
memset (&filelist, 0, sizeof (FILEENTRIES) * MAXFILES);
// reset browser
ResetBrowser();
// 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));
strncpy(filelist[nbfiles].filename, filename, MAXPATHLEN);
browserList = (BROWSERENTRY *)realloc(browserList, (entryNum+1) * sizeof(BROWSERENTRY));
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
filelist[nbfiles].length = filestat.st_size;
filelist[nbfiles].flags = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
nbfiles++;
strncpy(browserList[entryNum].displayname, tmpname, MAXDISPLAY); // crop name for display
browserList[entryNum].length = filestat.st_size;
browserList[entryNum].isdir = (filestat.st_mode & _IFDIR) == 0 ? 0 : 1; // flag this as a dir
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

View File

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

View File

@ -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;
int selection;
BROWSERINFO browser;
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)
{
dvddir = filelist[selection].offset;
dvddirlength = filelist[selection].length;
}
SetDVDdirectory(browserList[browser.selIndex].offset, browserList[browser.selIndex].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;
currentdir[size] = 0;
size = strlen(browser.dir) - size - 1;
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(((FILEENTRIES *)f2)->filename, ".") == 0) { return 1; }
if(strcmp(((FILEENTRIES *)f1)->filename, "..") == 0) { return -1; }
if(strcmp(((FILEENTRIES *)f2)->filename, "..") == 0) { return 1; }
if(strcmp(((BROWSERENTRY *)f1)->filename, ".") == 0) { return -1; }
if(strcmp(((BROWSERENTRY *)f2)->filename, ".") == 0) { return 1; }
if(strcmp(((BROWSERENTRY *)f1)->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(!(((FILEENTRIES *)f1)->flags) && ((FILEENTRIES *)f2)->flags) return 1;
if(((BROWSERENTRY *)f1)->isdir && !(((BROWSERENTRY *)f2)->isdir)) 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)
{
// go to directory the 7z was in
dvddir = filelist[0].offset;
dvddirlength = filelist[0].length;
}
SetDVDdirectory(browserList[0].offset, browserList[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++;
if (selection == maxfiles)
selection = offset = 0;
if ((selection - offset) >= PAGESIZE)
offset += PAGESIZE;
browser.selIndex++;
if (browser.selIndex == browser.numEntries)
browser.selIndex = browser.pageIndex = 0;
if ((browser.selIndex - browser.pageIndex) >= PAGESIZE)
browser.pageIndex += PAGESIZE;
redraw = 1;
move_selection = 0;
}
@ -519,15 +493,15 @@ int FileSelector (int method)
if (move_selection)
{
selection--;
if (selection < 0) {
selection = maxfiles - 1;
offset = selection - PAGESIZE + 1;
browser.selIndex--;
if (browser.selIndex < 0) {
browser.selIndex = browser.numEntries - 1;
browser.pageIndex = browser.selIndex - PAGESIZE + 1;
}
if (selection < offset)
offset -= PAGESIZE;
if (offset < 0)
offset = 0;
if (browser.selIndex < browser.pageIndex)
browser.pageIndex -= PAGESIZE;
if (browser.pageIndex < 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;
if (selection < 0)
browser.selIndex -= PAGESIZE;
if (browser.selIndex < 0)
{
selection = maxfiles - 1;
offset = selection - PAGESIZE + 1;
browser.selIndex = browser.numEntries - 1;
browser.pageIndex = browser.selIndex - PAGESIZE + 1;
}
if (selection < offset)
offset -= PAGESIZE;
if (offset < 0)
offset = 0;
if (browser.selIndex < browser.pageIndex)
browser.pageIndex -= PAGESIZE;
if (browser.pageIndex < 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;
if (selection > maxfiles - 1)
selection = offset = 0;
if ((selection - offset) >= PAGESIZE)
offset += PAGESIZE;
browser.selIndex += PAGESIZE;
if (browser.selIndex > browser.numEntries - 1)
browser.selIndex = browser.pageIndex = 0;
if ((browser.selIndex - browser.pageIndex) >= PAGESIZE)
browser.pageIndex += PAGESIZE;
redraw = 1;
}
}
@ -578,17 +552,17 @@ OpenROM (int method)
switch(method)
{
case METHOD_DVD:
currentdir[0] = 0;
maxfiles = ParseDVDdirectory (); // Parse root directory
browser.dir[0] = 0;
browser.numEntries = ParseDVDdirectory(); // Parse root directory
SwitchDVDFolder(GCSettings.LoadFolder); // switch to ROM folder
break;
default:
sprintf(currentdir, "/%s", GCSettings.LoadFolder);
maxfiles = ParseDirectory(); // Parse root directory
sprintf(browser.dir, "/%s", GCSettings.LoadFolder);
browser.numEntries = ParseDirectory(); // Parse root directory
break;
}
if (maxfiles > 0)
if (browser.numEntries > 0)
{
// Select an entry
return FileSelector (method);

View File

@ -13,38 +13,40 @@
#include <unistd.h>
#define SAVEBUFFERSIZE (1024 * 1024 * 2)
#define MAXJOLIET 255
#define MAXDISPLAY 40
typedef struct
{
u64 offset;
unsigned int length;
char flags;
char filename[MAXJOLIET + 1];
char displayname[MAXDISPLAY + 1];
} FILEENTRIES;
char dir[MAXPATHLEN]; // directory path of browserList
int numEntries; // # of entries in browserList
int selIndex; // currently selected index of browserList
int pageIndex; // starting index of browserList page display
} BROWSERINFO;
#define MAXFILES 2000 // Restrict to 2000 files per dir
extern FILEENTRIES filelist[MAXFILES];
extern unsigned char *savebuffer;
extern int offset;
extern int selection;
typedef struct
{
u64 offset; // DVD offset
unsigned int length; // file length
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

View File

@ -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, discoffset);
sizeread = dvd_safe_read (readbuffer, ZIPCHUNK, 0);
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;
CArchiveDatabaseEx SzDb;
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;
static char sz_buffer[2048];
static 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
* But it could parse the entire 7z for full browsing capability
* It parses 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
SzArchiveStream.offset = filelist[selection].offset;
SzArchiveStream.len = filelist[selection].length;
// save the length/offset of this file
unsigned int filelen = browserList[browser.selIndex].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
memset(&filelist, 0, sizeof(FILEENTRIES) * MAXFILES);
// reset browser
ResetBrowser();
// add '..' folder in case the user wants exit the 7z
strncpy(filelist[0].displayname, "..", 2);
filelist[0].flags = 1;
filelist[0].offset = dvddir;
filelist[0].length = dvddirlength;
strncpy(browserList[0].displayname, "..", 2);
browserList[0].isdir = 1;
browserList[0].offset = fileoff;
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
if (SzJ == (MAXFILES - 1))
browserList = (BROWSERENTRY *)realloc(browserList, (SzJ+1) * sizeof(BROWSERENTRY));
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...)
filelist[SzJ].filename[MAXJOLIET] = 0; // terminate string
strncpy(filelist[SzJ].displayname, SzF->Name, MAXDISPLAY+1); // crop name for display
filelist[SzJ].length = SzF->Size; // filesize
filelist[SzJ].offset = SzI; // the extraction function identifies the file with this number
filelist[SzJ].flags = 0; // only files will be displayed (-> no flags)
strncpy(browserList[SzJ].filename, SzF->Name, MAXJOLIET); // copy joliet name (useless...)
strncpy(browserList[SzJ].displayname, SzF->Name, MAXDISPLAY); // crop name for display
browserList[SzJ].length = SzF->Size; // filesize
browserList[SzJ].offset = SzI; // the extraction function identifies the file with this number
browserList[SzJ].isdir = 0; // only files will be displayed (-> no flags)
SzJ++;
}
// update maxfiles and select the first entry
offset = selection = 0;
nbfiles = SzJ;
}
else

View File

@ -3,14 +3,12 @@
*
* Tantric September 2008
*
* unzip.h
* gcunzip.h
*
* File unzip routines
***************************************************************************/
#ifndef _UNZIP_
#define _UNZIP_
#include <smb.h>
#ifndef _GCUNZIP_H_
#define _GCUNZIP_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

View File

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

View File

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

View File

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

View File

@ -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",
"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
static 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;
char cfg_text[][50] = {
"Remapping ",
"Press Any Button",
"on the",
" ", // identify controller
" ",
"Press C-Left or",
"Home to exit"
};
u32
static 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;
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
static 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);

View File

@ -28,10 +28,9 @@
#include "networkop.h"
/*** Globals ***/
FT_Library ftlibrary;
FT_Face face;
FT_GlyphSlot slot;
FT_UInt glyph_index;
static FT_Library ftlibrary;
static FT_Face face;
static FT_GlyphSlot slot;
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))
{

View File

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

View File

@ -20,10 +20,10 @@
#include "fileop.h"
#include "http.h"
bool networkInit = false;
bool autoNetworkInit = true;
bool networkShareInit = false;
bool updateChecked = false; // true if checked for app update
static bool networkInit = false;
static bool autoNetworkInit = true;
static bool networkShareInit = false;
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)

View File

@ -22,42 +22,40 @@
#include "filesel.h"
#include "input.h"
extern int currconfig[4];
char prefscomment[2][32];
static char prefscomment[2][32];
/****************************************************************************
* Prepare Preferences Data
*
* This sets up the save buffer for saving.
***************************************************************************/
mxml_node_t *xml;
mxml_node_t *data;
mxml_node_t *section;
mxml_node_t *item;
mxml_node_t *elem;
static mxml_node_t *xml;
static mxml_node_t *data;
static mxml_node_t *section;
static mxml_node_t *item;
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;

View File

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

View File

@ -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[1], "%s/%s.ups",currentdir,ROMFilename);
sprintf(patchpath[2], "%s/%s.ppf",currentdir,ROMFilename);
sprintf(patchpath[0], "%s/%s.ips",browser.dir,ROMFilename);
sprintf(patchpath[1], "%s/%s.ups",browser.dir,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);

View File

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

View File

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

View File

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