bool core_info_init_list(void)
{
core_info_curr_list = core_info_list_new();
if (!core_info_curr_list)
return false;
return true;
}
static void lakka_init_core_info(void *data)
{
(void)data;
core_info_list_free(g_extern.core_info);
g_extern.core_info = NULL;
if (*g_settings.libretro_directory)
g_extern.core_info = core_info_list_new(g_settings.libretro_directory);
}
static void rmenu_xui_init_core_info(void *data)
{
menu_handle_t *menu = (menu_handle_t*)data;
core_info_list_free(menu->core_info);
menu->core_info = NULL;
if (*g_settings.libretro_directory)
menu->core_info = core_info_list_new(g_settings.libretro_directory);
}
static void rmenu_init_core_info(void *data)
{
rgui_handle_t *rgui = (rgui_handle_t*)data;
core_info_list_free(rgui->core_info);
rgui->core_info = NULL;
if (*g_settings.libretro_directory)
rgui->core_info = core_info_list_new(g_settings.libretro_directory);
}
bool core_info_init_list(const char *path_info, const char *dir_cores,
const char *exts, bool dir_show_hidden_files)
{
if (!(core_info_curr_list = core_info_list_new(dir_cores,
!string_is_empty(path_info) ? path_info : dir_cores,
exts,
dir_show_hidden_files)))
return false;
return true;
}
bool core_info_init_list(void)
{
settings_t *settings = config_get_ptr();
if (settings)
core_info_curr_list = core_info_list_new(settings->paths.directory_libretro);
if (!core_info_curr_list)
return false;
return true;
}
static void update_libretro_info(struct retro_system_info *info)
{
#ifndef HAVE_DYNAMIC
retro_get_system_info(info);
#endif
core_info_list_free(g_extern.core_info);
g_extern.core_info = NULL;
if (*g_settings.libretro_directory)
g_extern.core_info = core_info_list_new(g_settings.libretro_directory);
rarch_update_system_info(info, NULL);
}
static void menu_update_libretro_info(menu_handle_t *menu)
{
#ifndef HAVE_DYNAMIC
retro_get_system_info(&menu->info);
#endif
core_info_list_free(menu->core_info);
menu->core_info = NULL;
if (*g_settings.libretro_directory)
menu->core_info = core_info_list_new(g_settings.libretro_directory);
menu_update_system_info(menu, NULL);
}
static void lakka_init_core_info(void *data)
{
core_info_list_t *core;
rgui_handle_t *rgui = (rgui_handle_t*)data;
core_info_list_free(rgui->core_info);
rgui->core_info = NULL;
rgui->core_info = (core_info_list_t*)core_info_list_new(*g_settings.libretro_directory ? g_settings.libretro_directory : "/usr/lib/libretro");
if (rgui->core_info)
{
core = (core_info_list_t*)rgui->core_info;
num_categories = rgui->core_info ? core->count + 1 : 1;
}
}
static void lakka_init_core_info(void *data)
{
core_info_list_t *core;
menu_handle_t *menu = (menu_handle_t*)data;
core_info_list_free(menu->core_info);
menu->core_info = NULL;
menu->core_info = (core_info_list_t*)core_info_list_new(*g_settings.libretro_directory ? g_settings.libretro_directory : "/usr/lib/libretro");
if (menu->core_info)
{
core = (core_info_list_t*)menu->core_info;
num_categories = menu->core_info ? core->count + 1 : 1;
}
}
static void menu_update_libretro_info(void *data)
{
rgui_handle_t *rgui = (rgui_handle_t*)data;
if (!rgui)
return;
#ifndef HAVE_DYNAMIC
retro_get_system_info(&rgui->info);
#endif
memset(&rgui->core_info_current, 0, sizeof(rgui->core_info_current));
core_info_list_free(rgui->core_info);
rgui->core_info = NULL;
if (*g_settings.libretro_directory)
rgui->core_info = core_info_list_new(g_settings.libretro_directory);
menu_update_system_info(rgui, NULL);
}
bool runloop_ctl(enum runloop_ctl_state state, void *data)
{
static rarch_dir_list_t runloop_shader_dir;
static char runloop_fullpath[PATH_MAX_LENGTH];
static rarch_system_info_t runloop_system;
static unsigned runloop_pending_windowed_scale;
static retro_keyboard_event_t runloop_key_event = NULL;
static unsigned runloop_max_frames = false;
static bool runloop_frame_time_last = false;
static bool runloop_set_frame_limit = false;
static bool runloop_paused = false;
static bool runloop_idle = false;
static bool runloop_exec = false;
static bool runloop_slowmotion = false;
static bool runloop_shutdown_initiated = false;
static bool runloop_core_shutdown_initiated = false;
static bool runloop_perfcnt_enable = false;
static bool runloop_overrides_active = false;
static bool runloop_game_options_active = false;
#ifdef HAVE_THREADS
static slock_t *runloop_msg_queue_lock = NULL;
#endif
static core_info_t *core_info_current = NULL;
static core_info_list_t *core_info_curr_list = NULL;
settings_t *settings = config_get_ptr();
switch (state)
{
case RUNLOOP_CTL_DATA_ITERATE:
rarch_task_check();
return true;
case RUNLOOP_CTL_SHADER_DIR_DEINIT:
shader_dir_free(&runloop_shader_dir);
return true;
case RUNLOOP_CTL_SHADER_DIR_INIT:
return shader_dir_init(&runloop_shader_dir);
case RUNLOOP_CTL_SYSTEM_INFO_INIT:
core.retro_get_system_info(&runloop_system.info);
if (!runloop_system.info.library_name)
runloop_system.info.library_name = msg_hash_to_str(MSG_UNKNOWN);
if (!runloop_system.info.library_version)
runloop_system.info.library_version = "v0";
#ifndef RARCH_CONSOLE
strlcpy(runloop_system.title_buf,
msg_hash_to_str(MSG_PROGRAM), sizeof(runloop_system.title_buf));
strlcat(runloop_system.title_buf, " : ", sizeof(runloop_system.title_buf));
#endif
strlcat(runloop_system.title_buf, runloop_system.info.library_name, sizeof(runloop_system.title_buf));
strlcat(runloop_system.title_buf, " ", sizeof(runloop_system.title_buf));
strlcat(runloop_system.title_buf, runloop_system.info.library_version, sizeof(runloop_system.title_buf));
strlcpy(runloop_system.valid_extensions, runloop_system.info.valid_extensions ?
runloop_system.info.valid_extensions : DEFAULT_EXT,
sizeof(runloop_system.valid_extensions));
runloop_system.block_extract = runloop_system.info.block_extract;
break;
case RUNLOOP_CTL_GET_CORE_OPTION_SIZE:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
*idx = core_option_size(runloop_system.core_options);
}
return true;
case RUNLOOP_CTL_HAS_CORE_OPTIONS:
return runloop_system.core_options;
case RUNLOOP_CTL_CURRENT_CORE_LIST_FREE:
if (core_info_curr_list)
core_info_list_free(core_info_curr_list);
core_info_curr_list = NULL;
return true;
case RUNLOOP_CTL_CURRENT_CORE_LIST_INIT:
core_info_curr_list = core_info_list_new();
return true;
case RUNLOOP_CTL_CURRENT_CORE_LIST_GET:
{
core_info_list_t **core = (core_info_list_t**)data;
if (!core)
return false;
*core = core_info_curr_list;
}
return true;
case RUNLOOP_CTL_CURRENT_CORE_FREE:
if (core_info_current)
free(core_info_current);
core_info_current = NULL;
return true;
case RUNLOOP_CTL_CURRENT_CORE_INIT:
core_info_current = (core_info_t*)calloc(1, sizeof(core_info_t));
if (!core_info_current)
return false;
return true;
case RUNLOOP_CTL_CURRENT_CORE_GET:
{
core_info_t **core = (core_info_t**)data;
if (!core)
return false;
*core = core_info_current;
}
return true;
case RUNLOOP_CTL_SYSTEM_INFO_GET:
{
rarch_system_info_t **system = (rarch_system_info_t**)data;
if (!system)
return false;
*system = &runloop_system;
}
return true;
case RUNLOOP_CTL_SYSTEM_INFO_FREE:
if (runloop_system.core_options)
{
core_option_flush(runloop_system.core_options);
core_option_free(runloop_system.core_options);
}
runloop_system.core_options = NULL;
/* No longer valid. */
if (runloop_system.special)
free(runloop_system.special);
runloop_system.special = NULL;
if (runloop_system.ports)
free(runloop_system.ports);
runloop_system.ports = NULL;
runloop_key_event = NULL;
global_get_ptr()->frontend_key_event = NULL;
audio_driver_unset_callback();
memset(&runloop_system, 0, sizeof(rarch_system_info_t));
break;
case RUNLOOP_CTL_IS_FRAME_COUNT_END:
{
uint64_t *frame_count = NULL;
video_driver_ctl(RARCH_DISPLAY_CTL_GET_FRAME_COUNT, &frame_count);
return runloop_max_frames && (*frame_count >= runloop_max_frames);
}
case RUNLOOP_CTL_SET_FRAME_TIME_LAST:
runloop_frame_time_last = true;
break;
case RUNLOOP_CTL_UNSET_FRAME_TIME_LAST:
runloop_frame_time_last = false;
break;
case RUNLOOP_CTL_SET_OVERRIDES_ACTIVE:
runloop_overrides_active = true;
break;
case RUNLOOP_CTL_UNSET_OVERRIDES_ACTIVE:
runloop_overrides_active = false;
break;
case RUNLOOP_CTL_IS_OVERRIDES_ACTIVE:
return runloop_overrides_active;
case RUNLOOP_CTL_SET_GAME_OPTIONS_ACTIVE:
runloop_game_options_active = true;
break;
case RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE:
runloop_game_options_active = false;
break;
case RUNLOOP_CTL_IS_GAME_OPTIONS_ACTIVE:
return runloop_game_options_active;
case RUNLOOP_CTL_IS_FRAME_TIME_LAST:
return runloop_frame_time_last;
case RUNLOOP_CTL_SET_FRAME_LIMIT:
runloop_set_frame_limit = true;
break;
case RUNLOOP_CTL_UNSET_FRAME_LIMIT:
runloop_set_frame_limit = false;
break;
case RUNLOOP_CTL_SHOULD_SET_FRAME_LIMIT:
return runloop_set_frame_limit;
case RUNLOOP_CTL_GET_PERFCNT:
{
bool **perfcnt = (bool**)data;
if (!perfcnt)
return false;
*perfcnt = &runloop_perfcnt_enable;
}
return true;
case RUNLOOP_CTL_SET_PERFCNT_ENABLE:
runloop_perfcnt_enable = true;
break;
case RUNLOOP_CTL_UNSET_PERFCNT_ENABLE:
runloop_perfcnt_enable = false;
break;
case RUNLOOP_CTL_IS_PERFCNT_ENABLE:
return runloop_perfcnt_enable;
case RUNLOOP_CTL_GET_WINDOWED_SCALE:
{
unsigned **scale = (unsigned**)data;
if (!scale)
return false;
*scale = (unsigned*)&runloop_pending_windowed_scale;
}
break;
case RUNLOOP_CTL_SET_WINDOWED_SCALE:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
runloop_pending_windowed_scale = *idx;
}
break;
case RUNLOOP_CTL_SET_LIBRETRO_PATH:
{
const char *fullpath = (const char*)data;
if (!fullpath)
return false;
strlcpy(settings->libretro, fullpath, sizeof(settings->libretro));
}
break;
case RUNLOOP_CTL_CLEAR_CONTENT_PATH:
*runloop_fullpath = '\0';
break;
case RUNLOOP_CTL_GET_CONTENT_PATH:
{
char **fullpath = (char**)data;
if (!fullpath)
return false;
*fullpath = (char*)runloop_fullpath;
}
break;
case RUNLOOP_CTL_SET_CONTENT_PATH:
{
const char *fullpath = (const char*)data;
if (!fullpath)
return false;
strlcpy(runloop_fullpath, fullpath, sizeof(runloop_fullpath));
}
break;
case RUNLOOP_CTL_CHECK_FOCUS:
if (settings->pause_nonactive)
return video_driver_ctl(RARCH_DISPLAY_CTL_IS_FOCUSED, NULL);
return true;
case RUNLOOP_CTL_CHECK_IDLE_STATE:
{
event_cmd_state_t *cmd = (event_cmd_state_t*)data;
bool focused = runloop_ctl(RUNLOOP_CTL_CHECK_FOCUS, NULL);
check_pause(settings, focused,
runloop_cmd_triggered(cmd, RARCH_PAUSE_TOGGLE),
runloop_cmd_triggered(cmd, RARCH_FRAMEADVANCE));
if (!runloop_ctl(RUNLOOP_CTL_CHECK_PAUSE_STATE, cmd) || !focused)
return false;
break;
}
case RUNLOOP_CTL_CHECK_STATE:
{
bool tmp = false;
event_cmd_state_t *cmd = (event_cmd_state_t*)data;
if (!cmd || runloop_idle)
return false;
if (runloop_cmd_triggered(cmd, RARCH_SCREENSHOT))
event_command(EVENT_CMD_TAKE_SCREENSHOT);
if (runloop_cmd_triggered(cmd, RARCH_MUTE))
event_command(EVENT_CMD_AUDIO_MUTE_TOGGLE);
if (runloop_cmd_triggered(cmd, RARCH_OSK))
{
if (input_driver_ctl(RARCH_INPUT_CTL_IS_KEYBOARD_LINEFEED_ENABLED, NULL))
input_driver_ctl(RARCH_INPUT_CTL_UNSET_KEYBOARD_LINEFEED_ENABLED, NULL);
else
input_driver_ctl(RARCH_INPUT_CTL_SET_KEYBOARD_LINEFEED_ENABLED, NULL);
}
if (runloop_cmd_press(cmd, RARCH_VOLUME_UP))
event_command(EVENT_CMD_VOLUME_UP);
else if (runloop_cmd_press(cmd, RARCH_VOLUME_DOWN))
event_command(EVENT_CMD_VOLUME_DOWN);
#ifdef HAVE_NETPLAY
tmp = runloop_cmd_triggered(cmd, RARCH_NETPLAY_FLIP);
netplay_driver_ctl(RARCH_NETPLAY_CTL_FLIP_PLAYERS, &tmp);
tmp = runloop_cmd_triggered(cmd, RARCH_FULLSCREEN_TOGGLE_KEY);
netplay_driver_ctl(RARCH_NETPLAY_CTL_FULLSCREEN_TOGGLE, &tmp);
#endif
if (!runloop_ctl(RUNLOOP_CTL_CHECK_IDLE_STATE, data))
return false;
check_fast_forward_button(
runloop_cmd_triggered(cmd, RARCH_FAST_FORWARD_KEY),
runloop_cmd_press (cmd, RARCH_FAST_FORWARD_HOLD_KEY),
runloop_cmd_pressed (cmd, RARCH_FAST_FORWARD_HOLD_KEY));
check_stateslots(settings,
runloop_cmd_triggered(cmd, RARCH_STATE_SLOT_PLUS),
runloop_cmd_triggered(cmd, RARCH_STATE_SLOT_MINUS)
);
if (runloop_cmd_triggered(cmd, RARCH_SAVE_STATE_KEY))
event_command(EVENT_CMD_SAVE_STATE);
else if (runloop_cmd_triggered(cmd, RARCH_LOAD_STATE_KEY))
event_command(EVENT_CMD_LOAD_STATE);
state_manager_check_rewind(runloop_cmd_press(cmd, RARCH_REWIND));
tmp = runloop_cmd_press(cmd, RARCH_SLOWMOTION);
runloop_ctl(RUNLOOP_CTL_CHECK_SLOWMOTION, &tmp);
if (runloop_cmd_triggered(cmd, RARCH_MOVIE_RECORD_TOGGLE))
runloop_ctl(RUNLOOP_CTL_CHECK_MOVIE, NULL);
check_shader_dir(&runloop_shader_dir,
runloop_cmd_triggered(cmd, RARCH_SHADER_NEXT),
runloop_cmd_triggered(cmd, RARCH_SHADER_PREV));
if (runloop_cmd_triggered(cmd, RARCH_DISK_EJECT_TOGGLE))
event_command(EVENT_CMD_DISK_EJECT_TOGGLE);
else if (runloop_cmd_triggered(cmd, RARCH_DISK_NEXT))
event_command(EVENT_CMD_DISK_NEXT);
else if (runloop_cmd_triggered(cmd, RARCH_DISK_PREV))
event_command(EVENT_CMD_DISK_PREV);
if (runloop_cmd_triggered(cmd, RARCH_RESET))
event_command(EVENT_CMD_RESET);
cheat_manager_state_checks(
runloop_cmd_triggered(cmd, RARCH_CHEAT_INDEX_PLUS),
runloop_cmd_triggered(cmd, RARCH_CHEAT_INDEX_MINUS),
runloop_cmd_triggered(cmd, RARCH_CHEAT_TOGGLE));
}
break;
case RUNLOOP_CTL_CHECK_PAUSE_STATE:
{
bool check_is_oneshot;
event_cmd_state_t *cmd = (event_cmd_state_t*)data;
if (!cmd)
return false;
check_is_oneshot = runloop_cmd_triggered(cmd, RARCH_FRAMEADVANCE)
|| runloop_cmd_press(cmd, RARCH_REWIND);
if (!runloop_paused)
return true;
if (runloop_cmd_triggered(cmd, RARCH_FULLSCREEN_TOGGLE_KEY))
{
event_command(EVENT_CMD_FULLSCREEN_TOGGLE);
video_driver_ctl(RARCH_DISPLAY_CTL_CACHED_FRAME_RENDER, NULL);
}
if (!check_is_oneshot)
return false;
}
break;
case RUNLOOP_CTL_CHECK_SLOWMOTION:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
runloop_slowmotion = *ptr;
if (!runloop_slowmotion)
return false;
if (settings->video.black_frame_insertion)
video_driver_ctl(RARCH_DISPLAY_CTL_CACHED_FRAME_RENDER, NULL);
if (state_manager_frame_is_reversed())
runloop_msg_queue_push_new(MSG_SLOW_MOTION_REWIND, 0, 30, true);
else
runloop_msg_queue_push_new(MSG_SLOW_MOTION, 0, 30, true);
}
break;
case RUNLOOP_CTL_CHECK_MOVIE:
if (bsv_movie_ctl(BSV_MOVIE_CTL_PLAYBACK_ON, NULL))
return runloop_ctl(RUNLOOP_CTL_CHECK_MOVIE_PLAYBACK, NULL);
if (!bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
return runloop_ctl(RUNLOOP_CTL_CHECK_MOVIE_INIT, NULL);
return runloop_ctl(RUNLOOP_CTL_CHECK_MOVIE_RECORD, NULL);
case RUNLOOP_CTL_CHECK_MOVIE_RECORD:
if (!bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
return false;
runloop_msg_queue_push_new(
MSG_MOVIE_RECORD_STOPPED, 2, 180, true);
RARCH_LOG("%s\n", msg_hash_to_str(MSG_MOVIE_RECORD_STOPPED));
event_command(EVENT_CMD_BSV_MOVIE_DEINIT);
break;
case RUNLOOP_CTL_CHECK_MOVIE_INIT:
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
return false;
{
char msg[128];
char path[PATH_MAX_LENGTH];
settings->rewind_granularity = 1;
if (settings->state_slot > 0)
snprintf(path, sizeof(path), "%s%d",
bsv_movie_get_path(), settings->state_slot);
else
strlcpy(path, bsv_movie_get_path(), sizeof(path));
strlcat(path, ".bsv", sizeof(path));
snprintf(msg, sizeof(msg), "%s \"%s\".",
msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO),
path);
bsv_movie_init_handle(path, RARCH_MOVIE_RECORD);
if (!bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
return false;
else if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
{
runloop_msg_queue_push(msg, 1, 180, true);
RARCH_LOG("%s \"%s\".\n",
msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO),
path);
}
else
{
runloop_msg_queue_push_new(
MSG_FAILED_TO_START_MOVIE_RECORD,
1, 180, true);
RARCH_ERR("%s\n", msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD));
}
}
break;
case RUNLOOP_CTL_CHECK_MOVIE_PLAYBACK:
if (!bsv_movie_ctl(BSV_MOVIE_CTL_END, NULL))
return false;
runloop_msg_queue_push_new(
MSG_MOVIE_PLAYBACK_ENDED, 1, 180, false);
RARCH_LOG("%s\n", msg_hash_to_str(MSG_MOVIE_PLAYBACK_ENDED));
event_command(EVENT_CMD_BSV_MOVIE_DEINIT);
bsv_movie_ctl(BSV_MOVIE_CTL_UNSET_END, NULL);
bsv_movie_ctl(BSV_MOVIE_CTL_UNSET_PLAYBACK, NULL);
break;
case RUNLOOP_CTL_STATE_FREE:
runloop_perfcnt_enable = false;
runloop_idle = false;
runloop_paused = false;
runloop_slowmotion = false;
runloop_frame_time_last = false;
runloop_set_frame_limit = false;
runloop_overrides_active = false;
runloop_max_frames = 0;
break;
case RUNLOOP_CTL_GLOBAL_FREE:
{
global_t *global;
event_command(EVENT_CMD_TEMPORARY_CONTENT_DEINIT);
event_command(EVENT_CMD_SUBSYSTEM_FULLPATHS_DEINIT);
event_command(EVENT_CMD_RECORD_DEINIT);
event_command(EVENT_CMD_LOG_FILE_DEINIT);
rarch_ctl(RARCH_CTL_UNSET_BLOCK_CONFIG_READ, NULL);
runloop_ctl(RUNLOOP_CTL_CLEAR_CONTENT_PATH, NULL);
runloop_overrides_active = false;
global = global_get_ptr();
memset(global, 0, sizeof(struct global));
}
break;
case RUNLOOP_CTL_CLEAR_STATE:
driver_ctl(RARCH_DRIVER_CTL_DEINIT, NULL);
runloop_ctl(RUNLOOP_CTL_STATE_FREE, NULL);
runloop_ctl(RUNLOOP_CTL_GLOBAL_FREE, NULL);
break;
case RUNLOOP_CTL_SET_MAX_FRAMES:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
runloop_max_frames = *ptr;
}
break;
case RUNLOOP_CTL_IS_IDLE:
return runloop_idle;
case RUNLOOP_CTL_SET_IDLE:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
runloop_idle = *ptr;
}
break;
case RUNLOOP_CTL_IS_SLOWMOTION:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
*ptr = runloop_slowmotion;
}
break;
case RUNLOOP_CTL_SET_SLOWMOTION:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
runloop_slowmotion = *ptr;
}
break;
case RUNLOOP_CTL_SET_PAUSED:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
runloop_paused = *ptr;
}
break;
case RUNLOOP_CTL_IS_PAUSED:
return runloop_paused;
case RUNLOOP_CTL_MSG_QUEUE_FREE:
#ifdef HAVE_THREADS
slock_free(runloop_msg_queue_lock);
runloop_msg_queue_lock = NULL;
#endif
break;
case RUNLOOP_CTL_MSG_QUEUE_DEINIT:
if (!g_msg_queue)
return true;
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_LOCK, NULL);
msg_queue_free(g_msg_queue);
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_UNLOCK, NULL);
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_FREE, NULL);
g_msg_queue = NULL;
break;
case RUNLOOP_CTL_MSG_QUEUE_INIT:
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_DEINIT, NULL);
g_msg_queue = msg_queue_new(8);
retro_assert(g_msg_queue);
#ifdef HAVE_THREADS
runloop_msg_queue_lock = slock_new();
retro_assert(runloop_msg_queue_lock);
#endif
break;
case RUNLOOP_CTL_MSG_QUEUE_LOCK:
#ifdef HAVE_THREADS
slock_lock(runloop_msg_queue_lock);
#endif
break;
case RUNLOOP_CTL_MSG_QUEUE_UNLOCK:
#ifdef HAVE_THREADS
slock_unlock(runloop_msg_queue_lock);
#endif
break;
case RUNLOOP_CTL_PREPARE_DUMMY:
#ifdef HAVE_MENU
menu_driver_ctl(RARCH_MENU_CTL_UNSET_LOAD_NO_CONTENT, NULL);
#endif
runloop_data_clear_state();
runloop_ctl(RUNLOOP_CTL_CLEAR_CONTENT_PATH, NULL);
rarch_ctl(RARCH_CTL_LOAD_CONTENT, NULL);
break;
case RUNLOOP_CTL_SET_CORE_SHUTDOWN:
runloop_core_shutdown_initiated = true;
break;
case RUNLOOP_CTL_UNSET_CORE_SHUTDOWN:
runloop_core_shutdown_initiated = false;
break;
case RUNLOOP_CTL_IS_CORE_SHUTDOWN:
return runloop_core_shutdown_initiated;
case RUNLOOP_CTL_SET_SHUTDOWN:
runloop_shutdown_initiated = true;
break;
case RUNLOOP_CTL_UNSET_SHUTDOWN:
runloop_shutdown_initiated = false;
break;
case RUNLOOP_CTL_IS_SHUTDOWN:
return runloop_shutdown_initiated;
case RUNLOOP_CTL_SET_EXEC:
runloop_exec = true;
break;
case RUNLOOP_CTL_UNSET_EXEC:
runloop_exec = false;
break;
case RUNLOOP_CTL_IS_EXEC:
return runloop_exec;
case RUNLOOP_CTL_DATA_DEINIT:
rarch_task_deinit();
break;
case RUNLOOP_CTL_IS_CORE_OPTION_UPDATED:
return runloop_system.core_options ?
core_option_updated(runloop_system.core_options) : false;
case RUNLOOP_CTL_CORE_OPTION_PREV:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
core_option_prev(runloop_system.core_options, *idx);
if (ui_companion_is_on_foreground())
ui_companion_driver_notify_refresh();
}
return true;
case RUNLOOP_CTL_CORE_OPTION_NEXT:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
core_option_next(runloop_system.core_options, *idx);
if (ui_companion_is_on_foreground())
ui_companion_driver_notify_refresh();
}
return true;
case RUNLOOP_CTL_CORE_OPTIONS_GET:
{
struct retro_variable *var = (struct retro_variable*)data;
if (!runloop_system.core_options || !var)
return false;
RARCH_LOG("Environ GET_VARIABLE %s:\n", var->key);
core_option_get(runloop_system.core_options, var);
RARCH_LOG("\t%s\n", var->value ? var->value : "N/A");
}
return true;
case RUNLOOP_CTL_CORE_OPTIONS_INIT:
{
char *game_options_path = NULL;
bool ret = false;
const struct retro_variable *vars = (const struct retro_variable*)data;
char buf[PATH_MAX_LENGTH] = {0};
global_t *global = global_get_ptr();
const char *options_path = settings->core_options_path;
if (!*options_path && *global->path.config)
{
fill_pathname_resolve_relative(buf, global->path.config,
"retroarch-core-options.cfg", sizeof(buf));
options_path = buf;
}
if (settings->game_specific_options)
ret = rarch_game_specific_options(&game_options_path);
if(ret)
{
runloop_ctl(RUNLOOP_CTL_SET_GAME_OPTIONS_ACTIVE, NULL);
runloop_system.core_options = core_option_new(game_options_path, vars);
free(game_options_path);
}
else
{
runloop_ctl(RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE, NULL);
runloop_system.core_options = core_option_new(options_path, vars);
}
}
break;
case RUNLOOP_CTL_CORE_OPTIONS_DEINIT:
if (!runloop_system.core_options)
return false;
core_option_flush(runloop_system.core_options);
core_option_free(runloop_system.core_options);
runloop_system.core_options = NULL;
return true;
case RUNLOOP_CTL_KEY_EVENT_GET:
{
retro_keyboard_event_t **key_event = (retro_keyboard_event_t**)data;
if (!key_event)
return false;
*key_event = &runloop_key_event;
}
break;
case RUNLOOP_CTL_NONE:
default:
return false;
}
return true;
}
/**
* event_command:
* @cmd : Event command index.
*
* Performs RetroArch event command with index @cmd.
*
* Returns: true (1) on success, otherwise false (0).
**/
bool event_command(enum event_command cmd)
{
unsigned i = 0;
bool boolean = false;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)i;
switch (cmd)
{
case EVENT_CMD_LOAD_CONTENT_PERSIST:
#ifdef HAVE_DYNAMIC
event_command(EVENT_CMD_LOAD_CORE);
#endif
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
break;
#ifdef HAVE_FFMPEG
case EVENT_CMD_LOAD_CONTENT_FFMPEG:
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT_FFMPEG);
break;
#endif
case EVENT_CMD_LOAD_CONTENT_IMAGEVIEWER:
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT_IMAGEVIEWER);
break;
case EVENT_CMD_LOAD_CONTENT:
#ifdef HAVE_DYNAMIC
event_command(EVENT_CMD_LOAD_CONTENT_PERSIST);
#else
rarch_environment_cb(RETRO_ENVIRONMENT_SET_LIBRETRO_PATH,
(void*)settings->libretro);
rarch_environment_cb(RETRO_ENVIRONMENT_EXEC,
(void*)global->fullpath);
event_command(EVENT_CMD_QUIT);
#endif
break;
case EVENT_CMD_LOAD_CORE_DEINIT:
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&global->menu.info);
#endif
break;
case EVENT_CMD_LOAD_CORE_PERSIST:
event_command(EVENT_CMD_LOAD_CORE_DEINIT);
{
#ifdef HAVE_MENU
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
event_update_system_info(&global->menu.info,
&menu->load_no_content);
#endif
}
break;
case EVENT_CMD_LOAD_CORE:
event_command(EVENT_CMD_LOAD_CORE_PERSIST);
#ifndef HAVE_DYNAMIC
event_command(EVENT_CMD_QUIT);
#endif
break;
case EVENT_CMD_LOAD_STATE:
/* Immutable - disallow savestate load when
* we absolutely cannot change game state. */
if (global->bsv.movie)
return false;
#ifdef HAVE_NETPLAY
if (driver->netplay_data)
return false;
#endif
event_main_state(cmd);
break;
case EVENT_CMD_RESIZE_WINDOWED_SCALE:
if (global->pending.windowed_scale == 0)
return false;
settings->video.scale = global->pending.windowed_scale;
if (!settings->video.fullscreen)
event_command(EVENT_CMD_REINIT);
global->pending.windowed_scale = 0;
break;
case EVENT_CMD_MENU_TOGGLE:
if (menu_driver_alive())
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
else
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING);
break;
case EVENT_CMD_CONTROLLERS_INIT:
event_init_controllers();
break;
case EVENT_CMD_RESET:
RARCH_LOG(RETRO_LOG_RESETTING_CONTENT);
rarch_main_msg_queue_push("Reset.", 1, 120, true);
pretro_reset();
/* bSNES since v073r01 resets controllers to JOYPAD
* after a reset, so just enforce it here. */
event_command(EVENT_CMD_CONTROLLERS_INIT);
break;
case EVENT_CMD_SAVE_STATE:
if (settings->savestate_auto_index)
settings->state_slot++;
event_main_state(cmd);
break;
case EVENT_CMD_TAKE_SCREENSHOT:
if (!take_screenshot())
return false;
break;
case EVENT_CMD_PREPARE_DUMMY:
{
#ifdef HAVE_MENU
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
menu->load_no_content = false;
#endif
rarch_main_data_deinit();
*global->fullpath = '\0';
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
}
break;
case EVENT_CMD_UNLOAD_CORE:
event_command(EVENT_CMD_PREPARE_DUMMY);
event_command(EVENT_CMD_LOAD_CORE_DEINIT);
break;
case EVENT_CMD_QUIT:
rarch_main_set_state(RARCH_ACTION_STATE_QUIT);
break;
case EVENT_CMD_REINIT:
{
const struct retro_hw_render_callback *hw_render =
(const struct retro_hw_render_callback*)video_driver_callback();
driver->video_cache_context = hw_render->cache_context;
driver->video_cache_context_ack = false;
event_command(EVENT_CMD_RESET_CONTEXT);
driver->video_cache_context = false;
/* Poll input to avoid possibly stale data to corrupt things. */
input_driver_poll();
#ifdef HAVE_MENU
menu_display_fb_set_dirty();
if (menu_driver_alive())
event_command(EVENT_CMD_VIDEO_SET_BLOCKING_STATE);
#endif
}
break;
case EVENT_CMD_CHEATS_DEINIT:
if (!global)
break;
if (global->cheat)
cheat_manager_free(global->cheat);
global->cheat = NULL;
break;
case EVENT_CMD_CHEATS_INIT:
event_command(EVENT_CMD_CHEATS_DEINIT);
event_init_cheats();
break;
case EVENT_CMD_REMAPPING_DEINIT:
break;
case EVENT_CMD_REMAPPING_INIT:
event_command(EVENT_CMD_REMAPPING_DEINIT);
event_init_remapping();
break;
case EVENT_CMD_REWIND_DEINIT:
if (!global)
break;
#ifdef HAVE_NETPLAY
if (driver->netplay_data)
return false;
#endif
if (global->rewind.state)
state_manager_free(global->rewind.state);
global->rewind.state = NULL;
break;
case EVENT_CMD_REWIND_INIT:
init_rewind();
break;
case EVENT_CMD_REWIND_TOGGLE:
if (settings->rewind_enable)
event_command(EVENT_CMD_REWIND_INIT);
else
event_command(EVENT_CMD_REWIND_DEINIT);
break;
case EVENT_CMD_AUTOSAVE_DEINIT:
#ifdef HAVE_THREADS
event_deinit_autosave();
#endif
break;
case EVENT_CMD_AUTOSAVE_INIT:
event_command(EVENT_CMD_AUTOSAVE_DEINIT);
#ifdef HAVE_THREADS
event_init_autosave();
#endif
break;
case EVENT_CMD_AUTOSAVE_STATE:
event_save_auto_state();
break;
case EVENT_CMD_AUDIO_STOP:
if (!driver->audio_data)
return false;
if (!audio_driver_alive())
return false;
if (!audio_driver_stop())
return false;
break;
case EVENT_CMD_AUDIO_START:
if (!driver->audio_data || audio_driver_alive())
return false;
if (!settings->audio.mute_enable && !audio_driver_start())
{
RARCH_ERR("Failed to start audio driver. Will continue without audio.\n");
driver->audio_active = false;
}
break;
case EVENT_CMD_AUDIO_MUTE_TOGGLE:
{
const char *msg = !settings->audio.mute_enable ?
"Audio muted." : "Audio unmuted.";
if (!audio_driver_mute_toggle())
{
RARCH_ERR("Failed to unmute audio.\n");
return false;
}
rarch_main_msg_queue_push(msg, 1, 180, true);
RARCH_LOG("%s\n", msg);
}
break;
case EVENT_CMD_OVERLAY_DEINIT:
#ifdef HAVE_OVERLAY
if (driver->overlay)
input_overlay_free(driver->overlay);
driver->overlay = NULL;
memset(&driver->overlay_state, 0, sizeof(driver->overlay_state));
#endif
break;
case EVENT_CMD_OVERLAY_INIT:
event_command(EVENT_CMD_OVERLAY_DEINIT);
#ifdef HAVE_OVERLAY
if (driver->osk_enable)
{
if (!*settings->osk.overlay)
break;
}
else
{
if (!*settings->input.overlay)
break;
}
driver->overlay = input_overlay_new(driver->osk_enable ? settings->osk.overlay : settings->input.overlay,
driver->osk_enable ? settings->osk.enable : settings->input.overlay_enable,
settings->input.overlay_opacity, settings->input.overlay_scale);
if (!driver->overlay)
RARCH_ERR("Failed to load overlay.\n");
#endif
break;
case EVENT_CMD_OVERLAY_NEXT:
#ifdef HAVE_OVERLAY
input_overlay_next(driver->overlay, settings->input.overlay_opacity);
#endif
break;
case EVENT_CMD_DSP_FILTER_DEINIT:
if (!global)
break;
audio_driver_dsp_filter_free();
break;
case EVENT_CMD_DSP_FILTER_INIT:
event_command(EVENT_CMD_DSP_FILTER_DEINIT);
if (!*settings->audio.dsp_plugin)
break;
audio_driver_dsp_filter_init(settings->audio.dsp_plugin);
break;
case EVENT_CMD_GPU_RECORD_DEINIT:
if (!global)
break;
if (global->record.gpu_buffer)
free(global->record.gpu_buffer);
global->record.gpu_buffer = NULL;
break;
case EVENT_CMD_RECORD_DEINIT:
if (!recording_deinit())
return false;
break;
case EVENT_CMD_RECORD_INIT:
event_command(EVENT_CMD_HISTORY_DEINIT);
if (!recording_init())
return false;
break;
case EVENT_CMD_HISTORY_DEINIT:
if (g_defaults.history)
{
content_playlist_write_file(g_defaults.history);
content_playlist_free(g_defaults.history);
}
g_defaults.history = NULL;
break;
case EVENT_CMD_HISTORY_INIT:
event_command(EVENT_CMD_HISTORY_DEINIT);
if (!settings->history_list_enable)
return false;
RARCH_LOG("Loading history file: [%s].\n", settings->content_history_path);
g_defaults.history = content_playlist_init(
settings->content_history_path,
settings->content_history_size);
break;
case EVENT_CMD_CORE_INFO_DEINIT:
if (!global)
break;
if (global->core_info)
core_info_list_free(global->core_info);
global->core_info = NULL;
break;
case EVENT_CMD_DATA_RUNLOOP_FREE:
rarch_main_data_free();
break;
case EVENT_CMD_CORE_INFO_INIT:
event_command(EVENT_CMD_CORE_INFO_DEINIT);
if (*settings->libretro_directory)
global->core_info = core_info_list_new();
break;
case EVENT_CMD_CORE_DEINIT:
{
struct retro_hw_render_callback *cb = video_driver_callback();
event_deinit_core(true);
if (cb)
memset(cb, 0, sizeof(*cb));
break;
}
case EVENT_CMD_CORE_INIT:
if (!event_init_core())
return false;
break;
case EVENT_CMD_VIDEO_APPLY_STATE_CHANGES:
video_driver_apply_state_changes();
break;
case EVENT_CMD_VIDEO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case EVENT_CMD_VIDEO_SET_BLOCKING_STATE:
video_driver_set_nonblock_state(boolean);
break;
case EVENT_CMD_VIDEO_SET_ASPECT_RATIO:
video_driver_set_aspect_ratio(settings->video.aspect_ratio_idx);
break;
case EVENT_CMD_AUDIO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case EVENT_CMD_AUDIO_SET_BLOCKING_STATE:
audio_driver_set_nonblock_state(boolean);
break;
case EVENT_CMD_OVERLAY_SET_SCALE_FACTOR:
#ifdef HAVE_OVERLAY
input_overlay_set_scale_factor(driver->overlay,
settings->input.overlay_scale);
#endif
break;
case EVENT_CMD_OVERLAY_SET_ALPHA_MOD:
#ifdef HAVE_OVERLAY
input_overlay_set_alpha_mod(driver->overlay,
settings->input.overlay_opacity);
#endif
break;
case EVENT_CMD_DRIVERS_DEINIT:
uninit_drivers(DRIVERS_CMD_ALL);
break;
case EVENT_CMD_DRIVERS_INIT:
init_drivers(DRIVERS_CMD_ALL);
break;
case EVENT_CMD_AUDIO_REINIT:
uninit_drivers(DRIVER_AUDIO);
init_drivers(DRIVER_AUDIO);
break;
case EVENT_CMD_RESET_CONTEXT:
event_command(EVENT_CMD_DRIVERS_DEINIT);
event_command(EVENT_CMD_DRIVERS_INIT);
break;
case EVENT_CMD_QUIT_RETROARCH:
rarch_main_set_state(RARCH_ACTION_STATE_FORCE_QUIT);
break;
case EVENT_CMD_RESUME:
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
break;
case EVENT_CMD_RESTART_RETROARCH:
#if defined(GEKKO) && defined(HW_RVL)
fill_pathname_join(global->fullpath, g_defaults.core_dir,
SALAMANDER_FILE,
sizeof(global->fullpath));
#endif
if (driver->frontend_ctx && driver->frontend_ctx->set_fork)
driver->frontend_ctx->set_fork(true, false);
break;
case EVENT_CMD_MENU_SAVE_CONFIG:
if (!event_save_core_config())
return false;
break;
case EVENT_CMD_SHADERS_APPLY_CHANGES:
#ifdef HAVE_MENU
menu_shader_manager_apply_changes();
#endif
break;
case EVENT_CMD_PAUSE_CHECKS:
if (runloop->is_paused)
{
RARCH_LOG("Paused.\n");
event_command(EVENT_CMD_AUDIO_STOP);
if (settings->video.black_frame_insertion)
video_driver_cached_frame();
}
else
{
RARCH_LOG("Unpaused.\n");
event_command(EVENT_CMD_AUDIO_START);
}
break;
case EVENT_CMD_PAUSE_TOGGLE:
runloop->is_paused = !runloop->is_paused;
event_command(EVENT_CMD_PAUSE_CHECKS);
break;
case EVENT_CMD_UNPAUSE:
runloop->is_paused = false;
event_command(EVENT_CMD_PAUSE_CHECKS);
break;
case EVENT_CMD_PAUSE:
runloop->is_paused = true;
event_command(EVENT_CMD_PAUSE_CHECKS);
break;
case EVENT_CMD_MENU_PAUSE_LIBRETRO:
if (menu_driver_alive())
{
if (settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_STOP);
else
event_command(EVENT_CMD_AUDIO_START);
}
else
{
if (settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_START);
}
break;
case EVENT_CMD_SHADER_DIR_DEINIT:
if (!global)
break;
dir_list_free(global->shader_dir.list);
global->shader_dir.list = NULL;
global->shader_dir.ptr = 0;
break;
case EVENT_CMD_SHADER_DIR_INIT:
event_command(EVENT_CMD_SHADER_DIR_DEINIT);
if (!*settings->video.shader_dir)
return false;
global->shader_dir.list = dir_list_new_special(NULL, DIR_LIST_SHADERS);
if (!global->shader_dir.list || global->shader_dir.list->size == 0)
{
event_command(EVENT_CMD_SHADER_DIR_DEINIT);
return false;
}
global->shader_dir.ptr = 0;
dir_list_sort(global->shader_dir.list, false);
for (i = 0; i < global->shader_dir.list->size; i++)
RARCH_LOG("Found shader \"%s\"\n",
global->shader_dir.list->elems[i].data);
break;
case EVENT_CMD_SAVEFILES:
event_save_files();
break;
case EVENT_CMD_SAVEFILES_DEINIT:
if (!global)
break;
if (global->savefiles)
string_list_free(global->savefiles);
global->savefiles = NULL;
break;
case EVENT_CMD_SAVEFILES_INIT:
global->use_sram = global->use_sram && !global->sram_save_disable
#ifdef HAVE_NETPLAY
&& (!driver->netplay_data || !global->netplay_is_client)
#endif
;
if (!global->use_sram)
RARCH_LOG("SRAM will not be saved.\n");
if (global->use_sram)
event_command(EVENT_CMD_AUTOSAVE_INIT);
break;
case EVENT_CMD_MSG_QUEUE_DEINIT:
rarch_main_msg_queue_free();
break;
case EVENT_CMD_MSG_QUEUE_INIT:
event_command(EVENT_CMD_MSG_QUEUE_DEINIT);
rarch_main_msg_queue_init();
rarch_main_data_init_queues();
break;
case EVENT_CMD_BSV_MOVIE_DEINIT:
if (!global)
break;
if (global->bsv.movie)
bsv_movie_free(global->bsv.movie);
global->bsv.movie = NULL;
break;
case EVENT_CMD_BSV_MOVIE_INIT:
event_command(EVENT_CMD_BSV_MOVIE_DEINIT);
event_init_movie();
break;
case EVENT_CMD_NETPLAY_DEINIT:
#ifdef HAVE_NETPLAY
deinit_netplay();
#endif
break;
case EVENT_CMD_NETWORK_DEINIT:
#ifdef HAVE_NETWORKING
network_deinit();
#endif
break;
case EVENT_CMD_NETWORK_INIT:
#ifdef HAVE_NETWORKING
network_init();
#endif
break;
case EVENT_CMD_NETPLAY_INIT:
event_command(EVENT_CMD_NETPLAY_DEINIT);
#ifdef HAVE_NETPLAY
if (!init_netplay())
return false;
#endif
break;
case EVENT_CMD_NETPLAY_FLIP_PLAYERS:
#ifdef HAVE_NETPLAY
{
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay)
return false;
netplay_flip_users(netplay);
}
#endif
break;
case EVENT_CMD_FULLSCREEN_TOGGLE:
if (!video_driver_has_windowed())
return false;
/* If we go fullscreen we drop all drivers and
* reinitialize to be safe. */
settings->video.fullscreen = !settings->video.fullscreen;
event_command(EVENT_CMD_REINIT);
break;
case EVENT_CMD_COMMAND_DEINIT:
#ifdef HAVE_COMMAND
if (driver->command)
rarch_cmd_free(driver->command);
driver->command = NULL;
#endif
break;
case EVENT_CMD_COMMAND_INIT:
event_command(EVENT_CMD_COMMAND_DEINIT);
#ifdef HAVE_COMMAND
event_init_command();
#endif
break;
case EVENT_CMD_TEMPORARY_CONTENT_DEINIT:
if (!global)
break;
if (global->temporary_content)
event_free_temporary_content();
global->temporary_content = NULL;
break;
case EVENT_CMD_SUBSYSTEM_FULLPATHS_DEINIT:
if (!global)
break;
if (global->subsystem_fullpaths)
string_list_free(global->subsystem_fullpaths);
global->subsystem_fullpaths = NULL;
break;
case EVENT_CMD_LOG_FILE_DEINIT:
if (!global)
break;
if (global->log_file && global->log_file != stderr)
fclose(global->log_file);
global->log_file = NULL;
break;
case EVENT_CMD_DISK_EJECT_TOGGLE:
if (system && system->disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&system->disk_control;
if (control)
event_check_disk_eject(control);
}
else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true);
break;
case EVENT_CMD_DISK_NEXT:
if (system && system->disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&system->disk_control;
if (!control)
return false;
if (!control->get_eject_state())
return false;
event_check_disk_next(control);
}
else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true);
break;
case EVENT_CMD_DISK_PREV:
if (system && system->disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&system->disk_control;
if (!control)
return false;
if (!control->get_eject_state())
return false;
event_check_disk_prev(control);
}
else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true);
break;
case EVENT_CMD_RUMBLE_STOP:
for (i = 0; i < MAX_USERS; i++)
{
input_driver_set_rumble_state(i, RETRO_RUMBLE_STRONG, 0);
input_driver_set_rumble_state(i, RETRO_RUMBLE_WEAK, 0);
}
break;
case EVENT_CMD_GRAB_MOUSE_TOGGLE:
{
static bool grab_mouse_state = false;
grab_mouse_state = !grab_mouse_state;
if (!driver->input || !input_driver_grab_mouse(grab_mouse_state))
return false;
RARCH_LOG("Grab mouse state: %s.\n",
grab_mouse_state ? "yes" : "no");
video_driver_show_mouse(!grab_mouse_state);
}
break;
case EVENT_CMD_PERFCNT_REPORT_FRONTEND_LOG:
rarch_perf_log();
break;
case EVENT_CMD_VOLUME_UP:
event_set_volume(0.5f);
break;
case EVENT_CMD_VOLUME_DOWN:
event_set_volume(-0.5f);
break;
case EVENT_CMD_NONE:
default:
goto error;
}
return true;
error:
return false;
}
void core_info_set_core_path(void)
{
global_core_list = core_info_list_new(g_defaults.core_dir);
}
