static void handle_discord_join(const char* secret)
{
RARCH_LOG("[Discord] join (%s)\n", secret);
static struct string_list *list = NULL;
list = string_split(secret, "|");
char tmp_hostname[32];
snprintf(tmp_hostname,
sizeof(tmp_hostname),
"%s|%s", list->elems[0].data, list->elems[1].data);
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
deinit_netplay();
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_CLIENT, NULL);
task_push_netplay_crc_scan(atoi(list->elems[3].data),
list->elems[2].data,
tmp_hostname, list->elems[4].data);
}
static int action_select_netplay_connect_room(const char *path,
const char *label, unsigned type,
size_t idx)
{
char tmp_hostname[4115];
tmp_hostname[0] = '\0';
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
command_event(CMD_EVENT_NETPLAY_DEINIT, NULL);
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_CLIENT, NULL);
if (netplay_room_list[idx - 3].host_method == NETPLAY_HOST_METHOD_MITM)
{
snprintf(tmp_hostname,
sizeof(tmp_hostname),
"%s|%d",
netplay_room_list[idx - 3].mitm_address,
netplay_room_list[idx - 3].mitm_port);
}
else
{
snprintf(tmp_hostname,
sizeof(tmp_hostname),
"%s|%d",
netplay_room_list[idx - 3].address,
netplay_room_list[idx - 3].port);
}
#if 0
RARCH_LOG("[lobby] connecting to: %s with game: %s/%08x\n",
tmp_hostname,
netplay_room_list[idx - 3].gamename,
netplay_room_list[idx - 3].gamecrc);
#endif
task_push_netplay_crc_scan(netplay_room_list[idx - 3].gamecrc,
netplay_room_list[idx - 3].gamename,
tmp_hostname, netplay_room_list[idx - 3].corename);
return 0;
}
bool core_unserialize(retro_ctx_serialize_info_t *info)
{
if (!info || !current_core.retro_unserialize(info->data_const, info->size))
return false;
#if HAVE_NETWORKING
netplay_driver_ctl(RARCH_NETPLAY_CTL_LOAD_SAVESTATE, info);
#endif
return true;
}
static void event_init_cheats(void)
{
bool allow_cheats = true;
#ifdef HAVE_NETPLAY
allow_cheats &= !netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL);
#endif
allow_cheats &= !bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL);
if (!allow_cheats)
return;
/* TODO/FIXME - add some stuff here. */
}
bool core_run(void)
{
#ifdef HAVE_NETWORKING
if (!netplay_driver_ctl(RARCH_NETPLAY_CTL_PRE_FRAME, NULL))
{
/* Paused due to netplay. We must poll and display something so that a
* netplay peer pausing doesn't just hang. */
input_poll();
video_driver_cached_frame();
return true;
}
#endif
switch (current_core.poll_type)
{
case POLL_TYPE_EARLY:
input_poll();
break;
case POLL_TYPE_LATE:
current_core.input_polled = false;
break;
default:
break;
}
current_core.retro_run();
if (current_core.poll_type == POLL_TYPE_LATE && !current_core.input_polled)
input_poll();
#ifdef HAVE_NETWORKING
netplay_driver_ctl(RARCH_NETPLAY_CTL_POST_FRAME, NULL);
#endif
return true;
}
/**
* core_init_libretro_cbs:
* @data : pointer to retro_callbacks object
*
* Initializes libretro callbacks, and binds the libretro callbacks
* to default callback functions.
**/
static bool core_init_libretro_cbs(struct retro_callbacks *cbs)
{
current_core.retro_set_video_refresh(video_driver_frame);
current_core.retro_set_audio_sample(audio_driver_sample);
current_core.retro_set_audio_sample_batch(audio_driver_sample_batch);
current_core.retro_set_input_state(core_input_state_poll);
current_core.retro_set_input_poll(core_input_state_poll_maybe);
core_set_default_callbacks(cbs);
#ifdef HAVE_NETWORKING
if (!netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
return true;
core_set_netplay_callbacks();
#endif
return true;
}
/**
* retro_init_libretro_cbs:
* @data : pointer to retro_callbacks object
*
* Initializes libretro callbacks, and binds the libretro callbacks
* to default callback functions.
**/
static bool retro_init_libretro_cbs(void *data)
{
struct retro_callbacks *cbs = (struct retro_callbacks*)data;
#ifdef HAVE_NETPLAY
global_t *global = global_get_ptr();
#endif
if (!cbs)
return false;
core.retro_set_video_refresh(video_driver_frame);
core.retro_set_audio_sample(audio_driver_sample);
core.retro_set_audio_sample_batch(audio_driver_sample_batch);
core.retro_set_input_state(input_state_poll);
core.retro_set_input_poll(input_poll_maybe);
core_ctl(CORE_CTL_SET_CBS, cbs);
#ifdef HAVE_NETPLAY
if (!netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
return true;
/* Force normal poll type for netplay. */
core_poll_type = POLL_TYPE_NORMAL;
if (global->netplay.is_spectate)
{
core.retro_set_input_state(
(global->netplay.is_client ?
input_state_spectate_client : input_state_spectate)
);
}
else
{
core.retro_set_video_refresh(video_frame_net);
core.retro_set_audio_sample(audio_sample_net);
core.retro_set_audio_sample_batch(audio_sample_batch_net);
core.retro_set_input_state(input_state_net);
}
#endif
return true;
}
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;
}
/**
* runloop_iterate:
*
* Run Libretro core in RetroArch for one frame.
*
* Returns: 0 on success, 1 if we have to wait until button input in order
* to wake up the loop, -1 if we forcibly quit out of the RetroArch iteration loop.
**/
int runloop_iterate(unsigned *sleep_ms)
{
unsigned i;
event_cmd_state_t cmd;
event_cmd_state_t *cmd_ptr = &cmd;
retro_time_t current, target, to_sleep_ms;
static retro_usec_t frame_time_last = 0;
static retro_time_t frame_limit_minimum_time = 0.0;
static retro_time_t frame_limit_last_time = 0.0;
static retro_input_t last_input = 0;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = NULL;
cmd.state[1] = last_input;
cmd.state[0] = input_keys_pressed();
last_input = cmd.state[0];
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);
if (runloop_ctl(RUNLOOP_CTL_IS_FRAME_TIME_LAST, NULL))
{
frame_time_last = 0;
runloop_ctl(RUNLOOP_CTL_UNSET_FRAME_TIME_LAST, NULL);
}
if (runloop_ctl(RUNLOOP_CTL_SHOULD_SET_FRAME_LIMIT, NULL))
{
struct retro_system_av_info *av_info = video_viewport_get_system_av_info();
float fastforward_ratio = (settings->fastforward_ratio == 0.0f)
? 1.0f : settings->fastforward_ratio;
frame_limit_last_time = retro_get_time_usec();
frame_limit_minimum_time = (retro_time_t)roundf(1000000.0f
/ (av_info->timing.fps * fastforward_ratio));
runloop_ctl(RUNLOOP_CTL_UNSET_FRAME_LIMIT, NULL);
}
if (input_driver_ctl(RARCH_INPUT_CTL_IS_FLUSHING_INPUT, NULL))
{
input_driver_ctl(RARCH_INPUT_CTL_UNSET_FLUSHING_INPUT, NULL);
if (cmd.state[0])
{
cmd.state[0] = 0;
/* If core was paused before entering menu, evoke
* pause toggle to wake it up. */
if (runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL))
BIT64_SET(cmd.state[0], RARCH_PAUSE_TOGGLE);
input_driver_ctl(RARCH_INPUT_CTL_SET_FLUSHING_INPUT, NULL);
}
}
if (system->frame_time.callback)
{
/* Updates frame timing if frame timing callback is in use by the core.
* Limits frame time if fast forward ratio throttle is enabled. */
bool is_slowmotion;
retro_time_t current = retro_get_time_usec();
retro_time_t delta = current - frame_time_last;
bool is_locked_fps = (runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL) ||
input_driver_ctl(RARCH_INPUT_CTL_IS_NONBLOCK_STATE, NULL)) |
!!recording_driver_get_data_ptr();
runloop_ctl(RUNLOOP_CTL_IS_SLOWMOTION, &is_slowmotion);
if (!frame_time_last || is_locked_fps)
delta = system->frame_time.reference;
if (!is_locked_fps && is_slowmotion)
delta /= settings->slowmotion_ratio;
frame_time_last = current;
if (is_locked_fps)
frame_time_last = 0;
system->frame_time.callback(delta);
}
cmd.state[2] = cmd.state[0] & ~cmd.state[1]; /* trigger */
if (runloop_cmd_triggered(cmd_ptr, RARCH_OVERLAY_NEXT))
event_command(EVENT_CMD_OVERLAY_NEXT);
if (runloop_cmd_triggered(cmd_ptr, RARCH_FULLSCREEN_TOGGLE_KEY))
{
bool fullscreen_toggled = !runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL);
#ifdef HAVE_MENU
fullscreen_toggled = fullscreen_toggled || menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL);
#endif
if (fullscreen_toggled)
event_command(EVENT_CMD_FULLSCREEN_TOGGLE);
}
if (runloop_cmd_triggered(cmd_ptr, RARCH_GRAB_MOUSE_TOGGLE))
event_command(EVENT_CMD_GRAB_MOUSE_TOGGLE);
#ifdef HAVE_MENU
if (runloop_cmd_menu_press(cmd_ptr) || (global->inited.core.type == CORE_TYPE_DUMMY))
{
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (global->inited.main && (global->inited.core.type != CORE_TYPE_DUMMY))
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
}
else
rarch_ctl(RARCH_CTL_MENU_RUNNING, NULL);
}
#endif
#ifdef HAVE_OVERLAY
runloop_iterate_linefeed_overlay(settings);
#endif
if (runloop_iterate_time_to_exit(runloop_cmd_press(cmd_ptr, RARCH_QUIT_KEY)) != 1)
{
frame_limit_last_time = 0.0;
return -1;
}
#ifdef HAVE_MENU
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
bool focused = runloop_ctl(RUNLOOP_CTL_CHECK_FOCUS, NULL) && !ui_companion_is_on_foreground();
bool is_idle = runloop_ctl(RUNLOOP_CTL_IS_IDLE, NULL);
if (menu_driver_iterate((enum menu_action)menu_input_frame_retropad(cmd.state[0], cmd.state[2])) == -1)
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
if (focused || !is_idle)
menu_driver_ctl(RARCH_MENU_CTL_RENDER, NULL);
if (!focused || is_idle)
{
*sleep_ms = 10;
return 1;
}
goto end;
}
#endif
if (!runloop_ctl(RUNLOOP_CTL_CHECK_STATE, &cmd))
{
/* RetroArch has been paused. */
retro_ctx.poll_cb();
*sleep_ms = 10;
return 1;
}
#if defined(HAVE_THREADS)
lock_autosave();
#endif
#ifdef HAVE_NETPLAY
netplay_driver_ctl(RARCH_NETPLAY_CTL_PRE_FRAME, NULL);
#endif
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
bsv_movie_ctl(BSV_MOVIE_CTL_SET_FRAME_START, NULL);
if (system->camera_callback.caps)
driver_camera_poll();
/* Update binds for analog dpad modes. */
for (i = 0; i < settings->input.max_users; i++)
{
if (!settings->input.analog_dpad_mode[i])
continue;
input_push_analog_dpad(settings->input.binds[i],
settings->input.analog_dpad_mode[i]);
input_push_analog_dpad(settings->input.autoconf_binds[i],
settings->input.analog_dpad_mode[i]);
}
if ((settings->video.frame_delay > 0) &&
!input_driver_ctl(RARCH_INPUT_CTL_IS_NONBLOCK_STATE, NULL))
retro_sleep(settings->video.frame_delay);
/* Run libretro for one frame. */
core.retro_run();
#ifdef HAVE_CHEEVOS
/* Test the achievements. */
cheevos_test();
#endif
for (i = 0; i < settings->input.max_users; i++)
{
if (!settings->input.analog_dpad_mode[i])
continue;
input_pop_analog_dpad(settings->input.binds[i]);
input_pop_analog_dpad(settings->input.autoconf_binds[i]);
}
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
bsv_movie_ctl(BSV_MOVIE_CTL_SET_FRAME_END, NULL);
#ifdef HAVE_NETPLAY
netplay_driver_ctl(RARCH_NETPLAY_CTL_POST_FRAME, NULL);
#endif
#if defined(HAVE_THREADS)
unlock_autosave();
#endif
#ifdef HAVE_MENU
end:
#endif
if (!settings->fastforward_ratio)
return 0;
current = retro_get_time_usec();
target = frame_limit_last_time + frame_limit_minimum_time;
to_sleep_ms = (target - current) / 1000;
if (to_sleep_ms > 0)
{
*sleep_ms = (unsigned)to_sleep_ms;
/* Combat jitter a bit. */
frame_limit_last_time += frame_limit_minimum_time;
return 1;
}
frame_limit_last_time = retro_get_time_usec();
return 0;
}
static bool runloop_check_state(event_cmd_state_t *cmd,
rarch_dir_list_t *shader_dir)
{
bool tmp = false;
settings_t *settings = config_get_ptr();
if (!cmd || runloop_ctl(RUNLOOP_CTL_IS_IDLE, NULL))
return false;
if (runloop_cmd_triggered(cmd, RARCH_SCREENSHOT))
command_event(CMD_EVENT_TAKE_SCREENSHOT, NULL);
if (runloop_cmd_triggered(cmd, RARCH_MUTE))
command_event(CMD_EVENT_AUDIO_MUTE_TOGGLE, NULL);
if (runloop_cmd_triggered(cmd, RARCH_OSK))
{
if (input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_IS_LINEFEED_ENABLED, NULL))
input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_UNSET_LINEFEED_ENABLED, NULL);
else
input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_SET_LINEFEED_ENABLED, NULL);
}
if (runloop_cmd_press(cmd, RARCH_VOLUME_UP))
command_event(CMD_EVENT_VOLUME_UP, NULL);
else if (runloop_cmd_press(cmd, RARCH_VOLUME_DOWN))
command_event(CMD_EVENT_VOLUME_DOWN, NULL);
#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_check_idle_state(cmd))
return false;
runloop_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));
runloop_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))
command_event(CMD_EVENT_SAVE_STATE, NULL);
else if (runloop_cmd_triggered(cmd, RARCH_LOAD_STATE_KEY))
command_event(CMD_EVENT_LOAD_STATE, NULL);
#ifdef HAVE_CHEEVOS
if(!settings->cheevos.hardcore_mode_enable)
#endif
state_manager_check_rewind(runloop_cmd_press(cmd, RARCH_REWIND));
tmp = runloop_cmd_press(cmd, RARCH_SLOWMOTION);
runloop_check_slowmotion(&tmp);
if (runloop_cmd_triggered(cmd, RARCH_MOVIE_RECORD_TOGGLE))
runloop_check_movie();
if (runloop_cmd_triggered(cmd, RARCH_SHADER_NEXT) ||
runloop_cmd_triggered(cmd, RARCH_SHADER_PREV))
{
runloop_check_shader_dir(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))
command_event(CMD_EVENT_DISK_EJECT_TOGGLE, NULL);
else if (runloop_cmd_triggered(cmd, RARCH_DISK_NEXT))
command_event(CMD_EVENT_DISK_NEXT, NULL);
else if (runloop_cmd_triggered(cmd, RARCH_DISK_PREV))
command_event(CMD_EVENT_DISK_PREV, NULL);
if (runloop_cmd_triggered(cmd, RARCH_RESET))
command_event(CMD_EVENT_RESET, NULL);
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));
return true;
}
/**
* runloop_iterate:
*
* Run Libretro core in RetroArch for one frame.
*
* Returns: 0 on success, 1 if we have to wait until
* button input in order to wake up the loop,
* -1 if we forcibly quit out of the RetroArch iteration loop.
**/
int runloop_iterate(unsigned *sleep_ms)
{
unsigned i;
event_cmd_state_t cmd;
retro_time_t current, target, to_sleep_ms;
static retro_input_t last_input = {0};
event_cmd_state_t *cmd_ptr = &cmd;
static retro_time_t frame_limit_minimum_time = 0.0;
static retro_time_t frame_limit_last_time = 0.0;
settings_t *settings = config_get_ptr();
cmd.state[1] = last_input;
cmd.state[0] = input_keys_pressed();
last_input = cmd.state[0];
runloop_ctl(RUNLOOP_CTL_UNSET_FRAME_TIME_LAST, NULL);
if (runloop_ctl(RUNLOOP_CTL_SHOULD_SET_FRAME_LIMIT, NULL))
{
struct retro_system_av_info *av_info =
video_viewport_get_system_av_info();
float fastforward_ratio =
(settings->fastforward_ratio == 0.0f)
? 1.0f : settings->fastforward_ratio;
frame_limit_last_time = cpu_features_get_time_usec();
frame_limit_minimum_time = (retro_time_t)roundf(1000000.0f
/ (av_info->timing.fps * fastforward_ratio));
runloop_ctl(RUNLOOP_CTL_UNSET_FRAME_LIMIT, NULL);
}
if (input_driver_is_flushing_input())
{
input_driver_unset_flushing_input();
if (cmd.state[0].state)
{
cmd.state[0].state = 0;
/* If core was paused before entering menu, evoke
* pause toggle to wake it up. */
if (runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL))
BIT64_SET(cmd.state[0].state, RARCH_PAUSE_TOGGLE);
input_driver_set_flushing_input();
}
}
if (runloop_frame_time.callback)
{
/* Updates frame timing if frame timing callback is in use by the core.
* Limits frame time if fast forward ratio throttle is enabled. */
retro_time_t current = cpu_features_get_time_usec();
retro_time_t delta = current - runloop_frame_time_last;
bool is_locked_fps = (runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL) ||
input_driver_is_nonblock_state()) |
!!recording_driver_get_data_ptr();
if (!runloop_frame_time_last || is_locked_fps)
delta = runloop_frame_time.reference;
if (!is_locked_fps && runloop_ctl(RUNLOOP_CTL_IS_SLOWMOTION, NULL))
delta /= settings->slowmotion_ratio;
runloop_frame_time_last = current;
if (is_locked_fps)
runloop_frame_time_last = 0;
runloop_frame_time.callback(delta);
}
cmd.state[2].state = cmd.state[0].state & ~cmd.state[1].state; /* trigger */
if (runloop_cmd_triggered(cmd_ptr, RARCH_OVERLAY_NEXT))
command_event(CMD_EVENT_OVERLAY_NEXT, NULL);
if (runloop_cmd_triggered(cmd_ptr, RARCH_FULLSCREEN_TOGGLE_KEY))
{
bool fullscreen_toggled = !runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL);
#ifdef HAVE_MENU
fullscreen_toggled = fullscreen_toggled ||
menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL);
#endif
if (fullscreen_toggled)
command_event(CMD_EVENT_FULLSCREEN_TOGGLE, NULL);
}
if (runloop_cmd_triggered(cmd_ptr, RARCH_GRAB_MOUSE_TOGGLE))
command_event(CMD_EVENT_GRAB_MOUSE_TOGGLE, NULL);
#ifdef HAVE_MENU
if (runloop_cmd_menu_press(cmd_ptr) ||
rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL))
{
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (rarch_ctl(RARCH_CTL_IS_INITED, NULL) &&
!rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL))
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
}
else
rarch_ctl(RARCH_CTL_MENU_RUNNING, NULL);
}
#endif
#ifdef HAVE_OVERLAY
runloop_iterate_linefeed_overlay(settings);
#endif
if (runloop_iterate_time_to_exit(
runloop_cmd_press(cmd_ptr, RARCH_QUIT_KEY)) != 1)
{
frame_limit_last_time = 0.0;
return -1;
}
#ifdef HAVE_MENU
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
int ret = runloop_iterate_menu((enum menu_action)
menu_input_frame_retropad(cmd.state[0], cmd.state[2]),
sleep_ms);
if (ret == -1)
goto end;
return ret;
}
#endif
if (!runloop_check_state(&cmd, &runloop_shader_dir))
{
/* RetroArch has been paused. */
core_poll();
*sleep_ms = 10;
return 1;
}
#if defined(HAVE_THREADS)
autosave_lock();
#endif
#ifdef HAVE_NETPLAY
netplay_driver_ctl(RARCH_NETPLAY_CTL_PRE_FRAME, NULL);
#endif
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
bsv_movie_ctl(BSV_MOVIE_CTL_SET_FRAME_START, NULL);
camera_driver_ctl(RARCH_CAMERA_CTL_POLL, NULL);
/* Update binds for analog dpad modes. */
for (i = 0; i < settings->input.max_users; i++)
{
if (!settings->input.analog_dpad_mode[i])
continue;
input_push_analog_dpad(settings->input.binds[i],
settings->input.analog_dpad_mode[i]);
input_push_analog_dpad(settings->input.autoconf_binds[i],
settings->input.analog_dpad_mode[i]);
}
if ((settings->video.frame_delay > 0) &&
!input_driver_is_nonblock_state())
retro_sleep(settings->video.frame_delay);
core_run();
#ifdef HAVE_CHEEVOS
cheevos_test();
#endif
for (i = 0; i < settings->input.max_users; i++)
{
if (!settings->input.analog_dpad_mode[i])
continue;
input_pop_analog_dpad(settings->input.binds[i]);
input_pop_analog_dpad(settings->input.autoconf_binds[i]);
}
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
bsv_movie_ctl(BSV_MOVIE_CTL_SET_FRAME_END, NULL);
#ifdef HAVE_NETPLAY
netplay_driver_ctl(RARCH_NETPLAY_CTL_POST_FRAME, NULL);
#endif
#if defined(HAVE_THREADS)
autosave_unlock();
#endif
if (!settings->fastforward_ratio)
return 0;
#ifdef HAVE_MENU
end:
#endif
current = cpu_features_get_time_usec();
target = frame_limit_last_time +
frame_limit_minimum_time;
to_sleep_ms = (target - current) / 1000;
if (to_sleep_ms > 0)
{
*sleep_ms = (unsigned)to_sleep_ms;
/* Combat jitter a bit. */
frame_limit_last_time += frame_limit_minimum_time;
return 1;
}
frame_limit_last_time = cpu_features_get_time_usec();
return 0;
}
static void netplay_announce_cb(void *task_data, void *user_data, const char *error)
{
RARCH_LOG("[netplay] announcing netplay game... \n");
if (task_data)
{
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
struct string_list *lines;
unsigned i, ip_len, port_len;
const char *mitm_ip = NULL;
const char *mitm_port = NULL;
char *buf;
char *host_string;
if (data->len == 0)
{
free(task_data);
return;
}
buf = (char*)calloc(1, data->len + 1);
memcpy(buf, data->data, data->len);
lines = string_split(buf, "\n");
if (lines->size == 0)
{
string_list_free(lines);
free(buf);
free(task_data);
return;
}
for (i = 0; i < lines->size; i++)
{
const char *line = lines->elems[i].data;
if (!strncmp(line, "mitm_ip=", 8))
mitm_ip = line + 8;
if (!strncmp(line, "mitm_port=", 10))
mitm_port = line + 10;
}
if (mitm_ip && mitm_port)
{
RARCH_LOG("[netplay] joining relay server: %s:%s\n", mitm_ip, mitm_port);
ip_len = (unsigned)strlen(mitm_ip);
port_len = (unsigned)strlen(mitm_port);
/* Enable Netplay client mode */
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
{
command_event(CMD_EVENT_NETPLAY_DEINIT, NULL);
is_mitm = true;
}
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_CLIENT, NULL);
host_string = (char*)calloc(1, ip_len + port_len + 2);
memcpy(host_string, mitm_ip, ip_len);
memcpy(host_string + ip_len, "|", 1);
memcpy(host_string + ip_len + 1, mitm_port, port_len);
/* Enable Netplay */
command_event(CMD_EVENT_NETPLAY_INIT_DIRECT_DEFERRED, (void*)host_string);
command_event(CMD_EVENT_NETPLAY_INIT, (void*)host_string);
free(host_string);
}
string_list_free(lines);
free(buf);
free(task_data);
}
return;
}
static enum runloop_state runloop_check_state(
settings_t *settings,
uint64_t current_input,
uint64_t old_input,
unsigned *sleep_ms)
{
static bool old_focus = true;
#ifdef HAVE_OVERLAY
static char prev_overlay_restore = false;
bool osk_enable = input_driver_is_onscreen_keyboard_enabled();
#endif
#ifdef HAVE_NETWORKING
bool tmp = false;
#endif
bool focused = true;
uint64_t trigger_input = current_input & ~old_input;
bool pause_pressed = runloop_cmd_triggered(trigger_input, RARCH_PAUSE_TOGGLE);
if (input_driver_is_flushing_input())
{
input_driver_unset_flushing_input();
if (current_input)
{
current_input = 0;
/* If core was paused before entering menu, evoke
* pause toggle to wake it up. */
if (runloop_paused)
BIT64_SET(current_input, RARCH_PAUSE_TOGGLE);
input_driver_set_flushing_input();
}
}
if (runloop_cmd_triggered(trigger_input, RARCH_OVERLAY_NEXT))
command_event(CMD_EVENT_OVERLAY_NEXT, NULL);
if (runloop_cmd_triggered(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
{
bool fullscreen_toggled = !runloop_paused;
#ifdef HAVE_MENU
fullscreen_toggled = fullscreen_toggled ||
menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL);
#endif
if (fullscreen_toggled)
command_event(CMD_EVENT_FULLSCREEN_TOGGLE, NULL);
}
if (runloop_cmd_triggered(trigger_input, RARCH_GRAB_MOUSE_TOGGLE))
command_event(CMD_EVENT_GRAB_MOUSE_TOGGLE, NULL);
#ifdef HAVE_OVERLAY
if (osk_enable && !input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_IS_LINEFEED_ENABLED, NULL))
{
input_driver_unset_onscreen_keyboard_enabled();
prev_overlay_restore = true;
command_event(CMD_EVENT_OVERLAY_DEINIT, NULL);
}
else if (!osk_enable && input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_IS_LINEFEED_ENABLED, NULL))
{
input_driver_set_onscreen_keyboard_enabled();
prev_overlay_restore = false;
command_event(CMD_EVENT_OVERLAY_INIT, NULL);
}
else if (prev_overlay_restore)
{
if (!settings->input.overlay_hide_in_menu)
command_event(CMD_EVENT_OVERLAY_INIT, NULL);
prev_overlay_restore = false;
}
#endif
if (runloop_iterate_time_to_exit(
runloop_cmd_press(current_input, RARCH_QUIT_KEY)) != 1)
return RUNLOOP_STATE_QUIT;
#ifdef HAVE_MENU
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
menu_ctx_iterate_t iter;
bool skip = false;
#ifdef HAVE_OVERLAY
skip = osk_enable && input_keyboard_return_pressed();
#endif
if (!skip)
{
enum menu_action action = (enum menu_action)menu_event(current_input, trigger_input);
bool focused = settings->pause_nonactive ? video_driver_is_focused() : true;
focused = focused && !ui_companion_is_on_foreground();
iter.action = action;
if (!menu_driver_ctl(RARCH_MENU_CTL_ITERATE, &iter))
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
if (focused || !runloop_idle)
menu_driver_ctl(RARCH_MENU_CTL_RENDER, NULL);
if (!focused)
return RUNLOOP_STATE_SLEEP;
if (action == MENU_ACTION_QUIT)
return RUNLOOP_STATE_QUIT;
}
}
#endif
if (runloop_idle)
return RUNLOOP_STATE_SLEEP;
#ifdef HAVE_MENU
if (menu_event_keyboard_is_set(RETROK_F1) == 1)
{
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (rarch_ctl(RARCH_CTL_IS_INITED, NULL) &&
!rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL))
{
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
menu_event_keyboard_set(false, RETROK_F1);
}
}
}
else if ((!menu_event_keyboard_is_set(RETROK_F1) && runloop_cmd_menu_press(current_input, old_input, trigger_input)) ||
rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL))
{
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (rarch_ctl(RARCH_CTL_IS_INITED, NULL) &&
!rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL))
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
}
else
{
menu_display_toggle_set_reason(MENU_TOGGLE_REASON_USER);
rarch_ctl(RARCH_CTL_MENU_RUNNING, NULL);
}
}
else
menu_event_keyboard_set(false, RETROK_F1);
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (!settings->menu.throttle_framerate && !settings->fastforward_ratio)
return RUNLOOP_STATE_MENU_ITERATE;
return RUNLOOP_STATE_END;
}
#endif
if (settings->pause_nonactive)
focused = video_driver_is_focused();
if (runloop_cmd_triggered(trigger_input, RARCH_SCREENSHOT))
command_event(CMD_EVENT_TAKE_SCREENSHOT, NULL);
if (runloop_cmd_triggered(trigger_input, RARCH_MUTE))
command_event(CMD_EVENT_AUDIO_MUTE_TOGGLE, NULL);
if (runloop_cmd_triggered(trigger_input, RARCH_OSK))
{
if (input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_IS_LINEFEED_ENABLED, NULL))
input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_UNSET_LINEFEED_ENABLED, NULL);
else
input_keyboard_ctl(
RARCH_INPUT_KEYBOARD_CTL_SET_LINEFEED_ENABLED, NULL);
}
if (runloop_cmd_press(current_input, RARCH_VOLUME_UP))
command_event(CMD_EVENT_VOLUME_UP, NULL);
else if (runloop_cmd_press(current_input, RARCH_VOLUME_DOWN))
command_event(CMD_EVENT_VOLUME_DOWN, NULL);
#ifdef HAVE_NETWORKING
tmp = runloop_cmd_triggered(trigger_input, RARCH_NETPLAY_FLIP);
netplay_driver_ctl(RARCH_NETPLAY_CTL_FLIP_PLAYERS, &tmp);
tmp = runloop_cmd_triggered(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY);
netplay_driver_ctl(RARCH_NETPLAY_CTL_FULLSCREEN_TOGGLE, &tmp);
#endif
/* Check if libretro pause key was pressed. If so, pause or
* unpause the libretro core. */
/* FRAMEADVANCE will set us into pause mode. */
pause_pressed |= !runloop_paused && runloop_cmd_triggered(trigger_input, RARCH_FRAMEADVANCE);
if (focused && pause_pressed)
command_event(CMD_EVENT_PAUSE_TOGGLE, NULL);
else if (focused && !old_focus)
command_event(CMD_EVENT_UNPAUSE, NULL);
else if (!focused && old_focus)
command_event(CMD_EVENT_PAUSE, NULL);
old_focus = focused;
if (!focused)
return RUNLOOP_STATE_SLEEP;
if (runloop_paused)
{
/* check pause state */
bool check_is_oneshot = runloop_cmd_triggered(trigger_input,
RARCH_FRAMEADVANCE)
|| runloop_cmd_press(current_input, RARCH_REWIND);
if (runloop_cmd_triggered(trigger_input, RARCH_FULLSCREEN_TOGGLE_KEY))
{
command_event(CMD_EVENT_FULLSCREEN_TOGGLE, NULL);
if (!runloop_ctl(RUNLOOP_CTL_IS_IDLE, NULL))
video_driver_cached_frame();
}
if (!check_is_oneshot)
return RUNLOOP_STATE_SLEEP;
}
/* To avoid continous switching if we hold the button down, we require
* that the button must go from pressed to unpressed back to pressed
* to be able to toggle between then.
*/
if (runloop_cmd_triggered(trigger_input, RARCH_FAST_FORWARD_KEY))
{
if (input_driver_is_nonblock_state())
input_driver_unset_nonblock_state();
else
input_driver_set_nonblock_state();
driver_ctl(RARCH_DRIVER_CTL_SET_NONBLOCK_STATE, NULL);
}
else if ((runloop_cmd_pressed(old_input, RARCH_FAST_FORWARD_HOLD_KEY)
!= runloop_cmd_press(current_input, RARCH_FAST_FORWARD_HOLD_KEY)))
{
if (runloop_cmd_press(current_input, RARCH_FAST_FORWARD_HOLD_KEY))
input_driver_set_nonblock_state();
else
input_driver_unset_nonblock_state();
driver_ctl(RARCH_DRIVER_CTL_SET_NONBLOCK_STATE, NULL);
}
/* Checks if the state increase/decrease keys have been pressed
* for this frame. */
if (runloop_cmd_triggered(trigger_input, RARCH_STATE_SLOT_PLUS))
{
char msg[128];
msg[0] = '\0';
settings->state_slot++;
snprintf(msg, sizeof(msg), "%s: %d",
msg_hash_to_str(MSG_STATE_SLOT),
settings->state_slot);
runloop_msg_queue_push(msg, 2, 180, true);
RARCH_LOG("%s\n", msg);
}
else if (runloop_cmd_triggered(trigger_input, RARCH_STATE_SLOT_MINUS))
{
char msg[128];
msg[0] = '\0';
if (settings->state_slot > 0)
settings->state_slot--;
snprintf(msg, sizeof(msg), "%s: %d",
msg_hash_to_str(MSG_STATE_SLOT),
settings->state_slot);
runloop_msg_queue_push(msg, 2, 180, true);
RARCH_LOG("%s\n", msg);
}
if (runloop_cmd_triggered(trigger_input, RARCH_SAVE_STATE_KEY))
command_event(CMD_EVENT_SAVE_STATE, NULL);
else if (runloop_cmd_triggered(trigger_input, RARCH_LOAD_STATE_KEY))
command_event(CMD_EVENT_LOAD_STATE, NULL);
#ifdef HAVE_CHEEVOS
if (!settings->cheevos.hardcore_mode_enable)
#endif
state_manager_check_rewind(runloop_cmd_press(current_input, RARCH_REWIND));
runloop_slowmotion = runloop_cmd_press(current_input, RARCH_SLOWMOTION);
if (runloop_slowmotion)
{
/* Checks if slowmotion toggle/hold was being pressed and/or held. */
if (settings->video.black_frame_insertion)
{
if (!runloop_ctl(RUNLOOP_CTL_IS_IDLE, NULL))
video_driver_cached_frame();
}
if (state_manager_frame_is_reversed())
runloop_msg_queue_push(msg_hash_to_str(MSG_SLOW_MOTION_REWIND), 2, 30, true);
else
runloop_msg_queue_push(msg_hash_to_str(MSG_SLOW_MOTION), 2, 30, true);
}
if (runloop_cmd_triggered(trigger_input, RARCH_MOVIE_RECORD_TOGGLE))
bsv_movie_check();
if (runloop_cmd_triggered(trigger_input, RARCH_SHADER_NEXT) ||
runloop_cmd_triggered(trigger_input, RARCH_SHADER_PREV))
dir_check_shader(
runloop_cmd_triggered(trigger_input, RARCH_SHADER_NEXT),
runloop_cmd_triggered(trigger_input, RARCH_SHADER_PREV));
if (runloop_cmd_triggered(trigger_input, RARCH_DISK_EJECT_TOGGLE))
command_event(CMD_EVENT_DISK_EJECT_TOGGLE, NULL);
else if (runloop_cmd_triggered(trigger_input, RARCH_DISK_NEXT))
command_event(CMD_EVENT_DISK_NEXT, NULL);
else if (runloop_cmd_triggered(trigger_input, RARCH_DISK_PREV))
command_event(CMD_EVENT_DISK_PREV, NULL);
if (runloop_cmd_triggered(trigger_input, RARCH_RESET))
command_event(CMD_EVENT_RESET, NULL);
cheat_manager_state_checks(
runloop_cmd_triggered(trigger_input, RARCH_CHEAT_INDEX_PLUS),
runloop_cmd_triggered(trigger_input, RARCH_CHEAT_INDEX_MINUS),
runloop_cmd_triggered(trigger_input, RARCH_CHEAT_TOGGLE));
return RUNLOOP_STATE_ITERATE;
}
bool runloop_ctl(enum runloop_ctl_state state, void *data)
{
switch (state)
{
case RUNLOOP_CTL_SYSTEM_INFO_INIT:
core_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";
video_driver_set_title_buf();
strlcpy(runloop_system.valid_extensions,
runloop_system.info.valid_extensions ?
runloop_system.info.valid_extensions : DEFAULT_EXT,
sizeof(runloop_system.valid_extensions));
break;
case RUNLOOP_CTL_GET_CORE_OPTION_SIZE:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
*idx = core_option_manager_size(runloop_core_options);
}
break;
case RUNLOOP_CTL_HAS_CORE_OPTIONS:
return runloop_core_options;
case RUNLOOP_CTL_CORE_OPTIONS_LIST_GET:
{
core_option_manager_t **coreopts = (core_option_manager_t**)data;
if (!coreopts)
return false;
*coreopts = runloop_core_options;
}
break;
case RUNLOOP_CTL_SYSTEM_INFO_GET:
{
rarch_system_info_t **system = (rarch_system_info_t**)data;
if (!system)
return false;
*system = &runloop_system;
}
break;
case RUNLOOP_CTL_SYSTEM_INFO_FREE:
/* No longer valid. */
if (runloop_system.subsystem.data)
free(runloop_system.subsystem.data);
runloop_system.subsystem.data = NULL;
runloop_system.subsystem.size = 0;
if (runloop_system.ports.data)
free(runloop_system.ports.data);
runloop_system.ports.data = NULL;
runloop_system.ports.size = 0;
if (runloop_system.mmaps.descriptors)
free((void *)runloop_system.mmaps.descriptors);
runloop_system.mmaps.descriptors = NULL;
runloop_system.mmaps.num_descriptors = 0;
runloop_key_event = NULL;
runloop_frontend_key_event = NULL;
audio_driver_unset_callback();
memset(&runloop_system, 0, sizeof(rarch_system_info_t));
break;
case RUNLOOP_CTL_SET_FRAME_TIME_LAST:
runloop_frame_time_last_enable = true;
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_SET_FRAME_LIMIT:
runloop_set_frame_limit = true;
break;
case RUNLOOP_CTL_GET_PERFCNT:
{
bool **perfcnt = (bool**)data;
if (!perfcnt)
return false;
*perfcnt = &runloop_perfcnt_enable;
}
break;
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_SET_NONBLOCK_FORCED:
runloop_force_nonblock = true;
break;
case RUNLOOP_CTL_UNSET_NONBLOCK_FORCED:
runloop_force_nonblock = false;
break;
case RUNLOOP_CTL_IS_NONBLOCK_FORCED:
return runloop_force_nonblock;
case RUNLOOP_CTL_SET_FRAME_TIME:
{
const struct retro_frame_time_callback *info =
(const struct retro_frame_time_callback*)data;
#ifdef HAVE_NETWORKING
/* retro_run() will be called in very strange and
* mysterious ways, have to disable it. */
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_ENABLED, NULL))
return false;
#endif
runloop_frame_time = *info;
}
break;
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:
return path_set(RARCH_PATH_CORE, (const char*)data);
case RUNLOOP_CTL_FRAME_TIME_FREE:
memset(&runloop_frame_time, 0,
sizeof(struct retro_frame_time_callback));
runloop_frame_time_last = 0;
runloop_max_frames = 0;
break;
case RUNLOOP_CTL_STATE_FREE:
runloop_perfcnt_enable = false;
runloop_idle = false;
runloop_paused = false;
runloop_slowmotion = false;
runloop_frame_time_last_enable = false;
runloop_set_frame_limit = false;
runloop_overrides_active = false;
runloop_ctl(RUNLOOP_CTL_FRAME_TIME_FREE, NULL);
break;
case RUNLOOP_CTL_GLOBAL_FREE:
{
global_t *global = NULL;
command_event(CMD_EVENT_TEMPORARY_CONTENT_DEINIT, NULL);
path_deinit_subsystem();
command_event(CMD_EVENT_RECORD_DEINIT, NULL);
command_event(CMD_EVENT_LOG_FILE_DEINIT, NULL);
rarch_ctl(RARCH_CTL_UNSET_BLOCK_CONFIG_READ, NULL);
rarch_ctl(RARCH_CTL_UNSET_SRAM_LOAD_DISABLED, NULL);
rarch_ctl(RARCH_CTL_UNSET_SRAM_SAVE_DISABLED, NULL);
rarch_ctl(RARCH_CTL_UNSET_SRAM_ENABLE, NULL);
rarch_ctl(RARCH_CTL_UNSET_BPS_PREF, NULL);
rarch_ctl(RARCH_CTL_UNSET_IPS_PREF, NULL);
rarch_ctl(RARCH_CTL_UNSET_UPS_PREF, NULL);
rarch_ctl(RARCH_CTL_UNSET_PATCH_BLOCKED, NULL);
runloop_overrides_active = false;
core_unset_input_descriptors();
global = global_get_ptr();
path_clear_all();
dir_clear_all();
memset(global, 0, sizeof(struct global));
retroarch_override_setting_free_state();
}
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:
return runloop_slowmotion;
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_PULL:
#ifdef HAVE_THREADS
slock_lock(_runloop_msg_queue_lock);
#endif
{
const char **ret = (const char**)data;
if (!ret)
{
#ifdef HAVE_THREADS
slock_unlock(_runloop_msg_queue_lock);
#endif
return false;
}
*ret = msg_queue_pull(runloop_msg_queue);
}
#ifdef HAVE_THREADS
slock_unlock(_runloop_msg_queue_lock);
#endif
break;
case RUNLOOP_CTL_MSG_QUEUE_DEINIT:
if (!runloop_msg_queue)
return true;
#ifdef HAVE_THREADS
slock_lock(_runloop_msg_queue_lock);
#endif
msg_queue_free(runloop_msg_queue);
#ifdef HAVE_THREADS
slock_unlock(_runloop_msg_queue_lock);
#endif
#ifdef HAVE_THREADS
slock_free(_runloop_msg_queue_lock);
_runloop_msg_queue_lock = NULL;
#endif
runloop_msg_queue = NULL;
break;
case RUNLOOP_CTL_MSG_QUEUE_INIT:
runloop_ctl(RUNLOOP_CTL_MSG_QUEUE_DEINIT, NULL);
runloop_msg_queue = msg_queue_new(8);
retro_assert(runloop_msg_queue);
#ifdef HAVE_THREADS
_runloop_msg_queue_lock = slock_new();
retro_assert(_runloop_msg_queue_lock);
#endif
break;
case RUNLOOP_CTL_TASK_INIT:
{
#ifdef HAVE_THREADS
settings_t *settings = config_get_ptr();
bool threaded_enable = settings->threaded_data_runloop_enable;
#else
bool threaded_enable = false;
#endif
task_queue_ctl(TASK_QUEUE_CTL_DEINIT, NULL);
task_queue_ctl(TASK_QUEUE_CTL_INIT, &threaded_enable);
}
break;
case RUNLOOP_CTL_SET_CORE_SHUTDOWN:
runloop_core_shutdown_initiated = true;
break;
case RUNLOOP_CTL_SET_SHUTDOWN:
runloop_shutdown_initiated = true;
break;
case RUNLOOP_CTL_IS_SHUTDOWN:
return runloop_shutdown_initiated;
case RUNLOOP_CTL_SET_EXEC:
runloop_exec = true;
break;
case RUNLOOP_CTL_DATA_DEINIT:
task_queue_ctl(TASK_QUEUE_CTL_DEINIT, NULL);
break;
case RUNLOOP_CTL_IS_CORE_OPTION_UPDATED:
if (!runloop_core_options)
return false;
return core_option_manager_updated(runloop_core_options);
case RUNLOOP_CTL_CORE_OPTION_PREV:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
core_option_manager_prev(runloop_core_options, *idx);
if (ui_companion_is_on_foreground())
ui_companion_driver_notify_refresh();
}
break;
case RUNLOOP_CTL_CORE_OPTION_NEXT:
{
unsigned *idx = (unsigned*)data;
if (!idx)
return false;
core_option_manager_next(runloop_core_options, *idx);
if (ui_companion_is_on_foreground())
ui_companion_driver_notify_refresh();
}
break;
case RUNLOOP_CTL_CORE_OPTIONS_GET:
{
struct retro_variable *var = (struct retro_variable*)data;
if (!runloop_core_options || !var)
return false;
RARCH_LOG("Environ GET_VARIABLE %s:\n", var->key);
core_option_manager_get(runloop_core_options, var);
RARCH_LOG("\t%s\n", var->value ? var->value :
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE));
}
break;
case RUNLOOP_CTL_CORE_OPTIONS_INIT:
{
settings_t *settings = config_get_ptr();
char *game_options_path = NULL;
bool ret = false;
const struct retro_variable *vars =
(const struct retro_variable*)data;
if (settings && settings->game_specific_options)
ret = rarch_game_specific_options(&game_options_path);
if(ret)
{
runloop_ctl(RUNLOOP_CTL_SET_GAME_OPTIONS_ACTIVE, NULL);
runloop_core_options =
core_option_manager_new(game_options_path, vars);
free(game_options_path);
}
else
{
char buf[PATH_MAX_LENGTH];
const char *options_path = NULL;
buf[0] = '\0';
if (settings)
options_path = settings->path.core_options;
if (string_is_empty(options_path) && !path_is_empty(RARCH_PATH_CONFIG))
{
fill_pathname_resolve_relative(buf, path_get(RARCH_PATH_CONFIG),
file_path_str(FILE_PATH_CORE_OPTIONS_CONFIG), sizeof(buf));
options_path = buf;
}
runloop_ctl(RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE, NULL);
if (!string_is_empty(options_path))
runloop_core_options =
core_option_manager_new(options_path, vars);
}
}
break;
case RUNLOOP_CTL_CORE_OPTIONS_FREE:
if (runloop_core_options)
core_option_manager_free(runloop_core_options);
runloop_core_options = NULL;
break;
case RUNLOOP_CTL_CORE_OPTIONS_DEINIT:
{
if (!runloop_core_options)
return false;
/* check if game options file was just created and flush
to that file instead */
if(!path_is_empty(RARCH_PATH_CORE_OPTIONS))
{
core_option_manager_flush_game_specific(runloop_core_options,
path_get(RARCH_PATH_CORE_OPTIONS));
path_clear(RARCH_PATH_CORE_OPTIONS);
}
else
core_option_manager_flush(runloop_core_options);
if (runloop_ctl(RUNLOOP_CTL_IS_GAME_OPTIONS_ACTIVE, NULL))
runloop_ctl(RUNLOOP_CTL_UNSET_GAME_OPTIONS_ACTIVE, NULL);
runloop_ctl(RUNLOOP_CTL_CORE_OPTIONS_FREE, NULL);
}
break;
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_FRONTEND_KEY_EVENT_GET:
{
retro_keyboard_event_t **key_event =
(retro_keyboard_event_t**)data;
if (!key_event)
return false;
*key_event = &runloop_frontend_key_event;
}
break;
case RUNLOOP_CTL_HTTPSERVER_INIT:
#if defined(HAVE_HTTPSERVER) && defined(HAVE_ZLIB)
httpserver_init(8888);
#endif
break;
case RUNLOOP_CTL_HTTPSERVER_DESTROY:
#if defined(HAVE_HTTPSERVER) && defined(HAVE_ZLIB)
httpserver_destroy();
#endif
break;
case RUNLOOP_CTL_NONE:
default:
break;
}
return true;
}
/**
* runloop_iterate:
*
* Run Libretro core in RetroArch for one frame.
*
* Returns: 0 on success, 1 if we have to wait until
* button input in order to wake up the loop,
* -1 if we forcibly quit out of the RetroArch iteration loop.
**/
int runloop_iterate(unsigned *sleep_ms)
{
unsigned i;
retro_time_t current, target, to_sleep_ms;
static uint64_t last_input = 0;
enum runloop_state runloop_status = RUNLOOP_STATE_NONE;
static retro_time_t frame_limit_minimum_time = 0.0;
static retro_time_t frame_limit_last_time = 0.0;
settings_t *settings = config_get_ptr();
uint64_t current_input = menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL) ? input_menu_keys_pressed() : input_keys_pressed();
uint64_t old_input = last_input;
last_input = current_input;
if (runloop_frame_time_last_enable)
{
runloop_frame_time_last = 0;
runloop_frame_time_last_enable = false;
}
if (runloop_set_frame_limit)
{
struct retro_system_av_info *av_info =
video_viewport_get_system_av_info();
float fastforward_ratio =
(settings->fastforward_ratio == 0.0f)
? 1.0f : settings->fastforward_ratio;
frame_limit_last_time = cpu_features_get_time_usec();
frame_limit_minimum_time = (retro_time_t)roundf(1000000.0f
/ (av_info->timing.fps * fastforward_ratio));
runloop_set_frame_limit = false;
}
if (runloop_frame_time.callback)
{
/* Updates frame timing if frame timing callback is in use by the core.
* Limits frame time if fast forward ratio throttle is enabled. */
retro_time_t current = cpu_features_get_time_usec();
retro_time_t delta = current - runloop_frame_time_last;
bool is_locked_fps = (runloop_paused ||
input_driver_is_nonblock_state()) |
!!recording_driver_get_data_ptr();
if (!runloop_frame_time_last || is_locked_fps)
delta = runloop_frame_time.reference;
if (!is_locked_fps && runloop_slowmotion)
delta /= settings->slowmotion_ratio;
runloop_frame_time_last = current;
if (is_locked_fps)
runloop_frame_time_last = 0;
runloop_frame_time.callback(delta);
}
runloop_status = runloop_check_state(settings, current_input,
old_input, sleep_ms);
switch (runloop_status)
{
case RUNLOOP_STATE_QUIT:
frame_limit_last_time = 0.0;
command_event(CMD_EVENT_QUIT, NULL);
return -1;
case RUNLOOP_STATE_SLEEP:
case RUNLOOP_STATE_END:
case RUNLOOP_STATE_MENU_ITERATE:
core_poll();
#ifdef HAVE_NETWORKING
/* FIXME: This is an ugly way to tell Netplay this... */
netplay_driver_ctl(RARCH_NETPLAY_CTL_PAUSE, NULL);
#endif
if (runloop_status == RUNLOOP_STATE_SLEEP)
*sleep_ms = 10;
if (runloop_status == RUNLOOP_STATE_END)
goto end;
if (runloop_status == RUNLOOP_STATE_MENU_ITERATE)
return 0;
return 1;
case RUNLOOP_STATE_ITERATE:
case RUNLOOP_STATE_NONE:
default:
break;
}
autosave_lock();
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
bsv_movie_ctl(BSV_MOVIE_CTL_SET_FRAME_START, NULL);
camera_driver_ctl(RARCH_CAMERA_CTL_POLL, NULL);
/* Update binds for analog dpad modes. */
for (i = 0; i < settings->input.max_users; i++)
{
if (!settings->input.analog_dpad_mode[i])
continue;
input_push_analog_dpad(settings->input.binds[i],
settings->input.analog_dpad_mode[i]);
input_push_analog_dpad(settings->input.autoconf_binds[i],
settings->input.analog_dpad_mode[i]);
}
if ((settings->video.frame_delay > 0) &&
!input_driver_is_nonblock_state())
retro_sleep(settings->video.frame_delay);
core_run();
#ifdef HAVE_CHEEVOS
cheevos_test();
#endif
for (i = 0; i < settings->input.max_users; i++)
{
if (!settings->input.analog_dpad_mode[i])
continue;
input_pop_analog_dpad(settings->input.binds[i]);
input_pop_analog_dpad(settings->input.autoconf_binds[i]);
}
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
bsv_movie_ctl(BSV_MOVIE_CTL_SET_FRAME_END, NULL);
autosave_unlock();
if (!settings->fastforward_ratio)
return 0;
end:
current = cpu_features_get_time_usec();
target = frame_limit_last_time +
frame_limit_minimum_time;
to_sleep_ms = (target - current) / 1000;
if (to_sleep_ms > 0)
{
*sleep_ms = (unsigned)to_sleep_ms;
/* Combat jitter a bit. */
frame_limit_last_time += frame_limit_minimum_time;
return 1;
}
frame_limit_last_time = cpu_features_get_time_usec();
return 0;
}
/**
* event_cmd_ctl:
* @cmd : Event command index.
*
* Performs program event command with index @cmd.
*
* Returns: true (1) on success, otherwise false (0).
**/
bool event_cmd_ctl(enum event_command cmd, void *data)
{
unsigned i = 0;
bool boolean = false;
settings_t *settings = config_get_ptr();
rarch_system_info_t *info = NULL;
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &info);
(void)i;
switch (cmd)
{
case EVENT_CMD_MENU_REFRESH:
#ifdef HAVE_MENU
menu_driver_ctl(RARCH_MENU_CTL_REFRESH, NULL);
#endif
break;
case EVENT_CMD_SET_PER_GAME_RESOLUTION:
#if defined(GEKKO)
{
unsigned width = 0, height = 0;
event_cmd_ctl(EVENT_CMD_VIDEO_SET_ASPECT_RATIO, NULL);
if (video_driver_get_video_output_size(&width, &height))
{
char msg[128] = {0};
video_driver_set_video_mode(width, height, true);
if (width == 0 || height == 0)
strlcpy(msg, "Resolution: DEFAULT", sizeof(msg));
else
snprintf(msg, sizeof(msg),"Resolution: %dx%d",width, height);
runloop_msg_queue_push(msg, 1, 100, true);
}
}
#endif
break;
case EVENT_CMD_LOAD_CONTENT_PERSIST:
#ifdef HAVE_DYNAMIC
event_cmd_ctl(EVENT_CMD_LOAD_CORE, NULL);
#endif
rarch_ctl(RARCH_CTL_LOAD_CONTENT, NULL);
break;
#ifdef HAVE_FFMPEG
case EVENT_CMD_LOAD_CONTENT_FFMPEG:
rarch_ctl(RARCH_CTL_LOAD_CONTENT_FFMPEG, NULL);
break;
#endif
case EVENT_CMD_LOAD_CONTENT_IMAGEVIEWER:
rarch_ctl(RARCH_CTL_LOAD_CONTENT_IMAGEVIEWER, NULL);
break;
case EVENT_CMD_LOAD_CONTENT:
{
#ifdef HAVE_DYNAMIC
event_cmd_ctl(EVENT_CMD_LOAD_CONTENT_PERSIST, NULL);
#else
char *fullpath = NULL;
runloop_ctl(RUNLOOP_CTL_GET_CONTENT_PATH, &fullpath);
runloop_ctl(RUNLOOP_CTL_SET_LIBRETRO_PATH, settings->libretro);
event_cmd_ctl(EVENT_CMD_EXEC, (void*)fullpath);
event_cmd_ctl(EVENT_CMD_QUIT, NULL);
#endif
}
break;
case EVENT_CMD_LOAD_CORE_DEINIT:
#ifdef HAVE_MENU
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_DEINIT, NULL);
#endif
break;
case EVENT_CMD_LOAD_CORE_PERSIST:
event_cmd_ctl(EVENT_CMD_LOAD_CORE_DEINIT, NULL);
{
#ifdef HAVE_MENU
bool *ptr = NULL;
struct retro_system_info *system = NULL;
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &system);
if (menu_driver_ctl(RARCH_MENU_CTL_LOAD_NO_CONTENT_GET, &ptr))
{
core_info_ctx_find_t info_find;
#if defined(HAVE_DYNAMIC)
if (!(*settings->libretro))
return false;
libretro_get_system_info(settings->libretro, system,
ptr);
#endif
info_find.path = settings->libretro;
if (!core_info_ctl(CORE_INFO_CTL_LOAD, &info_find))
return false;
}
#endif
}
break;
case EVENT_CMD_LOAD_CORE:
event_cmd_ctl(EVENT_CMD_LOAD_CORE_PERSIST, NULL);
#ifndef HAVE_DYNAMIC
event_cmd_ctl(EVENT_CMD_QUIT, NULL);
#endif
break;
case EVENT_CMD_LOAD_STATE:
/* Immutable - disallow savestate load when
* we absolutely cannot change game state. */
if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL))
return false;
#ifdef HAVE_NETPLAY
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
return false;
#endif
#ifdef HAVE_CHEEVOS
if (settings->cheevos.hardcore_mode_enable)
return false;
#endif
event_main_state(cmd);
break;
case EVENT_CMD_RESIZE_WINDOWED_SCALE:
{
unsigned idx = 0;
unsigned *window_scale = NULL;
runloop_ctl(RUNLOOP_CTL_GET_WINDOWED_SCALE, &window_scale);
if (*window_scale == 0)
return false;
settings->video.scale = *window_scale;
if (!settings->video.fullscreen)
event_cmd_ctl(EVENT_CMD_REINIT, NULL);
runloop_ctl(RUNLOOP_CTL_SET_WINDOWED_SCALE, &idx);
}
break;
case EVENT_CMD_MENU_TOGGLE:
#ifdef HAVE_MENU
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
else
rarch_ctl(RARCH_CTL_MENU_RUNNING, NULL);
#endif
break;
case EVENT_CMD_CONTROLLERS_INIT:
event_init_controllers();
break;
case EVENT_CMD_RESET:
RARCH_LOG("%s.\n", msg_hash_to_str(MSG_RESET));
runloop_msg_queue_push(msg_hash_to_str(MSG_RESET), 1, 120, true);
#ifdef HAVE_CHEEVOS
cheevos_ctl(CHEEVOS_CTL_SET_CHEATS, NULL);
#endif
core_ctl(CORE_CTL_RETRO_RESET, NULL);
break;
case EVENT_CMD_SAVE_STATE:
#ifdef HAVE_CHEEVOS
if (settings->cheevos.hardcore_mode_enable)
return false;
#endif
if (settings->savestate_auto_index)
settings->state_slot++;
event_main_state(cmd);
break;
case EVENT_CMD_SAVE_STATE_DECREMENT:
/* Slot -1 is (auto) slot. */
if (settings->state_slot >= 0)
settings->state_slot--;
break;
case EVENT_CMD_SAVE_STATE_INCREMENT:
settings->state_slot++;
break;
case EVENT_CMD_TAKE_SCREENSHOT:
if (!take_screenshot())
return false;
break;
case EVENT_CMD_UNLOAD_CORE:
runloop_ctl(RUNLOOP_CTL_PREPARE_DUMMY, NULL);
event_cmd_ctl(EVENT_CMD_LOAD_CORE_DEINIT, NULL);
break;
case EVENT_CMD_QUIT:
rarch_ctl(RARCH_CTL_QUIT, NULL);
break;
case EVENT_CMD_CHEEVOS_HARDCORE_MODE_TOGGLE:
#ifdef HAVE_CHEEVOS
cheevos_ctl(CHEEVOS_CTL_TOGGLE_HARDCORE_MODE, NULL);
#endif
break;
case EVENT_CMD_REINIT:
{
struct retro_hw_render_callback *hwr = NULL;
video_driver_ctl(RARCH_DISPLAY_CTL_HW_CONTEXT_GET, &hwr);
if (hwr->cache_context)
video_driver_ctl(
RARCH_DISPLAY_CTL_SET_VIDEO_CACHE_CONTEXT, NULL);
else
video_driver_ctl(
RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT, NULL);
video_driver_ctl(
RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT_ACK, NULL);
event_cmd_ctl(EVENT_CMD_RESET_CONTEXT, NULL);
video_driver_ctl(
RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT, NULL);
/* Poll input to avoid possibly stale data to corrupt things. */
input_driver_ctl(RARCH_INPUT_CTL_POLL, NULL);
#ifdef HAVE_MENU
menu_display_ctl(
MENU_DISPLAY_CTL_SET_FRAMEBUFFER_DIRTY_FLAG, NULL);
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
event_cmd_ctl(EVENT_CMD_VIDEO_SET_BLOCKING_STATE, NULL);
#endif
}
break;
case EVENT_CMD_CHEATS_DEINIT:
cheat_manager_state_free();
break;
case EVENT_CMD_CHEATS_INIT:
event_cmd_ctl(EVENT_CMD_CHEATS_DEINIT, NULL);
event_init_cheats();
break;
case EVENT_CMD_CHEATS_APPLY:
cheat_manager_apply_cheats();
break;
case EVENT_CMD_REWIND_DEINIT:
#ifdef HAVE_NETPLAY
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
return false;
#endif
#ifdef HAVE_CHEEVOS
if (settings->cheevos.hardcore_mode_enable)
return false;
#endif
state_manager_event_deinit();
break;
case EVENT_CMD_REWIND_INIT:
#ifdef HAVE_CHEEVOS
if (settings->cheevos.hardcore_mode_enable)
return false;
#endif
#ifdef HAVE_NETPLAY
if (!netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
#endif
init_rewind();
break;
case EVENT_CMD_REWIND_TOGGLE:
if (settings->rewind_enable)
event_cmd_ctl(EVENT_CMD_REWIND_INIT, NULL);
else
event_cmd_ctl(EVENT_CMD_REWIND_DEINIT, NULL);
break;
case EVENT_CMD_AUTOSAVE_DEINIT:
#ifdef HAVE_THREADS
autosave_event_deinit();
#endif
break;
case EVENT_CMD_AUTOSAVE_INIT:
event_cmd_ctl(EVENT_CMD_AUTOSAVE_DEINIT, NULL);
#ifdef HAVE_THREADS
autosave_event_init();
#endif
break;
case EVENT_CMD_AUTOSAVE_STATE:
event_save_auto_state();
break;
case EVENT_CMD_AUDIO_STOP:
if (!audio_driver_ctl(RARCH_AUDIO_CTL_ALIVE, NULL))
return false;
if (!audio_driver_ctl(RARCH_AUDIO_CTL_STOP, NULL))
return false;
break;
case EVENT_CMD_AUDIO_START:
if (audio_driver_ctl(RARCH_AUDIO_CTL_ALIVE, NULL))
return false;
if (!settings->audio.mute_enable &&
!audio_driver_ctl(RARCH_AUDIO_CTL_START, NULL))
{
RARCH_ERR("Failed to start audio driver. "
"Will continue without audio.\n");
audio_driver_ctl(RARCH_AUDIO_CTL_UNSET_ACTIVE, NULL);
}
break;
case EVENT_CMD_AUDIO_MUTE_TOGGLE:
{
const char *msg = !settings->audio.mute_enable ?
msg_hash_to_str(MSG_AUDIO_MUTED):
msg_hash_to_str(MSG_AUDIO_UNMUTED);
if (!audio_driver_ctl(RARCH_AUDIO_CTL_MUTE_TOGGLE, NULL))
{
RARCH_ERR("%s.\n",
msg_hash_to_str(MSG_FAILED_TO_UNMUTE_AUDIO));
return false;
}
runloop_msg_queue_push(msg, 1, 180, true);
RARCH_LOG("%s\n", msg);
}
break;
case EVENT_CMD_OVERLAY_DEINIT:
#ifdef HAVE_OVERLAY
input_overlay_free();
#endif
break;
case EVENT_CMD_OVERLAY_INIT:
event_cmd_ctl(EVENT_CMD_OVERLAY_DEINIT, NULL);
#ifdef HAVE_OVERLAY
input_overlay_init();
#endif
break;
case EVENT_CMD_OVERLAY_NEXT:
#ifdef HAVE_OVERLAY
input_overlay_next(settings->input.overlay_opacity);
#endif
break;
case EVENT_CMD_DSP_FILTER_DEINIT:
audio_driver_dsp_filter_free();
break;
case EVENT_CMD_DSP_FILTER_INIT:
event_cmd_ctl(EVENT_CMD_DSP_FILTER_DEINIT, NULL);
if (!*settings->audio.dsp_plugin)
break;
audio_driver_dsp_filter_init(settings->audio.dsp_plugin);
break;
case EVENT_CMD_GPU_RECORD_DEINIT:
video_driver_ctl(RARCH_DISPLAY_CTL_GPU_RECORD_DEINIT, NULL);
break;
case EVENT_CMD_RECORD_DEINIT:
if (!recording_deinit())
return false;
break;
case EVENT_CMD_RECORD_INIT:
event_cmd_ctl(EVENT_CMD_HISTORY_DEINIT, NULL);
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_cmd_ctl(EVENT_CMD_HISTORY_DEINIT, NULL);
if (!settings->history_list_enable)
return false;
RARCH_LOG("%s: [%s].\n",
msg_hash_to_str(MSG_LOADING_HISTORY_FILE),
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:
core_info_ctl(CORE_INFO_CTL_LIST_DEINIT, NULL);
break;
case EVENT_CMD_CORE_INFO_INIT:
event_cmd_ctl(EVENT_CMD_CORE_INFO_DEINIT, NULL);
if (*settings->libretro_directory)
core_info_ctl(CORE_INFO_CTL_LIST_INIT, NULL);
break;
case EVENT_CMD_CORE_DEINIT:
{
struct retro_hw_render_callback *hwr = NULL;
video_driver_ctl(RARCH_DISPLAY_CTL_HW_CONTEXT_GET, &hwr);
event_deinit_core(true);
if (hwr)
memset(hwr, 0, sizeof(*hwr));
break;
}
case EVENT_CMD_CORE_INIT:
if (!event_init_core(data))
return false;
break;
case EVENT_CMD_VIDEO_APPLY_STATE_CHANGES:
video_driver_ctl(RARCH_DISPLAY_CTL_APPLY_STATE_CHANGES, NULL);
break;
case EVENT_CMD_VIDEO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case EVENT_CMD_VIDEO_SET_BLOCKING_STATE:
video_driver_ctl(RARCH_DISPLAY_CTL_SET_NONBLOCK_STATE, &boolean);
break;
case EVENT_CMD_VIDEO_SET_ASPECT_RATIO:
video_driver_ctl(RARCH_DISPLAY_CTL_SET_ASPECT_RATIO, NULL);
break;
case EVENT_CMD_AUDIO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case EVENT_CMD_AUDIO_SET_BLOCKING_STATE:
audio_driver_set_nonblocking_state(boolean);
break;
case EVENT_CMD_OVERLAY_SET_SCALE_FACTOR:
#ifdef HAVE_OVERLAY
input_overlay_set_scale_factor(settings->input.overlay_scale);
#endif
break;
case EVENT_CMD_OVERLAY_SET_ALPHA_MOD:
#ifdef HAVE_OVERLAY
input_overlay_set_alpha_mod(settings->input.overlay_opacity);
#endif
break;
case EVENT_CMD_AUDIO_REINIT:
{
int flags = DRIVER_AUDIO;
driver_ctl(RARCH_DRIVER_CTL_UNINIT, &flags);
driver_ctl(RARCH_DRIVER_CTL_INIT, &flags);
}
break;
case EVENT_CMD_RESET_CONTEXT:
{
/* RARCH_DRIVER_CTL_UNINIT clears the callback struct so we
* need to make sure to keep a copy */
struct retro_hw_render_callback *hwr = NULL;
struct retro_hw_render_callback hwr_copy;
int flags = DRIVERS_CMD_ALL;
video_driver_ctl(RARCH_DISPLAY_CTL_HW_CONTEXT_GET, &hwr);
memcpy(&hwr_copy, hwr, sizeof(hwr_copy));
driver_ctl(RARCH_DRIVER_CTL_UNINIT, &flags);
memcpy(hwr, &hwr_copy, sizeof(*hwr));
driver_ctl(RARCH_DRIVER_CTL_INIT, &flags);
}
break;
case EVENT_CMD_QUIT_RETROARCH:
rarch_ctl(RARCH_CTL_FORCE_QUIT, NULL);
break;
case EVENT_CMD_SHUTDOWN:
#if defined(__linux__) && !defined(ANDROID)
runloop_msg_queue_push("Shutting down...", 1, 180, true);
rarch_ctl(RARCH_CTL_FORCE_QUIT, NULL);
system("shutdown -P now");
#endif
break;
case EVENT_CMD_REBOOT:
#if defined(__linux__) && !defined(ANDROID)
runloop_msg_queue_push("Rebooting...", 1, 180, true);
rarch_ctl(RARCH_CTL_FORCE_QUIT, NULL);
system("shutdown -r now");
#endif
break;
case EVENT_CMD_RESUME:
rarch_ctl(RARCH_CTL_MENU_RUNNING_FINISHED, NULL);
if (ui_companion_is_on_foreground())
ui_companion_driver_toggle();
break;
case EVENT_CMD_RESTART_RETROARCH:
if (!frontend_driver_set_fork(FRONTEND_FORK_RESTART))
return false;
break;
case EVENT_CMD_MENU_SAVE_CURRENT_CONFIG:
event_save_current_config();
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_ctl(RUNLOOP_CTL_IS_PAUSED, NULL))
{
RARCH_LOG("%s\n", msg_hash_to_str(MSG_PAUSED));
event_cmd_ctl(EVENT_CMD_AUDIO_STOP, NULL);
if (settings->video.black_frame_insertion)
video_driver_ctl(RARCH_DISPLAY_CTL_CACHED_FRAME_RENDER, NULL);
}
else
{
RARCH_LOG("%s\n", msg_hash_to_str(MSG_UNPAUSED));
event_cmd_ctl(EVENT_CMD_AUDIO_START, NULL);
}
break;
case EVENT_CMD_PAUSE_TOGGLE:
boolean = runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL);
boolean = !boolean;
runloop_ctl(RUNLOOP_CTL_SET_PAUSED, &boolean);
event_cmd_ctl(EVENT_CMD_PAUSE_CHECKS, NULL);
break;
case EVENT_CMD_UNPAUSE:
boolean = false;
runloop_ctl(RUNLOOP_CTL_SET_PAUSED, &boolean);
event_cmd_ctl(EVENT_CMD_PAUSE_CHECKS, NULL);
break;
case EVENT_CMD_PAUSE:
boolean = true;
runloop_ctl(RUNLOOP_CTL_SET_PAUSED, &boolean);
event_cmd_ctl(EVENT_CMD_PAUSE_CHECKS, NULL);
break;
case EVENT_CMD_MENU_PAUSE_LIBRETRO:
#ifdef HAVE_MENU
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
if (settings->menu.pause_libretro)
event_cmd_ctl(EVENT_CMD_AUDIO_STOP, NULL);
else
event_cmd_ctl(EVENT_CMD_AUDIO_START, NULL);
}
else
{
if (settings->menu.pause_libretro)
event_cmd_ctl(EVENT_CMD_AUDIO_START, NULL);
}
#endif
break;
case EVENT_CMD_SHADER_DIR_DEINIT:
runloop_ctl(RUNLOOP_CTL_SHADER_DIR_DEINIT, NULL);
break;
case EVENT_CMD_SHADER_DIR_INIT:
event_cmd_ctl(EVENT_CMD_SHADER_DIR_DEINIT, NULL);
if (!runloop_ctl(RUNLOOP_CTL_SHADER_DIR_INIT, NULL))
return false;
break;
case EVENT_CMD_SAVEFILES:
{
global_t *global = global_get_ptr();
if (!global->savefiles || !global->sram.use)
return false;
for (i = 0; i < global->savefiles->size; i++)
{
ram_type_t ram;
ram.type = global->savefiles->elems[i].attr.i;
ram.path = global->savefiles->elems[i].data;
RARCH_LOG("%s #%u %s \"%s\".\n",
msg_hash_to_str(MSG_SAVING_RAM_TYPE),
ram.type,
msg_hash_to_str(MSG_TO),
ram.path);
content_ctl(CONTENT_CTL_SAVE_RAM_FILE, &ram);
}
}
return true;
case EVENT_CMD_SAVEFILES_DEINIT:
{
global_t *global = global_get_ptr();
if (!global)
break;
if (global->savefiles)
string_list_free(global->savefiles);
global->savefiles = NULL;
}
break;
case EVENT_CMD_SAVEFILES_INIT:
{
global_t *global = global_get_ptr();
global->sram.use = global->sram.use && !global->sram.save_disable;
#ifdef HAVE_NETPLAY
global->sram.use = global->sram.use &&
(!netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL)
|| !global->netplay.is_client);
#endif
if (!global->sram.use)
RARCH_LOG("%s\n",
msg_hash_to_str(MSG_SRAM_WILL_NOT_BE_SAVED));
if (global->sram.use)
event_cmd_ctl(EVENT_CMD_AUTOSAVE_INIT, NULL);
}
break;
case EVENT_CMD_BSV_MOVIE_DEINIT:
bsv_movie_ctl(BSV_MOVIE_CTL_DEINIT, NULL);
break;
case EVENT_CMD_BSV_MOVIE_INIT:
event_cmd_ctl(EVENT_CMD_BSV_MOVIE_DEINIT, NULL);
bsv_movie_ctl(BSV_MOVIE_CTL_INIT, NULL);
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_cmd_ctl(EVENT_CMD_NETPLAY_DEINIT, NULL);
#ifdef HAVE_NETPLAY
if (!init_netplay())
return false;
#endif
break;
case EVENT_CMD_NETPLAY_FLIP_PLAYERS:
#ifdef HAVE_NETPLAY
netplay_driver_ctl(RARCH_NETPLAY_CTL_FLIP_PLAYERS, NULL);
#endif
break;
case EVENT_CMD_FULLSCREEN_TOGGLE:
if (!video_driver_ctl(RARCH_DISPLAY_CTL_HAS_WINDOWED, NULL))
return false;
/* If we go fullscreen we drop all drivers and
* reinitialize to be safe. */
settings->video.fullscreen = !settings->video.fullscreen;
event_cmd_ctl(EVENT_CMD_REINIT, NULL);
break;
case EVENT_CMD_COMMAND_DEINIT:
input_driver_ctl(RARCH_INPUT_CTL_COMMAND_DEINIT, NULL);
break;
case EVENT_CMD_COMMAND_INIT:
event_cmd_ctl(EVENT_CMD_COMMAND_DEINIT, NULL);
input_driver_ctl(RARCH_INPUT_CTL_COMMAND_INIT, NULL);
break;
case EVENT_CMD_REMOTE_DEINIT:
input_driver_ctl(RARCH_INPUT_CTL_REMOTE_DEINIT, NULL);
break;
case EVENT_CMD_REMOTE_INIT:
event_cmd_ctl(EVENT_CMD_REMOTE_DEINIT, NULL);
input_driver_ctl(RARCH_INPUT_CTL_REMOTE_INIT, NULL);
break;
case EVENT_CMD_TEMPORARY_CONTENT_DEINIT:
content_ctl(CONTENT_CTL_DEINIT, NULL);
break;
case EVENT_CMD_SUBSYSTEM_FULLPATHS_DEINIT:
{
global_t *global = global_get_ptr();
if (!global)
break;
if (global->subsystem_fullpaths)
string_list_free(global->subsystem_fullpaths);
global->subsystem_fullpaths = NULL;
}
break;
case EVENT_CMD_LOG_FILE_DEINIT:
retro_main_log_file_deinit();
break;
case EVENT_CMD_DISK_APPEND_IMAGE:
{
const char *path = (const char*)data;
if (string_is_empty(path))
return false;
return event_disk_control_append_image(path);
}
case EVENT_CMD_DISK_EJECT_TOGGLE:
if (info && info->disk_control_cb.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&info->disk_control_cb;
if (control)
{
bool new_state = !control->get_eject_state();
event_disk_control_set_eject(new_state, true);
}
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true);
break;
case EVENT_CMD_DISK_NEXT:
if (info && info->disk_control_cb.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&info->disk_control_cb;
if (!control)
return false;
if (!control->get_eject_state())
return false;
event_check_disk_next(control);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_DOES_NOT_SUPPORT_DISK_OPTIONS),
1, 120, true);
break;
case EVENT_CMD_DISK_PREV:
if (info && info->disk_control_cb.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&info->disk_control_cb;
if (!control)
return false;
if (!control->get_eject_state())
return false;
event_check_disk_prev(control);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_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:
{
bool ret = false;
static bool grab_mouse_state = false;
grab_mouse_state = !grab_mouse_state;
if (grab_mouse_state)
ret = input_driver_ctl(RARCH_INPUT_CTL_GRAB_MOUSE, NULL);
else
ret = input_driver_ctl(RARCH_INPUT_CTL_UNGRAB_MOUSE, NULL);
if (!ret)
return false;
RARCH_LOG("%s: %s.\n",
msg_hash_to_str(MSG_GRAB_MOUSE_STATE),
grab_mouse_state ? "yes" : "no");
if (grab_mouse_state)
video_driver_ctl(RARCH_DISPLAY_CTL_HIDE_MOUSE, NULL);
else
video_driver_ctl(RARCH_DISPLAY_CTL_SHOW_MOUSE, NULL);
}
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_SET_FRAME_LIMIT:
runloop_ctl(RUNLOOP_CTL_SET_FRAME_LIMIT, NULL);
break;
case EVENT_CMD_EXEC:
return event_cmd_exec(data);
case EVENT_CMD_NONE:
default:
return false;
}
return true;
}
