static void system_exec(const char *path, bool should_load_game)
{
(void)should_load_game;
RARCH_LOG("Attempt to load executable: [%s].\n", path);
#ifdef IS_SALAMANDER
XLaunchNewImage(path, NULL);
#else
#if defined(_XBOX1)
LAUNCH_DATA ptr;
memset(&ptr, 0, sizeof(ptr));
if (should_load_game)
{
snprintf((char*)ptr.Data, sizeof(ptr.Data), "%s", g_extern.fullpath);
XLaunchNewImage(path, &ptr);
}
else
XLaunchNewImage(path, NULL);
#elif defined(_XBOX360)
char game_path[1024];
if (should_load_game)
{
strlcpy(game_path, g_extern.fullpath, sizeof(game_path));
XSetLaunchData(game_path, MAX_LAUNCH_DATA_SIZE);
}
XLaunchNewImage(path, NULL);
#endif
#endif
}
void rarch_exec (void)
{
if(g_console.return_to_launcher)
{
RARCH_LOG("Attempt to load executable: [%s].\n", g_console.launch_app_on_exit);
#if defined(_XBOX)
XLaunchNewImage(g_console.launch_app_on_exit, NULL);
#elif defined(__CELLOS_LV2__)
char spawn_data[256];
for(unsigned int i = 0; i < sizeof(spawn_data); ++i)
spawn_data[i] = i & 0xff;
char spawn_data_size[16];
snprintf(spawn_data_size, sizeof(spawn_data_size), "%d", 256);
const char * const spawn_argv[] = {
spawn_data_size,
"test argv for",
"sceNpDrmProcessExitSpawn2()",
NULL
};
SceNpDrmKey * k_licensee = NULL;
int ret = sceNpDrmProcessExitSpawn2(k_licensee, g_console.launch_app_on_exit, (const char** const)spawn_argv, NULL, (sys_addr_t)spawn_data, 256, 1000, SYS_PROCESS_PRIMARY_STACK_SIZE_1M);
if(ret < 0)
{
RARCH_WARN("SELF file is not of NPDRM type, trying another approach to boot it...\n");
sys_game_process_exitspawn(g_console.launch_app_on_exit, NULL, NULL, NULL, 0, 1000, SYS_PROCESS_PRIMARY_STACK_SIZE_1M);
}
sceNpTerm();
cellSysmoduleUnloadModule(CELL_SYSMODULE_SYSUTIL_NP);
cellSysmoduleUnloadModule(CELL_SYSMODULE_NET);
#endif
}
}
/*
==============
Sys_PlatformExit
Windows specific initialisation
==============
*/
void Sys_PlatformExit( void )
{
#ifdef _DEBUG
DebugBreak();
#endif
XLaunchNewImage(XLAUNCH_KEYWORD_DASH, 0);
}
static void frontend_xdk_exec(const char *path, bool should_load_game)
{
#ifndef IS_SALAMANDER
bool *verbose = retro_main_verbosity();
bool original_verbose = *verbose;
*verbose = true;
#endif
(void)should_load_game;
#ifdef IS_SALAMANDER
if (path[0] != '\0')
XLaunchNewImage(path, NULL);
#else
#ifdef _XBOX
char *fullpath = NULL;
runloop_ctl(RUNLOOP_CTL_GET_CONTENT_PATH, &fullpath);
#if defined(_XBOX1)
LAUNCH_DATA ptr;
memset(&ptr, 0, sizeof(ptr));
if (should_load_game && fullpath[0] != '\0')
snprintf((char*)ptr.Data, sizeof(ptr.Data), "%s", fullpath);
if (path[0] != '\0')
XLaunchNewImage(path, ptr.Data[0] != '\0' ? &ptr : NULL);
#elif defined(_XBOX360)
char game_path[1024] = {0};
if (should_load_game && fullpath[0] != '\0')
{
strlcpy(game_path, fullpath, sizeof(game_path));
XSetLaunchData(game_path, MAX_LAUNCH_DATA_SIZE);
}
if (path[0] != '\0')
XLaunchNewImage(path, NULL);
#endif
#endif
#endif
#ifndef IS_SALAMANDER
*verbose = original_verbose;
#endif
}
static void frontend_xdk_exec(const char *path, bool should_load_game)
{
#ifndef IS_SALAMANDER
bool original_verbose = verbosity_is_enabled();
#endif
#if defined(_XBOX1)
LAUNCH_DATA ptr;
#elif defined(_XBOX360)
char game_path[1024] = {0};
#endif
(void)should_load_game;
#ifdef IS_SALAMANDER
if (!string_is_empty(path))
XLaunchNewImage(path, NULL);
#else
#if defined(_XBOX1)
memset(&ptr, 0, sizeof(ptr));
if (should_load_game && !path_is_empty(RARCH_PATH_CONTENT))
snprintf((char*)ptr.Data, sizeof(ptr.Data), "%s", path_get(RARCH_PATH_CONTENT));
if (!string_is_empty(path))
XLaunchNewImage(path, !string_is_empty((const char*)ptr.Data) ? &ptr : NULL);
#elif defined(_XBOX360)
if (should_load_game && !path_is_empty(RARCH_PATH_CONTENT))
{
strlcpy(game_path, path_get(RARCH_PATH_CONTENT), sizeof(game_path));
XSetLaunchData(game_path, MAX_LAUNCH_DATA_SIZE);
}
if (!string_is_empty(path))
XLaunchNewImage(path, 0);
#endif
#endif
#ifndef IS_SALAMANDER
if (original_verbose)
verbosity_enable();
else
verbosity_disable();
#endif
}
void XReturnToLaunchingXBE( )
{
if ( g_launchReturnXBE )
{
LD_LAUNCH_DASHBOARD LaunchData = { XLD_LAUNCH_DASHBOARD_MAIN_MENU };
}
else
{
LD_LAUNCH_DASHBOARD LaunchData = { XLD_LAUNCH_DASHBOARD_MAIN_MENU };
XLaunchNewImage( NULL, (LAUNCH_DATA*)&LaunchData );
}
}
static void frontend_xdk_exec(const char *path, bool should_load_game)
{
#ifndef IS_SALAMANDER
bool original_verbose = g_extern.verbose;
g_extern.verbose = true;
#endif
(void)should_load_game;
RARCH_LOG("Attempt to load executable: [%s].\n", path);
#ifdef IS_SALAMANDER
if (path[0] != '\0')
XLaunchNewImage(path, NULL);
#else
#if defined(_XBOX1)
LAUNCH_DATA ptr;
memset(&ptr, 0, sizeof(ptr));
if (should_load_game && g_extern.fullpath[0] != '\0')
snprintf((char*)ptr.Data, sizeof(ptr.Data), "%s", g_extern.fullpath);
if (path[0] != '\0')
XLaunchNewImage(path, ptr.Data[0] != '\0' ? &ptr : NULL);
#elif defined(_XBOX360)
char game_path[1024];
if (should_load_game && g_extern.fullpath[0] != '\0')
{
strlcpy(game_path, g_extern.fullpath, sizeof(game_path));
XSetLaunchData(game_path, MAX_LAUNCH_DATA_SIZE);
}
if (path[0] != '\0')
XLaunchNewImage(path, NULL);
#endif
#endif
#ifndef IS_SALAMANDER
g_extern.verbose = original_verbose;
#endif
}
void Sys_Reboot( const char *reason )
{
LAUNCH_DATA ld;
const char *path = NULL;
memset( &ld, 0, sizeof(ld) );
if (!Q_stricmp(reason, "new_account"))
{
PLD_LAUNCH_DASHBOARD pDash = (PLD_LAUNCH_DASHBOARD) &ld;
pDash->dwReason = XLD_LAUNCH_DASHBOARD_NEW_ACCOUNT_SIGNUP;
path = NULL;
}
else if (!Q_stricmp(reason, "net_config"))
{
PLD_LAUNCH_DASHBOARD pDash = (PLD_LAUNCH_DASHBOARD) &ld;
pDash->dwReason = XLD_LAUNCH_DASHBOARD_NETWORK_CONFIGURATION;
path = NULL;
}
else if (!Q_stricmp(reason, "manage_account"))
{
PLD_LAUNCH_DASHBOARD pDash = (PLD_LAUNCH_DASHBOARD) &ld;
pDash->dwReason = XLD_LAUNCH_DASHBOARD_ACCOUNT_MANAGEMENT;
path = NULL;
}
else if (!Q_stricmp(reason, "singleplayer"))
{
path = "d:\\default.xbe";
strcpy((char *)&ld.Data[0], LAUNCH_MAGIC);
}
else
{
Com_Error( ERR_FATAL, "Unknown reboot code %s\n", reason );
}
// Title should not be doing ANYTHING in the background.
// Shutting down sound ensures that the sound thread is gone
S_Shutdown();
// Similarly, kill off the streaming thread
extern void Sys_StreamShutdown(void);
Sys_StreamShutdown();
XLaunchNewImage(path, &ld);
// This function should not return!
Com_Error( ERR_FATAL, "ERROR: XLaunchNewImage returned\n" );
}
//-------------------------------------------------------------------------------------
// Name: main()
// Desc: The application's entry point
//-------------------------------------------------------------------------------------
void __cdecl main()
{
// Create a system thread to launch our "system plugin"
HANDLE hThread;
DWORD threadId;
ExCreateThread(&hThread, 0, &threadId, (VOID*)XapiThreadStartup, (LPTHREAD_START_ROUTINE)StartSystemDll, NULL, 0x2);
// Set the thread processor and priority, otherwise it will start on its own
XSetThreadProcessor(hThread, 4);
SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
ResumeThread(hThread);
// Just loop until the dll has been loaded
while (DllResult == -1) { Sleep(0); }
// The dll has loaded, now launch the game executable
XLaunchNewImage((CHAR*)&GameXexPath, NULL);
}
virtual void run()
{
#ifdef _XBOX
XSetThreadProcessor(GetCurrentThread(), _processorNo);
#endif
Thread::yield();
LOG(0, "&& AsyncLoader @%d: started\n", CurrentProcessorNo());
while (!_terminated)
{
_mutex.lock();
_current = NULL;
PopFront(_current);
_mutex.unlock();
if (_current == NULL)
{
LOG(0, "&& AsyncLoader @%d: idle\n", CurrentProcessorNo());
_queueReady.wait();
continue;
}
LOG(0, "&& AsyncLoader @%d: pick-up '%s'\n", CurrentProcessorNo(), _current->getName().c_str());
try
{
_current->prepare(true);
}
catch (...)
{
LOG(0, "&& AsyncLoader @%d: Terminated due to an exception.\n", CurrentProcessorNo());
#ifdef _XBOX
XLaunchNewImage( XLAUNCH_KEYWORD_DASH_ARCADE, 0 );
return;
#endif
}
LOG(0, "&& AsyncLoader @%d: output '%s'\n", CurrentProcessorNo(), _current->getName().c_str());
AddOutput(_current);
}
LOG(0, "&& AsyncLoader @%d: terminated\n", CurrentProcessorNo());
}
int main(int argc, char *argv[])
{
int ret;
#if defined(_XBOX)
XINPUT_STATE state;
get_environment_settings();
XInputGetState(0, &state);
if(state.Gamepad.wButtons & XINPUT_GAMEPAD_Y)
{
//override path, boot first executable in cores directory
RARCH_LOG("Fallback - Will boot first executable in RetroArch cores directory.\n");
find_and_set_first_file();
}
else
{
//normal executable loading path
init_settings();
}
XLaunchNewImage(libretro_path, NULL);
RARCH_LOG("Launch libretro core: [%s] (return code: %x]).\n", libretro_path, ret);
#elif defined(__CELLOS_LV2__)
CellPadData pad_data;
char spawn_data[256], spawn_data_size[16];
SceNpDrmKey * k_licensee = NULL;
cellSysutilRegisterCallback(0, callback_sysutil_exit, NULL);
cellSysmoduleLoadModule(CELL_SYSMODULE_IO);
cellSysmoduleLoadModule(CELL_SYSMODULE_FS);
cellSysmoduleLoadModule(CELL_SYSMODULE_SYSUTIL_GAME);
cellSysmoduleLoadModule(CELL_SYSMODULE_NET);
cellSysmoduleLoadModule(CELL_SYSMODULE_SYSUTIL_NP);
sys_net_initialize_network();
#ifdef HAVE_LOGGER
logger_init();
#endif
sceNpInit(NP_POOL_SIZE, np_pool);
get_environment_settings();
cellPadInit(7);
cellPadGetData(0, &pad_data);
if(pad_data.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_TRIANGLE)
{
//override path, boot first executable in cores directory
RARCH_LOG("Fallback - Will boot first executable in RetroArch cores/ directory.\n");
find_and_set_first_file();
}
else
{
//normal executable loading path
init_settings();
}
cellPadEnd();
#ifdef HAVE_LOGGER
logger_shutdown();
#endif
for(unsigned int i = 0; i < sizeof(spawn_data); ++i)
spawn_data[i] = i & 0xff;
snprintf(spawn_data_size, sizeof(spawn_data_size), "%d", 256);
const char * const spawn_argv[] = {
spawn_data_size,
"test argv for",
"sceNpDrmProcessExitSpawn2()",
NULL
};
ret = sceNpDrmProcessExitSpawn2(k_licensee, libretro_path, (const char** const)spawn_argv, NULL, (sys_addr_t)spawn_data, 256, 1000, SYS_PROCESS_PRIMARY_STACK_SIZE_1M);
RARCH_LOG("Launch libretro core: [%s] (return code: %x]).\n", libretro_path, ret);
if(ret < 0)
{
RARCH_LOG("Executable file is not of NPDRM type, trying another approach to boot it...\n");
sys_game_process_exitspawn2(libretro_path, NULL, NULL, NULL, 0, 1000, SYS_PROCESS_PRIMARY_STACK_SIZE_1M);
}
sceNpTerm();
sys_net_finalize_network();
cellSysmoduleUnloadModule(CELL_SYSMODULE_SYSUTIL_NP);
cellSysmoduleUnloadModule(CELL_SYSMODULE_NET);
cellSysmoduleUnloadModule(CELL_SYSMODULE_SYSUTIL_GAME);
cellSysmoduleLoadModule(CELL_SYSMODULE_FS);
cellSysmoduleLoadModule(CELL_SYSMODULE_IO);
#endif
return 1;
}
void CMenuMain::ProcessInput()
{
uint16_t input_state = 0;
input_xinput.poll(NULL);
static const struct retro_keybind *binds[MAX_PLAYERS] = {
g_settings.input.binds[0],
g_settings.input.binds[1],
g_settings.input.binds[2],
g_settings.input.binds[3],
g_settings.input.binds[4],
g_settings.input.binds[5],
g_settings.input.binds[6],
g_settings.input.binds[7],
};
for (unsigned i = 0; i < RARCH_FIRST_META_KEY; i++)
{
input_state |= input_xinput.input_state(NULL, binds, false,
RETRO_DEVICE_JOYPAD, 0, i) ? (1 << i) : 0;
}
uint16_t trigger_state = input_state & ~old_input_state;
if(trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_DOWN))
{
if(m_romListSelectedRom < g_romList.GetRomListSize())
{
if(m_menuMainRomSelectPanel_y < (m_menuMainRomListPos_y + (m_menuMainRomListSpacing * m_romListEndRender)))
{
m_menuMainRomSelectPanel_y += m_menuMainRomListSpacing;
m_romListSelectedRom++;
RARCH_LOG("SELECTED ROM: %d.\n", m_romListSelectedRom);
}
if(m_menuMainRomSelectPanel_y > (m_menuMainRomListPos_y + (m_menuMainRomListSpacing * (m_romListEndRender))))
{
m_menuMainRomSelectPanel_y -= m_menuMainRomListSpacing;
m_romListSelectedRom++;
if(m_romListSelectedRom > g_romList.GetRomListSize() - 1)
m_romListSelectedRom = g_romList.GetRomListSize() - 1;
RARCH_LOG("SELECTED ROM AFTER CORRECTION: %d.\n", m_romListSelectedRom);
if(m_romListSelectedRom < g_romList.GetRomListSize() - 1 && m_romListOffset < g_romList.GetRomListSize() - 1 - m_romListEndRender - 1)
{
m_romListOffset++;
RARCH_LOG("OFFSET: %d.\n", m_romListOffset);
}
}
}
}
if(trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_UP))
{
if(m_romListSelectedRom > -1)
{
if(m_menuMainRomSelectPanel_y > (m_menuMainRomListPos_y - m_menuMainRomListSpacing))
{
m_menuMainRomSelectPanel_y -= m_menuMainRomListSpacing;
m_romListSelectedRom--;
RARCH_LOG("SELECTED ROM: %d.\n", m_romListSelectedRom);
}
if(m_menuMainRomSelectPanel_y < (m_menuMainRomListPos_y - m_menuMainRomListSpacing))
{
m_menuMainRomSelectPanel_y += m_menuMainRomListSpacing;
m_romListSelectedRom--;
if(m_romListSelectedRom < 0)
m_romListSelectedRom = 0;
RARCH_LOG("SELECTED ROM AFTER CORRECTION: %d.\n", m_romListSelectedRom);
if(m_romListSelectedRom > 0 && m_romListOffset > 0)
{
m_romListOffset--;
RARCH_LOG("OFFSET: %d.\n", m_romListOffset);
}
}
}
}
// Press A to launch, selected rom filename is saved into T:\\tmp.retro
if (trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_B) || trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_START))
rarch_console_load_game(g_romList.GetRomAt(m_romListSelectedRom)->GetFileName().c_str());
if (trigger_state & (1 << RETRO_DEVICE_ID_JOYPAD_R3))
{
LD_LAUNCH_DASHBOARD LaunchData = { XLD_LAUNCH_DASHBOARD_MAIN_MENU };
XLaunchNewImage( NULL, (LAUNCH_DATA*)&LaunchData );
}
}
void FvDebugMsgHelper::CriticalMessageHelper( bool bIsDevAssertion,
const char *pcFormat, va_list kArgPtr )
{
char acBuffer[ FV_DEBUG_BUFSIZ * 2 ];
FvVSNPrintf( acBuffer, sizeof(acBuffer), pcFormat, kArgPtr );
acBuffer[sizeof(acBuffer)-1] = '\0';
#if FV_ENABLE_STACK_TRACKER
if (StackTracker::stackSize() > 0)
{
std::string stack = StackTracker::buildReport();
strcat( acBuffer, "\n" );
strcat( acBuffer, "Stack trace: " );
strcat( acBuffer, stack.c_str() );
strcat( acBuffer, "\n" );
}
#endif // FV_ENABLE_STACK_TRACKER
#if !defined( _WIN32 ) && !defined( PLAYSTATION3 )
if (g_bShouldWriteToSyslog)
{
syslog( LOG_CRIT, "%s", acBuffer );
}
#endif // (! _WIN32 && !PLAYSTATION3)
this->Message( "%s", acBuffer );
this->MessageBackTrace();
if (bIsDevAssertion && !FvDebugFilter::Instance().HasDevelopmentAssertions())
{
return;
}
if (FvDebugFilter::Instance().GetCriticalCallbacks().size() != 0)
{
FvDebugFilter::CriticalCallbacks::const_iterator it =
FvDebugFilter::Instance().GetCriticalCallbacks().begin();
FvDebugFilter::CriticalCallbacks::const_iterator end =
FvDebugFilter::Instance().GetCriticalCallbacks().end();
for (; it!=end; ++it)
{
(*it)->HandleCritical( acBuffer );
}
}
#ifdef _XBOX360
{
OutputDebugString( acBuffer );
LPCWSTR buttons[] = { L"Exit" };
XOVERLAPPED overlapped;
MESSAGEBOX_RESULT result;
ZeroMemory( &overlapped, sizeof( XOVERLAPPED ) );
TCHAR tcbuffer[ FV_DEBUG_BUFSIZ * 2 ];
WCHAR wcbuffer[ FV_DEBUG_BUFSIZ * 2 ];
vsnprintf( tcbuffer, sizeof(tcbuffer), pcFormat, kArgPtr );
tcbuffer[sizeof(tcbuffer)-1] = '\0';
MultiByteToWideChar( CP_UTF8, 0, tcbuffer, -1, wcbuffer, ARRAYSIZE(wcbuffer) );
DWORD dwRet = XShowMessageBoxUI( 0,
L"Critical Error",
wcbuffer,
ARRAYSIZE(buttons),
buttons,
0,
XMB_ERRORICON,
&result,
&overlapped );
while( !XHasOverlappedIoCompleted( &overlapped ) )
{
extern IDirect3DDevice9 * g_pd3dDevice;
g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, D3DCOLOR_XRGB(0,0,0), 1.0f, 0L );
g_pd3dDevice->Present( 0, 0, NULL, 0 );
}
for( int i=0; i<60; i++ )
{
extern IDirect3DDevice9 * g_pd3dDevice;
g_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, D3DCOLOR_XRGB(0,0,0), 1.0f, 0L );
g_pd3dDevice->Present( 0, 0, NULL, 0 );
}
XLaunchNewImage( "", 0 );
}
#elif defined ( PLAYSTATION3 )
printf( acBuffer );
printf( "\n" );
FV_ENTER_DEBUGGER();
#elif defined(_WIN32)
#if FV_ENABLE_ENTER_DEBUGGER_MESSAGE
strcat_s( acBuffer,FV_DEBUG_BUFSIZ * 2, "\nDo you want to enter debugger?\nSelect no will exit the program.\n" );
_set_abort_behavior( 0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT );
if( FvCriticalErrorHandler::Get() )
{
switch( FvCriticalErrorHandler::Get()->Ask( acBuffer ) )
{
case FvCriticalErrorHandler::ENTERDEBUGGER:
FvCriticalErrorHandler::Get()->RecordInfo( false );
FV_ENTER_DEBUGGER();
break;
case FvCriticalErrorHandler::EXITDIRECTLY:
FvCriticalErrorHandler::Get()->RecordInfo( true );
abort();
break;
}
}
else
abort();
#else // FV_ENABLE_ENTER_DEBUGGER_MESSAGE
::MessageBox( 0, acBuffer, "Critical Error Occured", MB_ICONHAND | MB_OK );
abort();
#endif// FV_ENABLE_ENTER_DEBUGGER_MESSAGE
#else // defined(_WIN32)
char filename[512], hostname[256];
if (gethostname( hostname, sizeof(hostname) ) != 0)
hostname[0] = 0;
char exeName[512];
const char * pExeName = "unknown";
int len = readlink( "/proc/self/exe", exeName, sizeof(exeName) - 1 );
if (len > 0)
{
exeName[ len ] = '\0';
char * pTemp = strrchr( exeName, '/' );
if (pTemp != NULL)
{
pExeName = pTemp + 1;
}
}
FvSNPrintf( filename, sizeof(filename), "assert.%s.%s.%d.log", pExeName, hostname, getpid() );
FILE * assertFile = fopen( filename, "a" );
fprintf( assertFile, "%s", acBuffer );
fclose( assertFile );
*(int*)NULL = 0;
typedef void(*BogusFunc)();
((BogusFunc)NULL)();
#endif // defined(_WIN32)
}
void ReBoot()
{
LD_LAUNCH_DASHBOARD LaunchData = { XLD_LAUNCH_DASHBOARD_MAIN_MENU };
XLaunchNewImage( NULL, (LAUNCH_DATA*)&LaunchData );
}
