bool load_menu_game(void)
{
if (g_extern.main_is_init)
rarch_main_deinit();
struct rarch_main_wrap args = {0};
args.verbose = g_extern.verbose;
args.config_path = *g_extern.config_path ? g_extern.config_path : NULL;
args.sram_path = *g_extern.savefile_dir ? g_extern.savefile_dir : NULL;
args.state_path = *g_extern.savestate_dir ? g_extern.savestate_dir : NULL;
args.rom_path = *g_extern.fullpath ? g_extern.fullpath : NULL;
args.libretro_path = g_settings.libretro;
args.no_rom = rgui->load_no_rom;
rgui->load_no_rom = false;
if (rarch_main_init_wrap(&args) == 0)
{
RARCH_LOG("rarch_main_init_wrap() succeeded.\n");
return true;
}
else
{
char name[PATH_MAX];
char msg[PATH_MAX];
fill_pathname_base(name, g_extern.fullpath, sizeof(name));
snprintf(msg, sizeof(msg), "Failed to load %s.\n", name);
msg_queue_push(g_extern.msg_queue, msg, 1, 90);
rgui->msg_force = true;
RARCH_ERR("rarch_main_init_wrap() failed.\n");
return false;
}
}
/**
* main_exit:
*
* Cleanly exit RetroArch.
*
* Also saves configuration files to disk,
* and (optionally) autosave state.
**/
void main_exit(void *args)
{
settings_t *settings = config_get_ptr();
event_cmd_ctl(EVENT_CMD_MENU_SAVE_CURRENT_CONFIG, NULL);
if (content_ctl(CONTENT_CTL_IS_INITED, NULL))
{
#ifdef HAVE_MENU
/* Do not want menu context to live any more. */
menu_driver_ctl(RARCH_MENU_CTL_UNSET_OWN_DRIVER, NULL);
#endif
rarch_main_deinit();
}
event_cmd_ctl(EVENT_CMD_PERFCNT_REPORT_FRONTEND_LOG, NULL);
#if defined(HAVE_LOGGER) && !defined(ANDROID)
logger_shutdown();
#endif
frontend_driver_deinit(args);
frontend_driver_exitspawn(settings->libretro,
sizeof(settings->libretro));
rarch_ctl(RARCH_CTL_DESTROY, NULL);
ui_companion_driver_deinit();
frontend_driver_shutdown(false);
driver_ctl(RARCH_DRIVER_CTL_DEINIT, NULL);
ui_companion_driver_free();
frontend_driver_free();
}
/**
* main_load_content:
* @argc : Argument count.
* @argv : Argument variable list.
* @args : Arguments passed from callee.
* @environ_get : Function passed for environment_get function.
* @process_args : Function passed for process_args function.
*
* Loads content file and starts up RetroArch.
* If no content file can be loaded, will start up RetroArch
* as-is.
*
* Returns: false (0) if rarch_main_init failed, otherwise true (1).
**/
bool main_load_content(int argc, char **argv, void *args,
environment_get_t environ_get,
process_args_t process_args)
{
unsigned i;
bool retval = true;
int ret = 0, rarch_argc = 0;
char *rarch_argv[MAX_ARGS] = {NULL};
char *argv_copy [MAX_ARGS] = {NULL};
char **rarch_argv_ptr = (char**)argv;
int *rarch_argc_ptr = (int*)&argc;
global_t *global = global_get_ptr();
struct rarch_main_wrap *wrap_args = (struct rarch_main_wrap*)
calloc(1, sizeof(*wrap_args));
if (!wrap_args)
return false;
(void)rarch_argc_ptr;
(void)rarch_argv_ptr;
(void)ret;
rarch_assert(wrap_args);
if (environ_get)
environ_get(rarch_argc_ptr, rarch_argv_ptr, args, wrap_args);
check_defaults_dirs();
if (wrap_args->touched)
{
rarch_main_init_wrap(wrap_args, &rarch_argc, rarch_argv);
memcpy(argv_copy, rarch_argv, sizeof(rarch_argv));
rarch_argv_ptr = (char**)rarch_argv;
rarch_argc_ptr = (int*)&rarch_argc;
}
if (global->main_is_init)
rarch_main_deinit();
if ((ret = rarch_main_init(*rarch_argc_ptr, rarch_argv_ptr)))
{
retval = false;
goto error;
}
event_command(EVENT_CMD_RESUME);
if (process_args)
process_args(rarch_argc_ptr, rarch_argv_ptr);
error:
for (i = 0; i < ARRAY_SIZE(argv_copy); i++)
free(argv_copy[i]);
free(wrap_args);
return retval;
}
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;
}
/**
* main_exit:
*
* Cleanly exit RetroArch.
*
* Also saves configuration files to disk,
* and (optionally) autosave state.
**/
void main_exit(void *args)
{
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
const frontend_ctx_driver_t *frontend = frontend_get_ptr();
const ui_companion_driver_t *ui = ui_companion_get_ptr();
global->system.shutdown = false;
main_exit_save_config();
if (global->main_is_init)
{
#ifdef HAVE_MENU
/* Do not want menu context to live any more. */
driver->menu_data_own = false;
#endif
rarch_main_deinit();
}
event_command(EVENT_CMD_PERFCNT_REPORT_FRONTEND_LOG);
#if defined(HAVE_LOGGER) && !defined(ANDROID)
logger_shutdown();
#endif
if (frontend)
{
if (frontend->deinit)
frontend->deinit(args);
if (frontend->exitspawn)
frontend->exitspawn(settings->libretro,
sizeof(settings->libretro));
}
rarch_main_free();
if (ui)
{
if (ui->deinit)
ui->deinit(driver->ui_companion_data);
}
if (frontend)
{
if (frontend->shutdown)
frontend->shutdown(false);
}
driver_free();
}
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;
}
bool load_menu_game(void *data)
{
struct rarch_main_wrap args = {0};
rgui_handle_t *rgui = (rgui_handle_t*)data;
if (g_extern.main_is_init)
rarch_main_deinit();
args.verbose = g_extern.verbose;
args.config_path = *g_extern.config_path ? g_extern.config_path : NULL;
args.sram_path = *g_extern.savefile_dir ? g_extern.savefile_dir : NULL;
args.state_path = *g_extern.savestate_dir ? g_extern.savestate_dir : NULL;
args.rom_path = *g_extern.fullpath ? g_extern.fullpath : NULL;
args.libretro_path = *g_settings.libretro ? g_settings.libretro : NULL;
args.no_rom = rgui->load_no_rom;
if (rgui)
rgui->load_no_rom = false;
if (rarch_main_init_wrap(&args) != 0)
{
char name[PATH_MAX], msg[PATH_MAX];
fill_pathname_base(name, g_extern.fullpath, sizeof(name));
snprintf(msg, sizeof(msg), "Failed to load %s.\n", name);
msg_queue_push(g_extern.msg_queue, msg, 1, 90);
if (rgui)
rgui->msg_force = true;
RARCH_ERR("rarch_main_init_wrap() failed.\n");
return false;
}
RARCH_LOG("rarch_main_init_wrap() succeeded.\n");
if (rgui)
{
// Update menu state which depends on config.
menu_update_libretro_info(rgui);
menu_init_history(rgui);
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->shader_manager_init)
driver.menu_ctx->backend->shader_manager_init(rgui);
}
return true;
}
bool rarch_startup (const char * config_path)
{
bool retval = false;
if(g_console.initialize_rarch_enable)
{
if(g_console.emulator_initialized)
rarch_main_deinit();
struct rarch_main_wrap args = {0};
args.verbose = g_extern.verbose;
args.config_path = config_path;
args.sram_path = g_console.default_sram_dir_enable ? g_console.default_sram_dir : NULL,
args.state_path = g_console.default_savestate_dir_enable ? g_console.default_savestate_dir : NULL,
args.rom_path = g_console.rom_path;
int init_ret = rarch_main_init_wrap(&args);
(void)init_ret;
if(init_ret == 0)
{
g_console.emulator_initialized = 1;
g_console.initialize_rarch_enable = 0;
retval = true;
}
else
{
//failed to load the ROM for whatever reason
g_console.emulator_initialized = 0;
g_console.mode_switch = MODE_MENU;
rarch_settings_msg(S_MSG_ROM_LOADING_ERROR, S_DELAY_180);
}
}
return retval;
}
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;
}
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;
}
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;
}
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[])
{
#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);
}
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 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;
}
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;
}
