/****************************************************************************
* LoadFileToMemWithProgress
*
* Load up the file into a block of memory, while showing a progress dialog
***************************************************************************/
extern "C" int LoadFileToMemWithProgress(const char *progressText, const char *filepath, u8 **inbuffer, u32 *size)
{
int ret = LoadFileToMem(filepath, inbuffer, size);
return ret;
}
void ThemeMenu::SetupMainButtons()
{
ThemeList.clear();
DirList ThemeDir(Settings.theme_path, ".them", DirList::Files);
if (ThemeDir.GetFilecount() == 0)
{
WindowPrompt(tr( "No themes found." ), 0, "OK");
}
for(int i = 0; i < ThemeDir.GetFilecount(); ++i)
{
u8 *buffer = NULL;
u32 filesize;
debughelper_printf("%i %s\n", i, ThemeDir.GetFilepath(i));
LoadFileToMem(ThemeDir.GetFilepath(i), &buffer, &filesize);
if(!buffer) continue;
buffer[filesize-1] = '\0';
int size = ThemeList.size();
ThemeList.resize(size+1);
ThemeList[size].Filepath = ThemeDir.GetFilepath(i);
GetNodeText(buffer, "Theme-Title:", ThemeList[size].Title);
GetNodeText(buffer, "Theme-Team:", ThemeList[size].Team);
GetNodeText(buffer, "Theme-Version:", ThemeList[size].Version);
GetNodeText(buffer, "Image-Folder:", ThemeList[size].ImageFolder);
if(ThemeList[size].Title.size() == 0 && ThemeDir.GetFilename(i))
{
ThemeList[size].Title = ThemeDir.GetFilename(i);
size_t pos = ThemeList[size].Title.rfind('.');
if(pos != std::string::npos)
ThemeList[size].Title.erase(pos);
}
if(ThemeList[size].ImageFolder.size() == 0)
{
ThemeList[size].ImageFolder = ThemeDir.GetFilepath(i);
size_t pos = ThemeList[size].ImageFolder.rfind('.');
if(pos != std::string::npos)
ThemeList[size].ImageFolder.erase(pos);
ThemeList[size].ImageFolder += '/';
}
else
{
std::string tempString = ThemeList[size].ImageFolder;
ThemeList[size].ImageFolder = Settings.theme_path;
ThemeList[size].ImageFolder += tempString;
ThemeList[size].ImageFolder += '/';
}
SetMainButton(size, ThemeList[size].Title.c_str(), MainButtonImgData, NULL);
free(buffer);
}
}
void GuiImageAsync::guiImageAsyncThread(CThread *thread, void *arg)
{
while(!bExitRequested)
{
if(imageQueue.empty() && !bExitRequested)
pThread->suspendThread();
if(!imageQueue.empty() && !bExitRequested)
{
pMutex->lock();
pInUse = imageQueue.front();
imageQueue.erase(imageQueue.begin());
pMutex->unlock();
if (!pInUse)
continue;
if(pInUse->imgBuffer && pInUse->imgBufferSize)
{
pInUse->imgData = new GuiImageData(pInUse->imgBuffer, pInUse->imgBufferSize);
}
else
{
u8 *buffer = NULL;
u32 bufferSize = 0;
int iResult = LoadFileToMem(pInUse->filename.c_str(), &buffer, &bufferSize);
if(iResult > 0)
{
pInUse->imgData = new GuiImageData(buffer, bufferSize, GX2_TEX_CLAMP_MIRROR);
//! free original image buffer which is converted to texture now and not needed anymore
free(buffer);
}
}
if(pInUse->imgData)
{
if(pInUse->imgData->getTexture())
{
pInUse->width = pInUse->imgData->getWidth();
pInUse->height = pInUse->imgData->getHeight();
pInUse->imageData = pInUse->imgData;
}
else
{
delete pInUse->imgData;
pInUse->imgData = NULL;
}
}
pInUse->imageLoaded();
pInUse = NULL;
}
}
}
GuiImage * ListEmuBrowser::GetSaveIcon()
{
int i = browser->GetPageIndex() + selectedItem;
std::string savepath = fmt("%s/title/%08x/%08x/data/banner.bin", Settings.EmuNandPath, (u32)(EmuList.GetTid(i) >> 32), (u32)(EmuList.GetTid(i) & 0xFFFFFFFF));
u8* buffer = NULL;
u64 size = 0;
LoadFileToMem(savepath, &buffer, &size);
GuiSaveIcon * Icon = new GuiSaveIcon(buffer, size);
free(buffer);
buffer = NULL;
return Icon;
}
int LoadHomebrew(const char * path)
{
filepath = path;
u8 *buffer = NULL;
u64 filesize = 0;
int ret = LoadFileToMem(path, &buffer, &filesize);
if(ret < 0)
return ret;
ret = CopyHomebrewMemory(buffer, 0, filesize);
if(buffer) {
free(buffer);
buffer = NULL;
}
return ret;
}
int main(int argc, char** argv)
{
if(argc != 3)
{
std::cout << argv[0] << " infile.xmi outfile.mid" << std::endl;
return EXIT_SUCCESS;
}
std::vector<u8> buf = LoadFileToMem(argv[1]);
if(buf.size())
{
buf = Music::Xmi2Mid(buf);
if(buf.empty())
std::cerr << ", file: " << argv[1] << std::endl;
else
SaveMemToFile(buf, std::string(argv[2]));
}
return 0;
}
bool RebootApp(void)
{
// be sure to use current settings as arguments
editMetaArguments();
#ifdef FULLCHANNEL
ExitApp();
WII_Initialize();
return !(WII_LaunchTitle(TITLE_ID(0x00010001, 0x554c4e52)) < 0);
#else
// Load meta.xml arguments
char filepath[255];
HomebrewXML MetaXML;
snprintf(filepath, sizeof(filepath), "%s/meta.xml", Settings.update_path);
MetaXML.LoadHomebrewXMLData(filepath);
u8 *buffer = NULL;
u32 filesize = 0;
snprintf(filepath, sizeof(filepath), "%s/boot.dol", Settings.update_path);
LoadFileToMem(filepath, &buffer, &filesize);
if(!buffer)
{
return false;
}
FreeHomebrewBuffer();
CopyHomebrewMemory(buffer, 0, filesize);
AddBootArgument(filepath);
for(u32 i = 0; i < MetaXML.GetArguments().size(); ++i)
{
AddBootArgument(MetaXML.GetArguments().at(i).c_str());
}
return !(BootHomebrewFromMem() <0);
#endif
}
int LoadXmlParameters(ReducedCosAppXmlInfo * xmlInfo, const char *rpx_name, const char *path)
{
//--------------------------------------------------------------------------------------------
// setup default data
//--------------------------------------------------------------------------------------------
memset(xmlInfo, 0, sizeof(ReducedCosAppXmlInfo));
xmlInfo->version_cos_xml = 18; // default for most games
xmlInfo->os_version = 0x000500101000400A; // default for most games
xmlInfo->title_id = OSGetTitleID(); // use mii maker ID
xmlInfo->app_type = 0x80000000; // default for most games
xmlInfo->cmdFlags = 0; // default for most games
strlcpy(xmlInfo->rpx_name, rpx_name, sizeof(xmlInfo->rpx_name));
xmlInfo->max_size = 0x40000000; // default for most games
xmlInfo->avail_size = 0; // default for most games
xmlInfo->codegen_size = 0; // default for most games
xmlInfo->codegen_core = 1; // default for most games
xmlInfo->max_codesize = 0x03000000; // i think this is the best for most games
xmlInfo->overlay_arena = 0; // only very few have that set to 1
xmlInfo->exception_stack0_size = 0x1000; // default for most games
xmlInfo->exception_stack1_size = 0x1000; // default for most games
xmlInfo->exception_stack2_size = 0x1000; // default for most games
xmlInfo->sdk_version = 20909; // game dependent, lets take the one from mii maker
xmlInfo->title_version = 0; // game dependent, we say its 0
//--------------------------------------------------------------------------------------------
char* path_copy = (char*)malloc(FS_MAX_MOUNTPATH_SIZE);
if (!path_copy)
return -1;
char* xmlNodeData = (char*)malloc(XML_BUFFER_SIZE);
if(!xmlNodeData) {
free(path_copy);
return -3;
}
// create path
snprintf(path_copy, FS_MAX_MOUNTPATH_SIZE, "%s/cos.xml", path);
char* xmlData = NULL;
u32 xmlSize = 0;
if(LoadFileToMem(path_copy, (u8**) &xmlData, &xmlSize) > 0)
{
// ensure 0 termination
xmlData[XML_BUFFER_SIZE-1] = 0;
if(XML_GetNodeText(xmlData, "version", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 10);
xmlInfo->version_cos_xml = value;
}
if(XML_GetNodeText(xmlData, "cmdFlags", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 10);
xmlInfo->cmdFlags = value;
}
// always use RPX name from FS
//if(XML_GetNodeText(xmlData, "argstr", xmlNodeData, XML_BUFFER_SIZE))
//{
// strlcpy(xmlInfo->rpx_name, xmlNodeData, sizeof(xmlInfo->rpx_name));
//}
if(XML_GetNodeText(xmlData, "avail_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->avail_size = value;
}
if(XML_GetNodeText(xmlData, "codegen_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->codegen_size = value;
}
if(XML_GetNodeText(xmlData, "codegen_core", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->codegen_core = value;
}
if(XML_GetNodeText(xmlData, "max_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->max_size = value;
}
if(XML_GetNodeText(xmlData, "max_codesize", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->max_codesize = value;
}
if(XML_GetNodeText(xmlData, "overlay_arena", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->overlay_arena = value;
}
if(XML_GetNodeText(xmlData, "default_stack0_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->default_stack0_size = value;
}
if(XML_GetNodeText(xmlData, "default_stack1_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->default_stack1_size = value;
}
if(XML_GetNodeText(xmlData, "default_stack2_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->default_stack2_size = value;
}
if(XML_GetNodeText(xmlData, "default_redzone0_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->default_redzone0_size = value;
}
if(XML_GetNodeText(xmlData, "default_redzone1_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->default_redzone1_size = value;
}
if(XML_GetNodeText(xmlData, "default_redzone2_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->default_redzone2_size = value;
}
if(XML_GetNodeText(xmlData, "exception_stack0_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->exception_stack0_size = value;
}
if(XML_GetNodeText(xmlData, "exception_stack1_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->exception_stack0_size = value;
}
if(XML_GetNodeText(xmlData, "exception_stack2_size", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->exception_stack0_size = value;
}
}
//! free previous XML data memory
free(xmlData);
// create path
snprintf(path_copy, FS_MAX_MOUNTPATH_SIZE, "%s/app.xml", path);
if(LoadFileToMem(path_copy, (u8**) &xmlData, &xmlSize) > 0)
{
// ensure 0 termination
xmlData[XML_BUFFER_SIZE-1] = 0;
//--------------------------------------------------------------------------------------------
// version tag is still unknown where it is used
//--------------------------------------------------------------------------------------------
if(XML_GetNodeText(xmlData, "os_version", xmlNodeData, XML_BUFFER_SIZE))
{
uint64_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->os_version = value;
}
if(XML_GetNodeText(xmlData, "title_id", xmlNodeData, XML_BUFFER_SIZE))
{
uint64_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->title_id = value;
}
if(XML_GetNodeText(xmlData, "title_version", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->title_version = value;
}
if(XML_GetNodeText(xmlData, "sdk_version", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 10);
xmlInfo->sdk_version = value;
}
if(XML_GetNodeText(xmlData, "app_type", xmlNodeData, XML_BUFFER_SIZE))
{
uint32_t value = m_strtoll(xmlNodeData, 0, 16);
xmlInfo->app_type = value;
}
//--------------------------------------------------------------------------------------------
// group_id tag is still unknown where it is used
//--------------------------------------------------------------------------------------------
}
free(xmlData);
free(xmlNodeData);
free(path_copy);
return 0;
}
int __entry_menu(int argc, char** argv) {
InitOSFunctionPointers();
InitVPadFunctionPointers();
InitFSFunctionPointers();
mount_sd_fat("sd");
//Setup BATs for later
InjectSyscall36((unsigned int)injectBAT);
RunSyscall36();
InstallExceptionHandler();
initInputs();
initVideo();
videoDebugMessage(0, "All running!");
//*((int*)0x04) = 4243;
unsigned char* MEM2core = 0;
unsigned int coreSize = 0;
LoadFileToMem("sd://stella.elf", &MEM2core, &coreSize);
void* core = (void*)CORES_BASE_ADDRESS;
memcpy(core, MEM2core, coreSize); //Move core to MEM1
free(MEM2core);
int error = loadCore(core); //Load core symbols (UDynLoad)
char buf[255];
__os_snprintf(buf, 255, "Core loaded, error %d. Core at 0x%X", error, core);
videoDebugMessage(1, buf);
unsigned char* game = 0;
unsigned int gameSize = 0;
LoadFileToMem("sd://game.bin", &game, &gameSize);
error = setupCore((void*)game, gameSize); //Initialise core
__os_snprintf(buf, 255, "Setup core, error %d, game at %X size %X", error, game, gameSize);
videoDebugMessage(2, buf);
testVideoOutput();
while (1) {
pollInputs();
if (UIInputCheckButton()) {
break;
}
}
//cleanup
shutdownVideo();
memset(core, 0, coreSize); //Delete core from memory or HBL will cry every time
memset(game, 0, gameSize);
InjectSyscall36((unsigned int)clearBAT);
RunSyscall36();
return 0;
}
const u8 * NetReceiver::UncompressData()
{
if(!filebuffer)
return NULL;
//Zip File
if (filebuffer[0] == 'P' && filebuffer[1] == 'K' && filebuffer[2] == 0x03 && filebuffer[3] == 0x04)
{
char temppath[200];
char tempfilepath[200];
snprintf(temppath, sizeof(temppath), "%s/WiiXplorerTmp/", Settings.BootDevice);
snprintf(tempfilepath, sizeof(tempfilepath), "%s/WiiXplorerTmp/tmp.zip", Settings.BootDevice);
if(!CreateSubfolder(temppath))
{
FreeData();
return NULL;
}
FILE * file = fopen(tempfilepath, "wb");
if(!file)
{
FreeData();
RemoveDirectory(temppath);
return NULL;
}
fwrite(filebuffer, 1, filesize, file);
fclose(file);
FreeData();
ArchiveHandle * Zip = new ArchiveHandle(tempfilepath);
if(!Zip->ExtractAll(temppath))
{
delete Zip;
RemoveDirectory(temppath);
return NULL;
}
delete Zip;
DirList Dir(temppath, ".dol,.elf");
if(Dir.GetFilecount() <= 0)
{
RemoveDirectory(temppath);
ShowError(tr("No homebrew in the zip."));
return NULL;
}
char newfilepath[300];
snprintf(newfilepath, sizeof(newfilepath), "%s", Dir.GetFilepath(0));
snprintf(FileName, sizeof(FileName), "%s", Dir.GetFilename(0));
u8 * buffer = NULL;
u32 newfilesize = 0;
if(LoadFileToMem(newfilepath, &buffer, &newfilesize) < 0)
{
RemoveDirectory(temppath);
return NULL;
}
RemoveDirectory(temppath);
filesize = newfilesize;
filebuffer = buffer;
}
//WiiLoad zlib compression
else if((wiiloadVersion[0] > 0 || wiiloadVersion[1] > 4) && uncfilesize != 0)
{
u8 * unc = (u8 *) malloc(uncfilesize);
if(!unc)
{
FreeData();
return NULL;
}
uLongf f = uncfilesize;
if(uncompress(unc, &f, filebuffer, filesize) != Z_OK)
{
free(unc);
FreeData();
return NULL;
}
free(filebuffer);
filebuffer = unc;
filesize = f;
}
return filebuffer;
}
