int fileBrowser_libfat_readDir(fileBrowser_file* file, fileBrowser_file** dir){
pauseRemovalThread();
DIR* dp = opendir( file->name );
if(!dp) return FILE_BROWSER_ERROR;
struct dirent * temp = NULL;
struct stat fstat;
// Set everything up to read
//char filename[MAXPATHLEN];
int num_entries = 2, i = 0;
*dir = malloc( num_entries * sizeof(fileBrowser_file) );
// Read each entry of the directory
while( (temp = readdir(dp)) && (temp != NULL) ){
// Make sure we have room for this one
if(i == num_entries){
++num_entries;
*dir = realloc( *dir, num_entries * sizeof(fileBrowser_file) );
}
sprintf((*dir)[i].name, "%s/%s", file->name, temp->d_name);
(*dir)[i].offset = 0;
(*dir)[i].size = fstat.st_size;
(*dir)[i].attr = (fstat.st_mode & S_IFDIR) ?
FILE_BROWSER_ATTR_DIR : 0;
++i;
}
continueRemovalThread();
return num_entries;
}
int fileBrowser_libfatROM_deinit(fileBrowser_file* f){
pauseRemovalThread();
if(fd)
fclose(fd);
fd = NULL;
continueRemovalThread();
return 0;
}
int fileBrowser_libfatROM_deinit(fileBrowser_file* f){
pauseRemovalThread();
if(fd[f->attr]) {
fclose(fd[f->attr]);
}
fd[f->attr] = NULL;
continueRemovalThread();
return 0;
}
int fileBrowser_libfat_writeFile(fileBrowser_file* file, void* buffer, unsigned int length){
pauseRemovalThread();
FILE* f = fopen( file->name, "wb" );
if(!f) return FILE_BROWSER_ERROR;
fseek(f, file->offset, SEEK_SET);
int bytes_read = fwrite(buffer, 1, length, f);
if(bytes_read > 0) file->offset += bytes_read;
fclose(f);
continueRemovalThread();
return bytes_read;
}
int fileBrowser_libfatROM_readFile(fileBrowser_file* file, void* buffer, unsigned int length){
if(stop) //do this only in the menu
pauseRemovalThread();
if(!fd) fd = fopen( file->name, "rb");
fseek(fd, file->offset, SEEK_SET);
int bytes_read = fread(buffer, 1, length, fd);
if(bytes_read > 0) file->offset += bytes_read;
if(stop)
continueRemovalThread();
return bytes_read;
}
static char* playGame_func(){
if(!hasLoadedROM) return "Please load a ROM first";
pauseRemovalThread();
resumeAudio();
resumeInput();
GUI_toggle();
go();
GUI_toggle();
pauseInput();
pauseAudio();
continueRemovalThread();
return NULL;
}
/* call fileBrowser_libfat_init as much as you like for all devices
- returns 0 on device not present/error
- returns 1 on ok
*/
int fileBrowser_libfat_init(fileBrowser_file* f){
int res = 0;
if(!rThreadCreated) InitRemovalThread();
#ifdef HW_RVL
if(f->name[0] == 's') { //SD
if(!sdMounted) { //if there's nothing currently mounted
pauseRemovalThread();
if(sdNeedsUnmount) {
fatUnmount("sd");
if(sdNeedsUnmount==FRONTSD)
frontsd->shutdown();
else if(sdNeedsUnmount==CARD_A)
carda->shutdown();
else if(sdNeedsUnmount==CARD_B)
cardb->shutdown();
sdNeedsUnmount = 0;
}
if(fatMountSimple ("sd", frontsd)) {
sdMounted = FRONTSD;
res = 1;
}
else if(fatMountSimple ("sd", carda)) {
sdMounted = CARD_A;
res = 1;
}
else if(fatMountSimple ("sd", cardb)) {
sdMounted = CARD_B;
res = 1;
}
continueRemovalThread();
return res;
}
else
return 1;
}
else if(f->name[0] == 'u') {
if(!usbMounted) {
pauseRemovalThread();
if(usbNeedsUnmount) {
fatUnmount("usb");
usb->shutdown();
usbNeedsUnmount=0;
}
if(fatMountSimple ("usb", usb))
usbMounted = 1;
continueRemovalThread();
return usbMounted;
}
else
return 1;
}
return res;
#else
if(!sdMounted) { //GC has only SD
if(sdNeedsUnmount) fatUnmount("sd");
switch(sdNeedsUnmount){ //unmount previous devices
case CARD_A:
carda->shutdown();
break;
case CARD_B:
cardb->shutdown();
break;
}
if(carda->startup()) {
res |= fatMountSimple ("sd", carda);
if(res)
sdMounted = CARD_A;
}
else if(cardb->startup() && !res) {
res |= fatMountSimple ("sd", cardb);
if(res)
sdMounted = CARD_B;
}
return res;
}
return 1; //we're always ok
#endif
}
void Func_PlayGame()
{
if(!hasLoadedROM)
{
menu::MessageBox::getInstance().setMessage("Please load a ROM first");
return;
}
//Wait until 'A' button released before play/resume game
menu::Cursor::getInstance().setFreezeAction(true);
menu::Focus::getInstance().setFreezeAction(true);
int buttonHeld = 1;
while(buttonHeld)
{
buttonHeld = 0;
menu::Gui::getInstance().draw();
for (int i=0; i<4; i++)
{
if(PAD_ButtonsHeld(i) & PAD_BUTTON_A) buttonHeld++;
#ifdef HW_RVL
WPADData* wiiPad = WPAD_Data(i);
if(wiiPad->err == WPAD_ERR_NONE && wiiPad->btns_h & (WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A)) buttonHeld++;
#endif
}
}
menu::Cursor::getInstance().setFreezeAction(false);
menu::Focus::getInstance().setFreezeAction(false);
menu::Gui::getInstance().gfx->clearEFB((GXColor){0, 0, 0, 0xFF}, 0x000000);
pause_netinit_thread();
pauseRemovalThread();
resumeAudio();
resumeInput();
menuActive = 0;
#ifdef DEBUGON
_break();
#endif
new_frame();
new_vi();
go();
#ifdef DEBUGON
_break();
#endif
menuActive = 1;
pauseInput();
pauseAudio();
if(autoSave==AUTOSAVE_ENABLE) {
if(flashramWritten || sramWritten || eepromWritten || mempakWritten) { //something needs saving
switch (nativeSaveDevice)
{
case NATIVESAVEDEVICE_SD:
case NATIVESAVEDEVICE_USB:
// Adjust saveFile pointers
saveFile_dir = (nativeSaveDevice==NATIVESAVEDEVICE_SD) ? &saveDir_libfat_Default:&saveDir_libfat_USB;
saveFile_readFile = fileBrowser_libfat_readFile;
saveFile_writeFile = fileBrowser_libfat_writeFile;
saveFile_init = fileBrowser_libfat_init;
saveFile_deinit = fileBrowser_libfat_deinit;
break;
case NATIVESAVEDEVICE_CARDA:
case NATIVESAVEDEVICE_CARDB:
// Adjust saveFile pointers
saveFile_dir = (nativeSaveDevice==NATIVESAVEDEVICE_CARDA) ? &saveDir_CARD_SlotA:&saveDir_CARD_SlotB;
saveFile_readFile = fileBrowser_CARD_readFile;
saveFile_writeFile = fileBrowser_CARD_writeFile;
saveFile_init = fileBrowser_CARD_init;
saveFile_deinit = fileBrowser_CARD_deinit;
break;
}
// Try saving everything
int amountSaves = flashramWritten + sramWritten + eepromWritten + mempakWritten;
int result = 0;
saveFile_init(saveFile_dir);
result += saveEeprom(saveFile_dir);
result += saveSram(saveFile_dir);
result += saveMempak(saveFile_dir);
result += saveFlashram(saveFile_dir);
saveFile_deinit(saveFile_dir);
if (result==amountSaves) { //saved all of them ok
switch (nativeSaveDevice)
{
case NATIVESAVEDEVICE_SD:
menu::MessageBox::getInstance().fadeMessage("Automatically saved to SD card");
break;
case NATIVESAVEDEVICE_USB:
menu::MessageBox::getInstance().fadeMessage("Automatically saved to USB device");
break;
case NATIVESAVEDEVICE_CARDA:
menu::MessageBox::getInstance().fadeMessage("Automatically saved to memcard in Slot A");
break;
case NATIVESAVEDEVICE_CARDB:
menu::MessageBox::getInstance().fadeMessage("Automatically saved to memcard in Slot B");
break;
}
flashramWritten = sramWritten = eepromWritten = mempakWritten = 0; //nothing new written since save
}
else
menu::MessageBox::getInstance().setMessage("Failed to save game"); //one or more failed to save
}
}
continueRemovalThread();
resume_netinit_thread();
FRAME_BUTTONS[5].buttonString = FRAME_STRINGS[6];
menu::Cursor::getInstance().clearCursorFocus();
}
void savestates_save()
{
gzFile f;
char *filename, buf[1024];
int len, i;
/* fix the filename to %s.st%d format */
filename = malloc(1024);
sprintf(filename, "%s%s%s%s.st%d",(saveStateDevice==SAVESTATEDEVICE_USB)?"usb:":"sd:",
statespath, ROM_SETTINGS.goodname, saveregionstr(),savestates_slot);
f = gzopen(filename, "wb");
free(filename);
if(!f) {
return;
}
if(stop) {
pauseRemovalThread();
}
else {
pauseAudio();
}
gzwrite(f, &rdram_register, sizeof(RDRAM_register));
gzwrite(f, &MI_register, sizeof(mips_register));
gzwrite(f, &pi_register, sizeof(PI_register));
gzwrite(f, &sp_register, sizeof(SP_register));
gzwrite(f, &rsp_register, sizeof(RSP_register));
gzwrite(f, &si_register, sizeof(SI_register));
gzwrite(f, &vi_register, sizeof(VI_register));
gzwrite(f, &ri_register, sizeof(RI_register));
gzwrite(f, &ai_register, sizeof(AI_register));
gzwrite(f, &dpc_register, sizeof(DPC_register));
gzwrite(f, &dps_register, sizeof(DPS_register));
#ifdef USE_EXPANSION
gzwrite(f, rdram, 0x800000);
#else
gzwrite(f, rdram, 0x400000);
#endif
gzwrite(f, SP_DMEM, 0x1000);
gzwrite(f, SP_IMEM, 0x1000);
gzwrite(f, PIF_RAM, 0x40);
save_flashram_infos(buf);
gzwrite(f, buf, 24);
#ifndef USE_TLB_CACHE
gzwrite(f, tlb_LUT_r, 0x100000);
gzwrite(f, tlb_LUT_w, 0x100000);
#else
//Traverse the TLB cache hash and dump it
TLBCache_dump_r(f);
TLBCache_dump_w(f);
#endif
gzwrite(f, &llbit, 4);
gzwrite(f, reg, 32*8);
for (i=0; i<32; i++) gzwrite(f, reg_cop0+i, 8); // *8 for compatibility with old versions purpose
gzwrite(f, &lo, 8);
gzwrite(f, &hi, 8);
if ((Status & 0x04000000) == 0)
{ // FR bit == 0 means 32-bit (MIPS I) FGR mode
shuffle_fpr_data(0, 0x04000000); // shuffle data into 64-bit register format for storage
gzwrite(f, reg_cop1_fgr_64, 32*8);
shuffle_fpr_data(0x04000000, 0); // put it back in 32-bit mode
}
else
{
gzwrite(f, reg_cop1_fgr_64, 32*8);
}
gzwrite(f, &FCR0, 4);
gzwrite(f, &FCR31, 4);
gzwrite(f, tlb_e, 32*sizeof(tlb));
gzwrite(f, &interp_addr, 4); //Dynarec should be ok with just this
gzwrite(f, &next_interupt, 4);
gzwrite(f, &next_vi, 4);
gzwrite(f, &vi_field, 4);
len = save_eventqueue_infos(buf);
gzwrite(f, buf, len);
gzclose(f);
if(stop) {
continueRemovalThread();
}
else {
resumeAudio();
}
}
void savestates_load()
{
gzFile f = NULL;
char *filename, buf[1024];
int len, i;
/* fix the filename to %s.st%d format */
filename = malloc(1024);
sprintf(filename, "%s%s%s%s.st%d",(saveStateDevice==SAVESTATEDEVICE_USB)?"usb:":"sd:",
statespath, ROM_SETTINGS.goodname, saveregionstr(),savestates_slot);
f = gzopen(filename, "rb");
free(filename);
if (!f) {
return;
}
if(stop) {
pauseRemovalThread();
}
else {
pauseAudio();
}
gzread(f, &rdram_register, sizeof(RDRAM_register));
gzread(f, &MI_register, sizeof(mips_register));
gzread(f, &pi_register, sizeof(PI_register));
gzread(f, &sp_register, sizeof(SP_register));
gzread(f, &rsp_register, sizeof(RSP_register));
gzread(f, &si_register, sizeof(SI_register));
gzread(f, &vi_register, sizeof(VI_register));
gzread(f, &ri_register, sizeof(RI_register));
gzread(f, &ai_register, sizeof(AI_register));
gzread(f, &dpc_register, sizeof(DPC_register));
gzread(f, &dps_register, sizeof(DPS_register));
#ifdef USE_EXPANSION
gzread(f, rdram, 0x800000);
#else
gzread(f, rdram, 0x400000);
#endif
gzread(f, SP_DMEM, 0x1000);
gzread(f, SP_IMEM, 0x1000);
gzread(f, PIF_RAM, 0x40);
gzread(f, buf, 24);
load_flashram_infos(buf);
#ifndef USE_TLB_CACHE
gzread(f, tlb_LUT_r, 0x100000);
gzread(f, tlb_LUT_w, 0x100000);
#else
int numNodesWritten_r=0,numNodesWritten_w=0,cntr,tlbpage,tlbvalue;
TLBCache_deinit();
TLBCache_init();
//Load number of them..
gzread(f, &numNodesWritten_r, 4);
for(cntr=0;cntr<numNodesWritten_r;cntr++)
{
gzread(f, &tlbpage, 4);
gzread(f, &tlbvalue, 4);
TLBCache_set_r(tlbpage,tlbvalue);
}
gzread(f, &numNodesWritten_w, 4);
for(cntr=0;cntr<numNodesWritten_w;cntr++)
{
gzread(f, &tlbpage, 4);
gzread(f, &tlbvalue, 4);
TLBCache_set_w(tlbpage,tlbvalue);
}
#endif
gzread(f, &llbit, 4);
gzread(f, reg, 32*8);
for (i=0; i<32; i++)
{
gzread(f, reg_cop0+i, 4);
gzread(f, buf, 4); // for compatibility with old versions purpose
}
set_fpr_pointers(Status); // Status is reg_cop0[12]
gzread(f, &lo, 8);
gzread(f, &hi, 8);
gzread(f, reg_cop1_fgr_64, 32*8);
if ((Status & 0x04000000) == 0) // 32-bit FPR mode requires data shuffling because 64-bit layout is always stored in savestate file
shuffle_fpr_data(0x04000000, 0);
gzread(f, &FCR0, 4);
gzread(f, &FCR31, 4);
gzread(f, tlb_e, 32*sizeof(tlb));
for (i=0; i<0x100000; i++)
invalid_code_set(i, 1);
gzread(f, &interp_addr, 4); //dynarec should be ok with just this
gzread(f, &next_interupt, 4);
gzread(f, &next_vi, 4);
gzread(f, &vi_field, 4);
len = 0;
while(1)
{
gzread(f, buf+len, 4);
if (*((unsigned long*)&buf[len]) == 0xFFFFFFFF) break;
gzread(f, buf+len+4, 4);
len += 8;
}
load_eventqueue_infos(buf);
gzclose(f);
last_addr = interp_addr;
if(stop) {
continueRemovalThread();
}
else {
resumeAudio();
}
}
