mirror of
https://github.com/ekeeke/Genesis-Plus-GX.git
synced 2024-11-10 04:45:08 +01:00
670 lines
17 KiB
C
670 lines
17 KiB
C
/****************************************************************************
|
|
* ROM Selection Interface
|
|
*
|
|
* The following features are implemented:
|
|
* . SDCARD access with LFN support (through softdev's VFAT library)
|
|
* . DVD access
|
|
* . easy subdirectory browsing
|
|
* . ROM browser
|
|
* . alphabetical file sorting (Marty Disibio)
|
|
* . load from history list (Marty Disibio)
|
|
*
|
|
***************************************************************************/
|
|
#include "shared.h"
|
|
#include "iso9660.h"
|
|
#include "font.h"
|
|
#include "fileio.h"
|
|
#include "history.h"
|
|
#include "dvd.h"
|
|
|
|
#ifdef HW_RVL
|
|
#include <di/di.h>
|
|
#endif
|
|
|
|
#define PAGESIZE 12
|
|
|
|
static int maxfiles;
|
|
static int offset = 0;
|
|
static int selection = 0;
|
|
static int old_selection = 0;
|
|
static int old_offset = 0;
|
|
static char rootFATdir[256];
|
|
static u8 haveDVDdir = 0;
|
|
static u8 haveFATdir = 0;
|
|
static u8 UseFAT = 0;
|
|
static u8 UseHistory = 0;
|
|
static int LoadFile (unsigned char *buffer);
|
|
|
|
/***************************************************************************
|
|
* FileSortCallback (Marty Disibio)
|
|
*
|
|
* Quick sort callback to sort file entries with the following order:
|
|
* .
|
|
* ..
|
|
* <dirs>
|
|
* <files>
|
|
***************************************************************************/
|
|
static int FileSortCallback(const void *f1, const void *f2)
|
|
{
|
|
/* Special case for implicit directories */
|
|
if(((FILEENTRIES *)f1)->filename[0] == '.' || ((FILEENTRIES *)f2)->filename[0] == '.')
|
|
{
|
|
if(strcmp(((FILEENTRIES *)f1)->filename, ".") == 0) { return -1; }
|
|
if(strcmp(((FILEENTRIES *)f2)->filename, ".") == 0) { return 1; }
|
|
if(strcmp(((FILEENTRIES *)f1)->filename, "..") == 0) { return -1; }
|
|
if(strcmp(((FILEENTRIES *)f2)->filename, "..") == 0) { return 1; }
|
|
}
|
|
|
|
/* If one is a file and one is a directory the directory is first. */
|
|
if(((FILEENTRIES *)f1)->flags == 1 && ((FILEENTRIES *)f2)->flags == 0) return -1;
|
|
if(((FILEENTRIES *)f1)->flags == 0 && ((FILEENTRIES *)f2)->flags == 1) return 1;
|
|
|
|
return stricmp(((FILEENTRIES *)f1)->filename, ((FILEENTRIES *)f2)->filename);
|
|
}
|
|
|
|
/***************************************************************************
|
|
* ShowFiles
|
|
*
|
|
* Show filenames list in current directory
|
|
***************************************************************************/
|
|
static void ShowFiles (int offset, int selection)
|
|
{
|
|
int i, j;
|
|
char text[MAXJOLIET+2];
|
|
|
|
ClearScreen ();
|
|
j = 0;
|
|
|
|
for (i = offset; i < (offset + PAGESIZE) && (i < maxfiles); i++)
|
|
{
|
|
memset(text,0,MAXJOLIET+2);
|
|
if (filelist[i].flags) sprintf(text, "[%s]", filelist[i].filename + filelist[i].filename_offset);
|
|
else sprintf (text, "%s", filelist[i].filename + filelist[i].filename_offset);
|
|
if (j == (selection - offset)) WriteCentre_HL ((j * fheight) + 120, text);
|
|
else WriteCentre ((j * fheight) + 120, text);
|
|
j++;
|
|
}
|
|
SetScreen ();
|
|
}
|
|
|
|
/***************************************************************************
|
|
* updateFATdirname
|
|
*
|
|
* Update ROOT directory while browsing SDCARD
|
|
***************************************************************************/
|
|
static int updateFATdirname()
|
|
{
|
|
int size=0;
|
|
char *test;
|
|
char temp[1024];
|
|
|
|
/* current directory doesn't change */
|
|
if (strcmp(filelist[selection].filename,".") == 0) return 0;
|
|
|
|
/* go up to parent directory */
|
|
else if (strcmp(filelist[selection].filename,"..") == 0)
|
|
{
|
|
/* determine last subdirectory namelength */
|
|
sprintf(temp,"%s",rootFATdir);
|
|
test= strtok(temp,"/");
|
|
while (test != NULL)
|
|
{
|
|
size = strlen(test);
|
|
test = strtok(NULL,"/");
|
|
}
|
|
|
|
/* remove last subdirectory name */
|
|
size = strlen(rootFATdir) - size;
|
|
rootFATdir[size-1] = 0;
|
|
}
|
|
else
|
|
{
|
|
sprintf(rootFATdir, "%s%s/",rootFATdir, filelist[selection].filename);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/***************************************************************************
|
|
* parseFATdirectory
|
|
*
|
|
* List files into one SDCARD directory
|
|
***************************************************************************/
|
|
static int parseFATdirectory()
|
|
{
|
|
int nbfiles = 0;
|
|
char filename[MAXPATHLEN];
|
|
struct stat filestat;
|
|
|
|
/* open directory */
|
|
DIR_ITER *dir = diropen (rootFATdir);
|
|
if (dir == NULL)
|
|
{
|
|
sprintf(filename, "Error opening %s", rootFATdir);
|
|
WaitPrompt (filename);
|
|
return 0;
|
|
}
|
|
|
|
while (dirnext(dir, filename, &filestat) == 0)
|
|
{
|
|
if (strcmp(filename,".") != 0)
|
|
{
|
|
memset(&filelist[nbfiles], 0, sizeof (FILEENTRIES));
|
|
sprintf(filelist[nbfiles].filename,"%s",filename);
|
|
filelist[nbfiles].length = filestat.st_size;
|
|
filelist[nbfiles].flags = (filestat.st_mode & S_IFDIR) ? 1 : 0;
|
|
nbfiles++;
|
|
}
|
|
}
|
|
|
|
dirclose(dir);
|
|
|
|
/* Sort the file list */
|
|
qsort(filelist, nbfiles, sizeof(FILEENTRIES), FileSortCallback);
|
|
|
|
return nbfiles;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* FileSelected
|
|
*
|
|
* Called when a file is selected by the user inside the FileSelector loop.
|
|
****************************************************************************/
|
|
static int FileSelected()
|
|
{
|
|
/* If loading from history then we need to setup a few more things. */
|
|
if(UseHistory)
|
|
{
|
|
/* Get the parent folder for the file. */
|
|
strncpy(rootFATdir, history.entries[selection].filepath, MAXJOLIET-1);
|
|
rootFATdir[MAXJOLIET-1] = '\0';
|
|
|
|
/* Get the length of the file. This has to be done
|
|
* before calling LoadFile(). */
|
|
char filepath[MAXJOLIET];
|
|
struct stat filestat;
|
|
snprintf(filepath, MAXJOLIET-1, "%s%s", history.entries[selection].filepath, history.entries[selection].filename);
|
|
filepath[MAXJOLIET-1] = '\0';
|
|
if(stat(filepath, &filestat) == 0)
|
|
{
|
|
filelist[selection].length = filestat.st_size;
|
|
}
|
|
}
|
|
|
|
/* Add/move the file to the top of the history. */
|
|
if (UseFAT) history_add_file(rootFATdir, filelist[selection].filename);
|
|
|
|
rootdir = filelist[selection].offset;
|
|
rootdirlength = filelist[selection].length;
|
|
memfile_autosave();
|
|
genromsize = LoadFile(cart_rom);
|
|
if (genromsize)
|
|
{
|
|
reloadrom();
|
|
memfile_autoload();
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* FileSelector
|
|
*
|
|
* Let user select a file from the File listing
|
|
****************************************************************************/
|
|
static int FileSelector ()
|
|
{
|
|
short p;
|
|
int redraw = 1;
|
|
int go_up = 0;
|
|
int i,size;
|
|
|
|
while (1)
|
|
{
|
|
if (redraw) ShowFiles (offset, selection);
|
|
redraw = 0;
|
|
p = ogc_input__getMenuButtons();
|
|
|
|
/* scroll displayed filename */
|
|
if (p & PAD_BUTTON_LEFT)
|
|
{
|
|
if (filelist[selection].filename_offset > 0)
|
|
{
|
|
filelist[selection].filename_offset --;
|
|
redraw = 1;
|
|
}
|
|
}
|
|
else if (p & PAD_BUTTON_RIGHT)
|
|
{
|
|
size = 0;
|
|
for (i=filelist[selection].filename_offset; i<strlen(filelist[selection].filename); i++)
|
|
size += font_size[(int)filelist[selection].filename[i]];
|
|
|
|
if (size > back_framewidth)
|
|
{
|
|
filelist[selection].filename_offset ++;
|
|
redraw = 1;
|
|
}
|
|
}
|
|
|
|
/* highlight next item */
|
|
else if (p & PAD_BUTTON_DOWN)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
selection++;
|
|
if (selection == maxfiles) selection = offset = 0;
|
|
if ((selection - offset) >= PAGESIZE) offset += PAGESIZE;
|
|
redraw = 1;
|
|
}
|
|
|
|
/* highlight previous item */
|
|
else if (p & PAD_BUTTON_UP)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
selection--;
|
|
if (selection < 0)
|
|
{
|
|
selection = maxfiles - 1;
|
|
offset = selection - PAGESIZE + 1;
|
|
}
|
|
if (selection < offset) offset -= PAGESIZE;
|
|
if (offset < 0) offset = 0;
|
|
redraw = 1;
|
|
}
|
|
|
|
/* go back one page */
|
|
else if (p & PAD_TRIGGER_L)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
selection -= PAGESIZE;
|
|
if (selection < 0)
|
|
{
|
|
selection = maxfiles - 1;
|
|
offset = selection - PAGESIZE + 1;
|
|
}
|
|
if (selection < offset) offset -= PAGESIZE;
|
|
if (offset < 0) offset = 0;
|
|
redraw = 1;
|
|
}
|
|
|
|
/* go forward one page */
|
|
else if (p & PAD_TRIGGER_R)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
selection += PAGESIZE;
|
|
if (selection > maxfiles - 1) selection = offset = 0;
|
|
if ((selection - offset) >= PAGESIZE) offset += PAGESIZE;
|
|
redraw = 1;
|
|
}
|
|
|
|
/* go up one directory or quit */
|
|
if (p & PAD_BUTTON_B)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
if (UseFAT)
|
|
{
|
|
if (strcmp(filelist[0].filename,"..") != 0) return 0;
|
|
}
|
|
else
|
|
{
|
|
if (basedir == rootdir) return 0;
|
|
}
|
|
go_up = 1;
|
|
}
|
|
|
|
/* quit */
|
|
if (p & PAD_TRIGGER_Z)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* open selected file or directory */
|
|
if ((p & PAD_BUTTON_A) || go_up)
|
|
{
|
|
filelist[selection].filename_offset = 0;
|
|
if (go_up)
|
|
{
|
|
/* select item #1 */
|
|
go_up = 0;
|
|
selection = UseFAT ? 0 : 1;
|
|
}
|
|
|
|
/*** This is directory ***/
|
|
if (filelist[selection].flags)
|
|
{
|
|
/* SDCARD directory handler */
|
|
if (UseFAT)
|
|
{
|
|
/* update current directory */
|
|
if (updateFATdirname())
|
|
{
|
|
/* reinit selector (previous value is saved for one level) */
|
|
if (selection == 0)
|
|
{
|
|
selection = old_selection;
|
|
offset = old_offset;
|
|
old_selection = 0;
|
|
old_offset = 0;
|
|
}
|
|
else
|
|
{
|
|
/* save current selector value */
|
|
old_selection = selection;
|
|
old_offset = offset;
|
|
selection = 0;
|
|
offset = 0;
|
|
}
|
|
|
|
/* set new entry list */
|
|
maxfiles = parseFATdirectory();
|
|
if (!maxfiles)
|
|
{
|
|
/* quit */
|
|
WaitPrompt ("No files found !");
|
|
haveFATdir = 0;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
else /* DVD directory handler */
|
|
{
|
|
/* move to a new directory */
|
|
if (selection != 0)
|
|
{
|
|
/* update current directory */
|
|
rootdir = filelist[selection].offset;
|
|
rootdirlength = filelist[selection].length;
|
|
|
|
/* reinit selector (previous value is saved for one level) */
|
|
if (selection == 1)
|
|
{
|
|
selection = old_selection;
|
|
offset = old_offset;
|
|
old_selection = 0;
|
|
old_offset = 0;
|
|
}
|
|
else
|
|
{
|
|
/* save current selector value */
|
|
old_selection = selection;
|
|
old_offset = offset;
|
|
selection = 0;
|
|
offset = 0;
|
|
}
|
|
|
|
/* get new entry list */
|
|
maxfiles = parseDVDdirectory ();
|
|
}
|
|
}
|
|
}
|
|
else /*** This is a file ***/
|
|
{
|
|
return FileSelected();
|
|
}
|
|
redraw = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* OpenDVD
|
|
*
|
|
* Function to load a DVD directory and display to user.
|
|
****************************************************************************/
|
|
int OpenDVD ()
|
|
{
|
|
UseFAT = 0;
|
|
UseHistory = 0;
|
|
|
|
if (!getpvd())
|
|
{
|
|
/* mount DVD */
|
|
ShowAction("Mounting DVD ... Wait");
|
|
|
|
#ifndef HW_RVL
|
|
DVD_Mount();
|
|
#else
|
|
u32 val;
|
|
DI_GetCoverRegister(&val);
|
|
|
|
if(val & 0x1)
|
|
{
|
|
WaitPrompt("No Disc inserted !");
|
|
return 0;
|
|
}
|
|
DI_Mount();
|
|
while(DI_GetStatus() & DVD_INIT);
|
|
if (!(DI_GetStatus() & DVD_READY))
|
|
{
|
|
char msg[50];
|
|
sprintf(msg, "DI Status Error: 0x%08X\n",DI_GetStatus());
|
|
WaitPrompt(msg);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
haveDVDdir = 0;
|
|
if (!getpvd())
|
|
{
|
|
WaitPrompt ("Failed to mount DVD");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (haveDVDdir == 0)
|
|
{
|
|
/* don't mess with SD entries */
|
|
haveFATdir = 0;
|
|
|
|
/* reinit selector */
|
|
rootdir = basedir;
|
|
old_selection = selection = offset = old_offset = 0;
|
|
}
|
|
|
|
/* Parse root directory and get entries list */
|
|
ShowAction("Reading Directory ...");
|
|
if ((maxfiles = parseDVDdirectory ()))
|
|
{
|
|
/* Select an entry */
|
|
haveDVDdir = 1;
|
|
return FileSelector ();
|
|
}
|
|
else
|
|
{
|
|
/* no entries found */
|
|
WaitPrompt ("no files found !");
|
|
haveDVDdir = 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* OpenFAT
|
|
*
|
|
* Function to load a FAT directory and display to user.
|
|
****************************************************************************/
|
|
int OpenFAT (char *name)
|
|
{
|
|
UseFAT = 1;
|
|
UseHistory = 0;
|
|
|
|
if (haveFATdir == 0)
|
|
{
|
|
/* don't mess with DVD entries */
|
|
haveDVDdir = 0;
|
|
|
|
/* reinit selector */
|
|
old_selection = selection = offset = old_offset = 0;
|
|
|
|
/* Reset SDCARD root directory */
|
|
sprintf (rootFATdir, "%s/genplus/roms/", name);
|
|
|
|
/* if directory doesn't exist, use root */
|
|
DIR_ITER *dir = diropen(rootFATdir);
|
|
if (dir == NULL) sprintf (rootFATdir, "%s/", name);
|
|
else dirclose(dir);
|
|
}
|
|
|
|
/* Parse root directory and get entries list */
|
|
ShowAction("Reading Directory ...");
|
|
if ((maxfiles = parseFATdirectory ()))
|
|
{
|
|
/* Select an entry */
|
|
haveFATdir = 1;
|
|
return FileSelector ();
|
|
}
|
|
else
|
|
{
|
|
/* no entries found */
|
|
WaitPrompt ("no files found !");
|
|
haveFATdir = 0;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* OpenHistory
|
|
*
|
|
* Function to load a recent file from SDCARD (Marty Disibio)
|
|
****************************************************************************/
|
|
int OpenHistory()
|
|
{
|
|
int i;
|
|
|
|
UseFAT = 1;
|
|
UseHistory = 1;
|
|
|
|
/* don't mess with other entries */
|
|
haveFATdir = 0;
|
|
haveDVDdir = 0;
|
|
|
|
/* reinit selector */
|
|
old_selection = selection = offset = old_offset = 0;
|
|
|
|
/* Recreate the file listing from the history
|
|
* as if all of the roms were in the same directory. */
|
|
ShowAction("Reading Files ...");
|
|
|
|
maxfiles = 0;
|
|
for(i=0; i < NUM_HISTORY_ENTRIES; i++)
|
|
{
|
|
if(history.entries[i].filepath[0] > 0)
|
|
{
|
|
filelist[i].offset = 0;
|
|
filelist[i].length = 0;
|
|
filelist[i].flags = 0;
|
|
filelist[i].filename_offset = 0;
|
|
strncpy(filelist[i].filename, history.entries[i].filename, MAXJOLIET-1);
|
|
filelist[i].filename[MAXJOLIET-1] = '\0';
|
|
|
|
maxfiles++;
|
|
}
|
|
else
|
|
{
|
|
/* Found the end of the list. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!maxfiles)
|
|
{
|
|
WaitPrompt ("No recent files");
|
|
return 0;
|
|
}
|
|
|
|
return FileSelector();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
* LoadFile
|
|
*
|
|
* This function will load a file from DVD or SDCARD, in BIN, SMD or ZIP format.
|
|
* The values for offset and length are inherited from rootdir and
|
|
* rootdirlength.
|
|
*
|
|
* The buffer parameter should re-use the initial ROM buffer.
|
|
****************************************************************************/
|
|
static int LoadFile (unsigned char *buffer)
|
|
{
|
|
u64 discoffset = 0;
|
|
char readbuffer[2048];
|
|
char fname[MAXPATHLEN];
|
|
FILE *sdfile = NULL;
|
|
|
|
if (rootdirlength == 0) return 0;
|
|
|
|
/* SDCard access */
|
|
if (UseFAT)
|
|
{
|
|
/* open file */
|
|
sprintf(fname, "%s%s",rootFATdir,filelist[selection].filename);
|
|
sdfile = fopen(fname, "rb");
|
|
if (sdfile == NULL)
|
|
{
|
|
WaitPrompt ("Unable to open file!");
|
|
haveFATdir = 0;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
ShowAction ("Loading ... Wait");
|
|
|
|
/* Read first data chunk */
|
|
if (UseFAT)
|
|
{
|
|
fread(readbuffer, 1, 2048, sdfile);
|
|
}
|
|
else
|
|
{
|
|
discoffset = rootdir;
|
|
dvd_read (&readbuffer, 2048, discoffset);
|
|
}
|
|
|
|
/* determine file type */
|
|
if (!IsZipFile ((char *) readbuffer))
|
|
{
|
|
if (UseFAT)
|
|
{
|
|
/* go back to file start and read file */
|
|
fseek(sdfile, 0, SEEK_SET);
|
|
fread(buffer, 1, rootdirlength, sdfile);
|
|
fclose(sdfile);
|
|
}
|
|
else
|
|
{
|
|
/* How many 2k blocks to read */
|
|
int blocks = rootdirlength / 2048;
|
|
int readoffset = 0;
|
|
int i;
|
|
|
|
/* read data chunks */
|
|
for (i = 0; i < blocks; i++)
|
|
{
|
|
dvd_read(readbuffer, 2048, discoffset);
|
|
discoffset += 2048;
|
|
memcpy (buffer + readoffset, readbuffer, 2048);
|
|
readoffset += 2048;
|
|
}
|
|
|
|
/* final read */
|
|
i = rootdirlength % 2048;
|
|
if (i)
|
|
{
|
|
dvd_read (readbuffer, 2048, discoffset);
|
|
memcpy (buffer + readoffset, readbuffer, i);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* unzip file */
|
|
if (UseFAT) return UnZipFAT(buffer, fname);
|
|
else return UnZipDVD (buffer, discoffset, rootdirlength);
|
|
}
|
|
|
|
return rootdirlength;
|
|
}
|