static void emscripten_mainloop(void)
{
if (rarch_main_iterate() != -1)
return;
main_exit(NULL);
exit(0);
}
int main(int argc, char *argv[])
{
get_environment_settings();
rarch_main_clear_state();
config_set_defaults();
char full_path[1024];
snprintf(full_path, sizeof(full_path), "game:\\CORE.xex");
bool find_libretro_file = rarch_configure_libretro_core(full_path, "game:\\", "game:\\",
SYS_CONFIG_FILE, ".xex");
set_default_settings();
rarch_config_load(SYS_CONFIG_FILE, "game:\\", ".xex", find_libretro_file);
init_libretro_sym();
video_xdk360.start();
input_xdk360.init();
rarch_input_set_default_keybind_names_for_emulator();
menu_init();
begin_loop:
if(g_console.mode_switch == MODE_EMULATION)
{
bool repeat = false;
input_xdk360.poll(NULL);
rarch_set_auto_viewport(g_extern.frame_cache.width, g_extern.frame_cache.height);
do{
repeat = rarch_main_iterate();
}while(repeat && !g_console.frame_advance_enable);
}
else if(g_console.mode_switch == MODE_MENU)
{
menu_loop();
rarch_startup(SYS_CONFIG_FILE);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
if(path_file_exists(SYS_CONFIG_FILE))
rarch_config_save(SYS_CONFIG_FILE);
menu_free();
video_xdk360.stop();
input_xdk360.free(NULL);
rarch_exec();
return 0;
}
static void emscripten_mainloop(void)
{
int ret = rarch_main_iterate();
rarch_main_data_iterate();
if (ret != -1)
return;
main_exit(NULL);
exit(0);
}
int main(void)
{
#ifdef HW_RVL
L2Enhance();
#endif
fatInitDefault();
#ifdef HAVE_FILE_LOGGER
g_extern.verbose = true;
log_fp = fopen("/retroarch-log.txt", "w");
#endif
config_set_defaults();
g_settings.audio.rate_control = true;
g_settings.audio.rate_control_delta = 0.004;
g_console.block_config_read = true;
wii_video_init();
input_wii.init();
rgui_handle_t *rgui = rgui_init("",
menu_framebuf, RGUI_WIDTH * sizeof(uint16_t),
_binary_console_font_bmp_start, folder_cb, NULL);
rgui_iterate(rgui, RGUI_ACTION_REFRESH);
int ret = 0;
while (get_rom_path(rgui) && ret == 0)
{
bool repeat = false;
input_wii.poll(NULL);
do{
repeat = rarch_main_iterate();
}while(repeat && !g_console.frame_advance_enable);
audio_stop_func();
}
if(g_console.emulator_initialized)
rarch_main_deinit();
wii_video_deinit();
input_wii.free(NULL);
#ifdef HAVE_FILE_LOGGER
fclose(log_fp);
#endif
rgui_free(rgui);
return ret;
}
static void emscripten_mainloop(void)
{
unsigned sleep_ms = 0;
int ret = rarch_main_iterate(&sleep_ms);
if (ret == 1 && sleep_ms > 0)
rarch_sleep(sleep_ms);
rarch_main_data_iterate();
if (ret != -1)
return;
main_exit(NULL);
exit(0);
}
int main(void)
{
fatInitDefault();
#ifdef HAVE_FILE_LOGGER
g_extern.verbose = true;
log_fp = fopen("sd:/ssnes-log.txt", "w");
#endif
wii_video_init();
wii_input_init();
sgui_handle_t *sgui = sgui_init("sd:/",
menu_framebuf, SGUI_WIDTH * sizeof(uint16_t),
_binary_console_font_bmp_start, folder_cb, NULL);
const char *rom_path;
int ret = 0;
while ((rom_path = get_rom_path(sgui)) && ret == 0)
{
g_console.initialize_rarch_enable = true;
strlcpy(g_console.rom_path, rom_path, sizeof(g_console.rom_path));
rarch_startup(NULL);
bool repeat = false;
input_wii.poll(NULL);
do{
repeat = rarch_main_iterate();
}while(repeat && !g_console.frame_advance_enable);
}
if(g_console.emulator_initialized)
rarch_main_deinit();
wii_input_deinit();
wii_video_deinit();
#ifdef HAVE_FILE_LOGGER
fclose(log_fp);
#endif
sgui_free(sgui);
return ret;
}
static void android_app_entry(void *data)
{
char *argv[1];
int argc = 0;
int ret = 0;
if (rarch_main(argc, argv, data) != 0)
goto end;
#ifndef HAVE_MAIN
do
{
ret = rarch_main_iterate();
rarch_main_data_iterate();
}while (ret != -1);
main_exit(data);
#endif
end:
exit(0);
}
int main(int argc, char *argv[])
{
#ifdef HAVE_SYSUTILS
RARCH_LOG("Registering system utility callback...\n");
cellSysutilRegisterCallback(0, callback_sysutil_exit, NULL);
#endif
#ifdef HAVE_SYSMODULES
cellSysmoduleLoadModule(CELL_SYSMODULE_IO);
cellSysmoduleLoadModule(CELL_SYSMODULE_FS);
cellSysmoduleLoadModule(CELL_SYSMODULE_SYSUTIL_GAME);
cellSysmoduleLoadModule(CELL_SYSMODULE_AVCONF_EXT);
cellSysmoduleLoadModule(CELL_SYSMODULE_PNGDEC);
cellSysmoduleLoadModule(CELL_SYSMODULE_JPGDEC);
cellSysmoduleLoadModule(CELL_SYSMODULE_NET);
cellSysmoduleLoadModule(CELL_SYSMODULE_SYSUTIL_NP);
#endif
sys_net_initialize_network();
#ifdef HAVE_LOGGER
logger_init();
#endif
sceNpInit(NP_POOL_SIZE, np_pool);
rarch_main_clear_state();
get_environment_settings(argc, argv);
config_set_defaults();
input_ps3.init();
char tmp_path[PATH_MAX];
snprintf(tmp_path, sizeof(tmp_path), "%s/", default_paths.core_dir);
rarch_configure_libretro(&input_ps3, tmp_path, default_paths.executable_extension);
#if(CELL_SDK_VERSION > 0x340000)
if (g_console.screenshots_enable)
{
#ifdef HAVE_SYSMODULES
cellSysmoduleLoadModule(CELL_SYSMODULE_SYSUTIL_SCREENSHOT);
#endif
#ifdef HAVE_SYSUTILS
CellScreenShotSetParam screenshot_param = {0, 0, 0, 0};
screenshot_param.photo_title = "RetroArch PS3";
screenshot_param.game_title = "RetroArch PS3";
cellScreenShotSetParameter (&screenshot_param);
cellScreenShotEnable();
#endif
}
#ifdef HAVE_SYSUTILS
if (g_console.custom_bgm_enable)
cellSysutilEnableBgmPlayback();
#endif
#endif
video_gl.start();
#ifdef HAVE_OSKUTIL
oskutil_init(&g_console.oskutil_handle, 0);
#endif
rarch_input_set_default_keybind_names_for_emulator();
menu_init();
switch(g_console.external_launcher_support)
{
case EXTERN_LAUNCHER_SALAMANDER:
g_console.mode_switch = MODE_MENU;
break;
#ifdef HAVE_MULTIMAN
case EXTERN_LAUNCHER_MULTIMAN:
RARCH_LOG("Started from multiMAN, will auto-start game.\n");
strlcpy(g_console.rom_path, argv[1], sizeof(g_console.rom_path));
rarch_settings_change(S_START_RARCH);
rarch_startup(default_paths.config_file);
break;
#endif
default:
break;
}
begin_loop:
if(g_console.mode_switch == MODE_EMULATION)
{
bool repeat = false;
input_ps3.poll(NULL);
rarch_set_auto_viewport(g_extern.frame_cache.width, g_extern.frame_cache.height);
do{
repeat = rarch_main_iterate();
}while(repeat && !g_console.frame_advance_enable);
}
else if(g_console.mode_switch == MODE_MENU)
{
menu_loop();
rarch_startup(default_paths.config_file);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
if(path_file_exists(default_paths.config_file))
rarch_config_save(default_paths.config_file);
if(g_console.emulator_initialized)
rarch_main_deinit();
input_ps3.free(NULL);
video_gl.stop();
menu_free();
#ifdef HAVE_OSKUTIL
if(g_console.oskutil_handle.is_running)
oskutil_unload(&g_console.oskutil_handle);
#endif
#ifdef HAVE_LOGGER
logger_shutdown();
#endif
#ifdef HAVE_SYSMODULES
if(g_console.screenshots_enable)
cellSysmoduleUnloadModule(CELL_SYSMODULE_SYSUTIL_SCREENSHOT);
cellSysmoduleUnloadModule(CELL_SYSMODULE_JPGDEC);
cellSysmoduleUnloadModule(CELL_SYSMODULE_PNGDEC);
cellSysmoduleUnloadModule(CELL_SYSMODULE_AVCONF_EXT);
cellSysmoduleUnloadModule(CELL_SYSMODULE_SYSUTIL_GAME);
#endif
#ifdef HAVE_HDD_CACHE_PARTITION
int ret = cellSysCacheClear();
if(ret != CELL_SYSCACHE_RET_OK_CLEARED)
{
RARCH_ERR("System cache partition could not be cleared on exit.\n");
}
#endif
rarch_exec();
return 1;
}
static void do_iteration(void)
{
int ret = rarch_main_iterate();
if (ret == -1)
{
main_exit(NULL);
return;
}
CFRunLoopWakeUp(CFRunLoopGetMain());
/* TODO/FIXME
I am almost positive that this is not necessary and is actually a
bad thing.
1st. Why it is bad thing.
This wakes up the main event loop immediately and the main loop
has only one observer, which is this function. In other words,
this causes the function to be called immediately. I did an
experiment where I saved the time before calling this and then
reported the difference between it and the start of
do_iteration, and as expected it was about 0. As a result, when
we remove this, idle performance (i.e. displaying the RetroArch
menu) is 0% CPU as desired.
2nd. Why it is not necessary.
The event loop will wake up itself when there is input to the
process. This includes touch events, keyboard, bluetooth,
etc. Thus, it will be woken up and without any intervention so
that we can process that event.
Nota bene. Why this analysis might be wrong (and what to do about it).
If RA is not idle and is running a core, then I believe it is
designed to expect to be called in a busy loop like this because
it implements its own frame timer to ensure that the emulation
simulation isn't too fast. In that case, this change would only
allow emulation to run when there was input, which would make
all games turn-based. :)
There are two good ways to fix this and still have the desired
0% CPU idle behavior.
Approach 1: Change main_entry_decide from returning a boolean
(two-values) that are interpreted as CONTINUE and QUIT. Into
returning a char-sized enum with three values that are
interpreted as QUIT, WAIT, and AGAIN, such that QUIT calls
main_exit, WAIT doesn't wake up the loop, and AGAIN does. It
would then return AGAIN when a core was active. An ugly way to
get the same effect is to look have this code just look at
g_extern.is_menu and use the WAIT behavior in that case.
Approach 2: Instead of signalling outside of RA whether a core
is running, instead externalize the frame time that is inside
retroarch. change main_entry_decide to return a value in
[-1,MAX_INT] where -1 is interpreted as QUIT, [0,MAX_INT) is
interpreted as the amount of time to wait until continuing, and
MAX_INT is interpreted as WAIT. This could be more robust
because we'd be exposing the scheduling behavior of RA to iOS,
which might be good in other platforms as well.
Approach 1 is the simplest and essentially just pushes down
these requirements to rarch_main_iterate. I have gone with the
"ugly way" first because it is the most expedient and
safe. Other eyeballs should decide if it isn't necessary.
*/
}
int rarch_main(int argc, char *argv[])
{
//Initialize bps
#ifndef HAVE_BB10
bps_initialize();
rarch_main_clear_state();
strlcpy(g_settings.libretro, "app/native/lib", sizeof(g_settings.libretro));
#endif
strlcpy(g_extern.config_path, "app/native/retroarch.cfg", sizeof(g_extern.config_path));
strlcpy(g_settings.video.shader_dir, "app/native/shaders_glsl", sizeof(g_settings.video.shader_dir));
config_load();
g_extern.verbose = true;
menu_init();
g_extern.lifecycle_mode_state |= (1ULL << MODE_LOAD_GAME);
#ifdef HAVE_BB10
if (!g_extern.libretro_dummy)
menu_rom_history_push_current();
#endif
for (;;)
{
if (g_extern.system.shutdown)
break;
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME))
{
load_menu_game_prepare();
// If ROM load fails, we exit RetroArch. On console it might make more sense to go back to menu though ...
if (load_menu_game())
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
else
{
#if defined(RARCH_CONSOLE) || defined(__BLACKBERRY_QNX__)
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
#else
return 1;
#endif
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_LOAD_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
while ((g_extern.is_paused && !g_extern.is_oneshot) ? rarch_main_idle_iterate() : rarch_main_iterate());
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= 1ULL << MODE_MENU_PREINIT;
while (!g_extern.system.shutdown && menu_iterate());
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
break;
}
g_extern.system.shutdown = false;
menu_free();
if (g_extern.config_save_on_exit && *g_extern.config_path)
config_save_file(g_extern.config_path);
if (g_extern.main_is_init)
rarch_main_deinit();
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
error:
bps_shutdown();
return 0;
}
int main(int argc, char *argv[])
{
rarch_main_clear_state();
get_environment_settings();
config_set_defaults();
input_xinput.init();
#ifdef _XBOX1
char path_prefix[256];
snprintf(path_prefix, sizeof(path_prefix), "D:\\");
#else
const char *path_prefix = default_paths.filesystem_root_dir;
#endif
const char *extension = default_paths.executable_extension;
const input_driver_t *input = &input_xinput;
char full_path[1024];
snprintf(full_path, sizeof(full_path), "%sCORE%s", path_prefix, extension);
bool find_libretro_file = rarch_configure_libretro_core(full_path, path_prefix, path_prefix,
default_paths.config_file, extension);
rarch_settings_set_default();
rarch_input_set_controls_default(input);
rarch_config_load(default_paths.config_file, find_libretro_file);
init_libretro_sym();
input_xinput.post_init();
#if defined(HAVE_D3D9) || defined(HAVE_D3D8)
video_xdk_d3d.start();
driver.video = &video_xdk_d3d;
#else
video_null.start();
driver.video = &video_null;
#endif
system_init();
menu_init();
begin_loop:
if(g_extern.console.rmenu.mode == MODE_EMULATION)
{
bool repeat = false;
input_xinput.poll(NULL);
driver.video->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
do{
repeat = rarch_main_iterate();
}while(repeat && !g_extern.console.screen.state.frame_advance.enable);
}
else if(g_extern.console.rmenu.mode == MODE_MENU)
{
menu_loop();
if (g_extern.console.rmenu.mode != MODE_EXIT)
rarch_startup(default_paths.config_file);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
rarch_config_save(default_paths.config_file);
menu_free();
#if defined(HAVE_D3D8) || defined(HAVE_D3D9)
video_xdk_d3d.stop();
#else
video_null.stop();
#endif
input_xinput.free(NULL);
if(g_extern.console.external_launch.enable)
rarch_console_exec(g_extern.console.external_launch.launch_app);
return 0;
}
void* rarch_main_ios(void* args)
{
struct rarch_main_wrap* argdata = (struct rarch_main_wrap*)args;
int init_ret = rarch_main_init_wrap(argdata);
ios_free_main_wrap(argdata);
if (init_ret)
{
rarch_main_clear_state();
dispatch_async_f(dispatch_get_main_queue(), (void*)1, ios_rarch_exited);
return 0;
}
#ifdef HAVE_RGUI
char* system_directory = ios_get_rarch_system_directory();
strlcpy(g_extern.savestate_dir, system_directory,
sizeof(g_extern.savestate_dir));
strlcpy(g_extern.savefile_dir, system_directory,
sizeof(g_extern.savefile_dir));
menu_init();
g_extern.lifecycle_mode_state |= 1ULL << MODE_GAME;
// If we started a ROM directly from command line,
// push it to ROM history.
if (!g_extern.libretro_dummy)
menu_rom_history_push_current();
for (;;)
{
if (g_extern.system.shutdown)
break;
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME))
{
load_menu_game_prepare();
// If ROM load fails, we exit RetroArch. On console it might make more sense to go back to menu though ...
if (load_menu_game())
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
else
{
#ifdef RARCH_CONSOLE
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
#else
// This needs to be here to tell the GUI thread that the emulator loop has stopped,
// the (void*)1 makes it display the 'Failed to load game' message.
dispatch_async_f(dispatch_get_main_queue(), (void*)1, ios_rarch_exited);
return 1;
#endif
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_LOAD_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
while ((g_extern.is_paused && !g_extern.is_oneshot) ? rarch_main_idle_iterate() : rarch_main_iterate())
process_events();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= 1ULL << MODE_MENU_PREINIT;
while (!g_extern.system.shutdown && menu_iterate())
process_events();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
break;
}
g_extern.system.shutdown = false;
menu_free();
if (g_extern.config_save_on_exit && *g_extern.config_path)
config_save_file(g_extern.config_path);
if (g_extern.main_is_init)
rarch_main_deinit();
free(system_directory);
#else
while ((g_extern.is_paused && !g_extern.is_oneshot) ? rarch_main_idle_iterate() : rarch_main_iterate());
rarch_main_deinit();
#endif
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
rarch_main_clear_state();
dispatch_async_f(dispatch_get_main_queue(), 0, ios_rarch_exited);
return 0;
}
static void *android_app_entry(void *data)
{
struct android_app* android_app = (struct android_app*)data;
android_app->config = AConfiguration_new();
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
print_cur_config(android_app);
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL, NULL);
android_app->looper = looper;
pthread_mutex_lock(&android_app->mutex);
android_app->running = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
memset(&g_android, 0, sizeof(g_android));
g_android = android_app;
RARCH_LOG("Native Activity started.\n");
rarch_main_clear_state();
while (!android_app->window)
{
if (!android_run_events(android_app))
goto exit;
}
rarch_init_msg_queue();
if (!android_app_start_main(android_app))
{
g_settings.input.overlay[0] = 0;
// threaded video doesn't work right for just displaying one frame
g_settings.video.threaded = false;
init_drivers();
driver.video_poke->set_aspect_ratio(driver.video_data, ASPECT_RATIO_SQUARE);
rarch_render_cached_frame();
sleep(2);
goto exit;
}
if (!g_extern.libretro_dummy)
menu_rom_history_push_current();
for (;;)
{
if (g_extern.system.shutdown)
break;
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME))
{
load_menu_game_prepare();
// If ROM load fails, we exit RetroArch. On console it might make more sense to go back to menu though ...
if (load_menu_game())
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
else
{
#ifdef RARCH_CONSOLE
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
#else
return NULL;
#endif
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_LOAD_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
driver.input->poll(NULL);
if (driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_start_func();
// Main loop
while (rarch_main_iterate());
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_stop_func();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if(g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_PREINIT);
while((input_key_pressed_func(RARCH_PAUSE_TOGGLE)) ?
android_run_events(android_app) : menu_iterate());
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
break;
}
exit:
android_app->activityState = APP_CMD_DEAD;
RARCH_LOG("Deinitializing RetroArch...\n");
menu_free();
if (g_extern.config_save_on_exit && *g_extern.config_path)
config_save_file(g_extern.config_path);
if (g_extern.main_is_init)
rarch_main_deinit();
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
rarch_main_clear_state();
RARCH_LOG("android_app_destroy!");
if (android_app->inputQueue != NULL)
AInputQueue_detachLooper(android_app->inputQueue);
AConfiguration_delete(android_app->config);
// exit() here is nasty.
// pthread_exit(NULL) or return NULL; causes hanging ...
// Should probably called ANativeActivity_finsih(), but it's bugged, it will hang our app.
exit(0);
}
int main(int argc, char *argv[])
{
get_environment_settings();
rarch_main_clear_state();
config_set_defaults();
#ifdef _XBOX1
configure_libretro("D:\\", ".xbe");
#else
configure_libretro("game:\\", ".xex");
#endif
#if defined(HAVE_D3D8) || defined(HAVE_D3D9)
video_xdk_d3d.start();
#else
video_null.start();
#endif
input_xinput.init();
rarch_input_set_default_keybind_names_for_emulator();
menu_init();
begin_loop:
if(g_console.mode_switch == MODE_EMULATION)
{
bool repeat = false;
input_xinput.poll(NULL);
rarch_set_auto_viewport(g_extern.frame_cache.width, g_extern.frame_cache.height);
do {
repeat = rarch_main_iterate();
} while(repeat && !g_console.frame_advance_enable);
}
else if(g_console.mode_switch == MODE_MENU)
{
menu_loop();
rarch_startup(SYS_CONFIG_FILE);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
if(path_file_exists(SYS_CONFIG_FILE))
rarch_config_save(SYS_CONFIG_FILE);
menu_free();
#if defined(HAVE_D3D8) || defined(HAVE_D3D9)
video_xdk_d3d.stop();
#else
video_null.stop();
#endif
input_xinput.free(NULL);
rarch_exec();
return 0;
}
int rarch_main(int argc, char *argv[])
{
//Initialize bps
bps_initialize();
RARCH_LOG("Initializing screen context\n");
// Create a screen context that will be used to create an EGL surface to receive libscreen events
screen_create_context(&screen_ctx, 0);
if (screen_request_events(screen_ctx) != BPS_SUCCESS)
{
RARCH_ERR("screen_request_events failed.\n");
goto error;
}
if (navigator_request_events(0) != BPS_SUCCESS)
{
RARCH_ERR("navigator_request_events failed.\n");
goto error;
}
if (navigator_rotation_lock(false) != BPS_SUCCESS)
{
RARCH_ERR("navigator_location_lock failed.\n");
goto error;
}
rarch_main_clear_state();
g_extern.verbose = true;
int init_ret;
struct rarch_main_wrap args = {0};
args.verbose = g_extern.verbose;
args.sram_path = NULL;
args.state_path = NULL;
args.rom_path = "/accounts/1000/shared/documents/roms/quake/pak0.pak";
args.libretro_path = "/accounts/1000/appdata/com.RetroArch.testDev_m_RetroArch181dafc7/app/native/lib/test.so";
args.config_path = "/accounts/1000/appdata/com.RetroArch.testDev_m_RetroArch181dafc7/app/native/retroarch.cfg";
if ((init_ret = rarch_main_init_wrap(&args)))
{
return init_ret;
}
rarch_init_msg_queue();
while ((g_extern.is_paused && !g_extern.is_oneshot) ? rarch_main_idle_iterate() : rarch_main_iterate());
rarch_main_deinit();
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
error:
screen_stop_events(screen_ctx);
bps_shutdown();
return 0;
}
#define return_var(var) return var
#define declare_argc()
#define declare_argv()
#define args_initial_ptr() NULL
#endif
#if !defined(__APPLE__) && !defined(EMSCRIPTEN)
#define HAVE_MAIN_LOOP
#endif
#define MAX_ARGS 32
int main_entry_decide(signature(), args_type() args)
{
int ret = rarch_main_iterate();
if (ret == -1)
{
if (g_extern.core_shutdown_initiated
&& g_settings.load_dummy_on_core_shutdown)
{
/* Load dummy core instead of exiting RetroArch completely. */
rarch_main_command(RARCH_CMD_PREPARE_DUMMY);
g_extern.core_shutdown_initiated = false;
return 0;
}
}
if (driver.frontend_ctx && driver.frontend_ctx->process_events)
driver.frontend_ctx->process_events(args);
/**
* main_entry:
*
* Main function of RetroArch.
*
* If HAVE_MAIN is not defined, will contain main loop and will not
* be exited from until we exit the program. Otherwise, will
* just do initialization.
*
* Returns: varies per platform.
**/
int rarch_main(int argc, char *argv[], void *data)
{
void *args = (void*)data;
int ret = 0;
settings_t *settings = NULL;
driver_t *driver = NULL;
rarch_main_alloc();
driver = driver_get_ptr();
if (driver)
driver->frontend_ctx = (frontend_ctx_driver_t*)frontend_ctx_init_first();
if (!driver || !driver->frontend_ctx)
RARCH_WARN("Frontend context could not be initialized.\n");
if (driver->frontend_ctx && driver->frontend_ctx->init)
driver->frontend_ctx->init(args);
rarch_main_new();
if (driver->frontend_ctx)
{
if (!(ret = (main_load_content(argc, argv, args,
driver->frontend_ctx->environment_get,
driver->frontend_ctx->process_args))))
return ret;
}
event_command(EVENT_CMD_HISTORY_INIT);
settings = config_get_ptr();
if (settings->history_list_enable)
{
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (global->content_is_init || system->no_content)
history_playlist_push(
g_defaults.history,
global->fullpath,
settings->libretro,
system ? &system->info : NULL);
}
if (driver)
driver->ui_companion = (ui_companion_driver_t*)ui_companion_init_first();
if (driver->ui_companion && driver->ui_companion->toggle)
{
if (settings->ui.companion_start_on_boot)
driver->ui_companion->toggle(driver->ui_companion_data);
}
#ifndef HAVE_MAIN
do{
ret = rarch_main_iterate();
rarch_main_data_iterate();
}while(ret != -1);
main_exit(args);
#endif
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HW_RVL
IOS_ReloadIOS(IOS_GetVersion());
L2Enhance();
gx_init_mem2();
#endif
fatInitDefault();
#ifdef HAVE_LOGGER
g_extern.verbose = true;
logger_init();
devoptab_list[STD_OUT] = &dotab_stdout;
devoptab_list[STD_ERR] = &dotab_stdout;
dotab_stdout.write_r = gx_logger_net;
#elif defined(HAVE_FILE_LOGGER)
g_extern.verbose = true;
log_fp = fopen("/retroarch-log.txt", "w");
devoptab_list[STD_OUT] = &dotab_stdout;
devoptab_list[STD_ERR] = &dotab_stdout;
dotab_stdout.write_r = gx_logger_file;
#endif
#ifdef HW_RVL
lwp_t gx_device_thread;
gx_devices[GX_DEVICE_SD].interface = &__io_wiisd;
gx_devices[GX_DEVICE_SD].name = "sd";
gx_devices[GX_DEVICE_SD].mounted = fatMountSimple(gx_devices[GX_DEVICE_SD].name, gx_devices[GX_DEVICE_SD].interface);
gx_devices[GX_DEVICE_USB].interface = &__io_usbstorage;
gx_devices[GX_DEVICE_USB].name = "usb";
gx_devices[GX_DEVICE_USB].mounted = fatMountSimple(gx_devices[GX_DEVICE_USB].name, gx_devices[GX_DEVICE_USB].interface);
LWP_MutexInit(&gx_device_mutex, false);
LWP_CreateThread(&gx_device_thread, gx_devthread, NULL, NULL, 0, 66);
#endif
get_environment_settings();
make_directories();
config_set_defaults();
input_gx.init();
video_gx.start();
driver.video = &video_gx;
gx_video_t *gx = (gx_video_t*)driver.video_data;
gx->menu_data = (uint32_t *) menu_framebuf;
char tmp_path[PATH_MAX];
const char *extension = default_paths.executable_extension;
snprintf(tmp_path, sizeof(tmp_path), "%s/", default_paths.core_dir);
const char *path_prefix = tmp_path;
char full_path[1024];
snprintf(full_path, sizeof(full_path), "%sCORE%s", path_prefix, extension);
bool find_libretro_file = rarch_configure_libretro_core(full_path, path_prefix, path_prefix,
default_paths.config_file, extension);
rarch_settings_set_default(&input_gx);
rarch_config_load(default_paths.config_file, path_prefix, extension, find_libretro_file);
char core_name[64];
rarch_console_name_from_id(core_name, sizeof(core_name));
char input_path[1024];
snprintf(input_path, sizeof(input_path), "%s/%s.cfg", default_paths.input_presets_dir, core_name);
config_read_keybinds(input_path);
init_libretro_sym();
input_gx.post_init();
menu_init();
if (argc > 2 && argv[1] != NULL && argv[2] != NULL)
{
char rom[PATH_MAX];
g_console.external_launcher_support = EXTERN_LAUNCHER_CHANNEL;
snprintf(rom, sizeof(rom), "%s%s", argv[1], argv[2]);
g_console.zip_extract_mode = ZIP_EXTRACT_TO_CURRENT_DIR_AND_LOAD_FIRST_FILE;
rarch_console_load_game_wrap(rom, g_console.zip_extract_mode, S_DELAY_1);
rgui_iterate(rgui, RGUI_ACTION_MESSAGE);
gx->menu_render = true;
rarch_render_cached_frame();
gx->menu_render = false;
rarch_startup(default_paths.config_file);
}
else
{
g_console.external_launcher_support = EXTERN_LAUNCHER_SALAMANDER;
}
begin_loop:
if(g_console.mode_switch == MODE_EMULATION)
{
bool repeat = false;
input_gx.poll(NULL);
video_set_aspect_ratio_func(g_console.aspect_ratio_index);
audio_start_func();
do{
repeat = rarch_main_iterate();
}while(repeat && !g_console.frame_advance_enable);
audio_stop_func();
}
else if(g_console.mode_switch == MODE_MENU)
{
menu_loop();
if (g_console.mode_switch != MODE_EXIT)
rarch_startup(default_paths.config_file);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
rarch_config_save(default_paths.config_file);
config_save_keybinds(input_path);
if(g_console.emulator_initialized)
rarch_main_deinit();
input_gx.free(NULL);
video_gx.stop();
menu_free();
#ifdef HAVE_LOGGER
logger_shutdown();
#elif defined(HAVE_FILE_LOGGER)
fclose(log_fp);
#endif
if(g_console.return_to_launcher)
rarch_console_exec(g_console.launch_app_on_exit);
exit(0);
}
int main(int argc, char *argv[])
#endif
{
frontend_ctx = (frontend_ctx_driver_t*)frontend_ctx_init_first();
if (frontend_ctx && frontend_ctx->init)
frontend_ctx->init();
rarch_main_clear_state();
#ifndef __APPLE__
rarch_get_environment(argc, argv);
#endif
#if !defined(RARCH_CONSOLE)
#if defined(__APPLE__)
struct rarch_main_wrap* argdata = (struct rarch_main_wrap*)args;
int init_ret = rarch_main_init_wrap(argdata);
apple_free_main_wrap(argdata);
if (init_ret)
{
rarch_main_clear_state();
dispatch_async_f(dispatch_get_main_queue(), (void*)1, apple_rarch_exited);
return 0;
}
#else
rarch_init_msg_queue();
int init_ret;
if ((init_ret = rarch_main_init(argc, argv))) return init_ret;
#endif
#endif
#ifdef HAVE_MENU
menu_init();
#ifndef __APPLE__
if (frontend_ctx && frontend_ctx->process_args)
frontend_ctx->process_args(argc, argv);
#endif
#ifdef RARCH_CONSOLE
g_extern.lifecycle_mode_state |= 1ULL << MODE_LOAD_GAME;
#else
g_extern.lifecycle_mode_state |= 1ULL << MODE_GAME;
#endif
#ifndef RARCH_CONSOLE
// If we started a ROM directly from command line,
// push it to ROM history.
if (!g_extern.libretro_dummy)
menu_rom_history_push_current();
#endif
for (;;)
{
if (g_extern.system.shutdown)
break;
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME))
{
load_menu_game_prepare();
// If ROM load fails, we exit RetroArch. On console it might make more sense to go back to menu though ...
if (load_menu_game())
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
else
{
#if defined(RARCH_CONSOLE) || defined(__QNX__)
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
#else
if (frontend_ctx && frontend_ctx->shutdown)
frontend_ctx->shutdown(true);
return 1;
#endif
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_LOAD_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
#ifdef RARCH_CONSOLE
driver.input->poll(NULL);
#endif
if (driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
while ((g_extern.is_paused && !g_extern.is_oneshot) ? rarch_main_idle_iterate() : rarch_main_iterate())
{
if (frontend_ctx && frontend_ctx->process_events)
frontend_ctx->process_events();
if (!(g_extern.lifecycle_mode_state & (1ULL << MODE_GAME)))
break;
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= 1ULL << MODE_MENU_PREINIT;
// Menu should always run with vsync on.
video_set_nonblock_state_func(false);
if (driver.audio_data)
audio_stop_func();
while (!g_extern.system.shutdown && menu_iterate())
{
if (frontend_ctx && frontend_ctx->process_events)
frontend_ctx->process_events();
if (!(g_extern.lifecycle_mode_state & (1ULL << MODE_MENU)))
break;
}
driver_set_nonblock_state(driver.nonblock_state);
if (driver.audio_data && !audio_start_func())
{
RARCH_ERR("Failed to resume audio driver. Will continue without audio.\n");
g_extern.audio_active = false;
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
break;
}
g_extern.system.shutdown = false;
menu_free();
if (g_extern.config_save_on_exit && *g_extern.config_path)
config_save_file(g_extern.config_path);
#ifdef GEKKO
/* Per-core input config saving */
config_save_keybinds(g_extern.input_config_path);
#endif
#ifdef RARCH_CONSOLE
global_uninit_drivers();
#endif
#else
while ((g_extern.is_paused && !g_extern.is_oneshot) ? rarch_main_idle_iterate() : rarch_main_iterate());
#endif
rarch_main_deinit();
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
#if defined(HAVE_LOGGER)
logger_shutdown();
#elif defined(HAVE_FILE_LOGGER)
if (g_extern.log_file)
fclose(g_extern.log_file);
g_extern.log_file = NULL;
#endif
if (frontend_ctx && frontend_ctx->deinit)
frontend_ctx->deinit();
if (g_extern.lifecycle_mode_state & (1ULL << MODE_EXITSPAWN) && frontend_ctx
&& frontend_ctx->exitspawn)
frontend_ctx->exitspawn();
rarch_main_clear_state();
if (frontend_ctx && frontend_ctx->shutdown)
frontend_ctx->shutdown(false);
return 0;
}
int rarch_main(int argc, char *argv[])
{
system_init();
rarch_main_clear_state();
verbose_log_init();
get_environment_settings(argc, argv);
config_load();
init_libretro_sym();
rarch_init_system_info();
global_init_drivers();
#ifdef HAVE_LIBRETRO_MANAGEMENT
char core_exe_path[PATH_MAX];
char path_prefix[PATH_MAX];
const char *extension = DEFAULT_EXE_EXT;
char slash;
#if defined(_WIN32)
slash = '\\';
#else
slash = '/';
#endif
snprintf(path_prefix, sizeof(path_prefix), "%s%c", default_paths.core_dir, slash);
snprintf(core_exe_path, sizeof(core_exe_path), "%sCORE%s", path_prefix, extension);
if (path_file_exists(core_exe_path))
{
RARCH_LOG("core_exe_path: %s\n", core_exe_path);
if (install_libretro_core(core_exe_path, path_prefix, extension))
{
RARCH_LOG("New default libretro core saved to config file: %s.\n", g_settings.libretro);
config_save_file(g_extern.config_path);
}
}
#endif
init_libretro_sym();
system_post_init();
menu_init();
system_process_args(argc, argv);
begin_loop:
if(g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
driver.input->poll(NULL);
if (driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_start_func();
while(rarch_main_iterate());
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_stop_func();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_INIT))
{
if(g_extern.main_is_init)
rarch_main_deinit();
struct rarch_main_wrap args = {0};
args.verbose = g_extern.verbose;
args.sram_path = (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME_SRAM_DIR_ENABLE)) ? g_extern.console.main_wrap.default_sram_dir : NULL;
args.state_path = (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME_STATE_DIR_ENABLE)) ? g_extern.console.main_wrap.default_savestate_dir : NULL;
args.rom_path = g_extern.fullpath;
args.libretro_path = g_settings.libretro;
if (path_file_exists(g_extern.config_path))
args.config_path = g_extern.config_path;
else
args.config_path = NULL;
if (rarch_main_init_wrap(&args) == 0)
{
RARCH_LOG("rarch_main_init succeeded.\n");
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
}
else
{
RARCH_ERR("rarch_main_init failed.\n");
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
menu_settings_msg(S_MSG_ROM_LOADING_ERROR, 180);
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_INIT);
}
else if(g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_PREINIT);
while (menu_iterate());
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
goto begin_shutdown;
goto begin_loop;
begin_shutdown:
config_save_file(g_extern.config_path);
system_deinit_save();
if(g_extern.main_is_init)
rarch_main_deinit();
menu_free();
global_uninit_drivers();
#ifdef PERF_TEST
rarch_perf_log();
#endif
system_deinit();
if (g_extern.lifecycle_mode_state & (1ULL << MODE_EXITSPAWN))
system_exitspawn();
return 1;
}