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

code restructure, revamp filebrowser

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

3
Makefile.gc
View File

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

3
Makefile.wii
View File

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

12
source/ngc/cheatmgr.cpp
View File

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

7
source/ngc/dvd.cpp
View File

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

329
source/ngc/filebrowser.cpp
View File

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

25
source/ngc/filebrowser.h
View File

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

16
source/ngc/filelist.h
View File

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

412
source/ngc/fileop.cpp
View File

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

17
source/ngc/fileop.h
View File

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

59
source/ngc/freeze.cpp
View File

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

8
source/ngc/freeze.h
View File

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

47
source/ngc/gcunzip.cpp
View File

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

6
source/ngc/gcunzip.h
View File

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

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

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

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

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

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

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.2 KiB

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

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.3 KiB

After

Width:  |  Height:  |  Size: 1.3 KiB

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

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 644 B

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

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.0 KiB

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

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 888 B

195
source/ngc/menu.cpp
View File

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

7
source/ngc/networkop.cpp
View File

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

4
source/ngc/patch.cpp
View File

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

2
source/ngc/patch.h
View File

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

114
source/ngc/preferences.cpp
View File

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

4
source/ngc/s9xconfig.cpp
View File

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

39
source/ngc/snes9xGX.cpp
View File

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

27
source/ngc/snes9xGX.h
View File

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

64
source/ngc/sram.cpp
View File

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

8
source/ngc/sram.h
View File

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

4
source/snes9x/gfx.cpp
View File

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

343
source/snes9x/ngcscreenshot.cpp
View File

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