static void history_playlist_push(content_playlist_t *playlist,
const char *path, const char *core_path,
struct retro_system_info *info)
{
char tmp[PATH_MAX_LENGTH] = {0};
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (!playlist || (global->core_type == CORE_TYPE_DUMMY) || !info)
return;
/* Path can be relative here.
* Ensure we're pushing absolute path. */
strlcpy(tmp, path, sizeof(tmp));
if (*tmp)
path_resolve_realpath(tmp, sizeof(tmp));
if (system->no_content || *tmp)
content_playlist_push(playlist,
*tmp ? tmp : NULL,
NULL,
core_path,
info->library_name,
NULL,
NULL);
}
static void callback_sysutil_exit(uint64_t status,
uint64_t param, void *userdata)
{
(void)param;
(void)userdata;
(void)status;
#ifndef IS_SALAMANDER
switch (status)
{
case CELL_SYSUTIL_REQUEST_EXITGAME:
{
frontend_ctx_driver_t *frontend = frontend_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (system)
system->shutdown = true;
if (frontend)
frontend->shutdown = frontend_ps3_shutdown;
}
break;
}
#endif
}
void init_camera(void)
{
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
/* Resource leaks will follow if camera is initialized twice. */
if (driver->camera_data)
return;
find_camera_driver();
driver->camera_data = driver->camera->init(
*settings->camera.device ? settings->camera.device : NULL,
system->camera_callback.caps,
settings->camera.width ?
settings->camera.width : system->camera_callback.width,
settings->camera.height ?
settings->camera.height : system->camera_callback.height);
if (!driver->camera_data)
{
RARCH_ERR("Failed to initialize camera driver. Will continue without camera.\n");
driver->camera_active = false;
}
if (system->camera_callback.initialized)
system->camera_callback.initialized();
}
/**
* main_exit_save_config:
*
* Saves configuration file to disk, and (optionally)
* autosave state.
**/
void main_exit_save_config(void)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *info = rarch_system_info_get_ptr();
if (settings->config_save_on_exit && *global->config_path)
{
/* restore original paths in case per-core organization is enabled */
if (settings->sort_savefiles_enable && orig_savefile_dir[0] != '\0')
strlcpy(global->savefile_dir,orig_savefile_dir,sizeof(global->savefile_dir));
if (settings->sort_savestates_enable && orig_savestate_dir[0] != '\0')
strlcpy(global->savestate_dir,orig_savestate_dir,sizeof(global->savestate_dir));
/* restore system directory if it was set to <content dir> */
if(settings->system_in_content_dir && !strcmp(info->info.library_name,"No Core"))
settings->system_directory[0] = '\0';
/* Save last core-specific config to the default config location,
* needed on consoles for core switching and reusing last good
* config for new cores.
*/
config_save_file(global->config_path);
/* Flush out the core specific config. */
if (*global->core_specific_config_path &&
settings->core_specific_config)
config_save_file(global->core_specific_config_path);
}
event_command(EVENT_CMD_AUTOSAVE_STATE);
}
/**
* implementation_magic_value:
*
* Not really a hash, but should be enough to differentiate
* implementations from each other.
*
* Subtle differences in the implementation will not be possible to spot.
* The alternative would have been checking serialization sizes, but it
* was troublesome for cross platform compat.
**/
static uint32_t implementation_magic_value(void)
{
size_t i, len;
uint32_t res = 0;
const char *ver = PACKAGE_VERSION;
unsigned api = core.retro_api_version();
rarch_system_info_t *info = rarch_system_info_get_ptr();
const char *lib = info ? info->info.library_name : NULL;
res |= api;
len = strlen(lib);
for (i = 0; i < len; i++)
res ^= lib[i] << (i & 0xf);
lib = info->info.library_version;
len = strlen(lib);
for (i = 0; i < len; i++)
res ^= lib[i] << (i & 0xf);
len = strlen(ver);
for (i = 0; i < len; i++)
res ^= ver[i] << ((i & 0xf) + 16);
return res;
}
/* Sets 's' to the name of the current core
* (shown at the top of the UI). */
int menu_entries_get_core_title(char *s, size_t len)
{
const char *core_name = NULL;
const char *core_version = NULL;
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
rarch_system_info_t *info = rarch_system_info_get_ptr();
if (!settings->menu.core_enable)
return -1;
if (global)
{
core_name = global->menu.info.library_name;
core_version = global->menu.info.library_version;
}
if (!core_name || core_name[0] == '\0')
core_name = info->info.library_name;
if (!core_name || core_name[0] == '\0')
core_name = menu_hash_to_str(MENU_VALUE_NO_CORE);
if (!core_version)
core_version = info->info.library_version;
if (!core_version)
core_version = "";
snprintf(s, len, "%s - %s %s", PACKAGE_VERSION,
core_name, core_version);
return 0;
}
/**
* event_disk_control_set_eject:
* @new_state : Eject or close the virtual drive tray.
* false (0) : Close
* true (1) : Eject
* @print_log : Show message onscreen.
*
* Ejects/closes of the virtual drive tray.
**/
static void event_disk_control_set_eject(bool new_state, bool print_log)
{
char msg[PATH_MAX_LENGTH] = {0};
bool error = false;
rarch_system_info_t *info = rarch_system_info_get_ptr();
const struct retro_disk_control_callback *control =
info ? (const struct retro_disk_control_callback*)&info->disk_control : NULL;
if (!control || !control->get_num_images)
return;
*msg = '\0';
if (control->set_eject_state(new_state))
snprintf(msg, sizeof(msg), "%s virtual disk tray.",
new_state ? "Ejected" : "Closed");
else
{
error = true;
snprintf(msg, sizeof(msg), "Failed to %s virtual disk tray.",
new_state ? "eject" : "close");
}
if (*msg)
{
if (error)
RARCH_ERR("%s\n", msg);
else
RARCH_LOG("%s\n", msg);
/* Only noise in menu. */
if (print_log)
rarch_main_msg_queue_push(msg, 1, 180, true);
}
}
/**
* driver_camera_poll:
*
* Call camera driver's poll function.
* Used by RETRO_ENVIRONMENT_GET_CAMERA_INTERFACE.
*
* Returns: true (1) if successful, otherwise false (0).
**/
void driver_camera_poll(void)
{
driver_t *driver = driver_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (driver->camera && driver->camera->poll && driver->camera_data)
driver->camera->poll(driver->camera_data,
system->camera_callback.frame_raw_framebuffer,
system->camera_callback.frame_opengl_texture);
}
/**
* event_init_controllers:
*
* Initialize libretro controllers.
**/
static void event_init_controllers(void)
{
unsigned i;
settings_t *settings = config_get_ptr();
rarch_system_info_t *info = rarch_system_info_get_ptr();
for (i = 0; i < MAX_USERS; i++)
{
const char *ident = NULL;
const struct retro_controller_description *desc = NULL;
unsigned device = settings->input.libretro_device[i];
if (i < info->num_ports)
desc = libretro_find_controller_description(
&info->ports[i], device);
if (desc)
ident = desc->desc;
if (!ident)
{
/* If we're trying to connect a completely unknown device,
* revert back to JOYPAD. */
if (device != RETRO_DEVICE_JOYPAD && device != RETRO_DEVICE_NONE)
{
/* Do not fix settings->input.libretro_device[i],
* because any use of dummy core will reset this,
* which is not a good idea. */
RARCH_WARN("Input device ID %u is unknown to this libretro implementation. Using RETRO_DEVICE_JOYPAD.\n", device);
device = RETRO_DEVICE_JOYPAD;
}
ident = "Joypad";
}
switch (device)
{
case RETRO_DEVICE_NONE:
RARCH_LOG("Disconnecting device from port %u.\n", i + 1);
pretro_set_controller_port_device(i, device);
break;
case RETRO_DEVICE_JOYPAD:
break;
default:
/* Some cores do not properly range check port argument.
* This is broken behavior of course, but avoid breaking
* cores needlessly. */
RARCH_LOG("Connecting %s (ID: %u) to port %u.\n", ident,
device, i + 1);
pretro_set_controller_port_device(i, device);
break;
}
}
}
static void menu_driver_toggle(bool latch)
{
const menu_ctx_driver_t *menu_driver = menu_ctx_driver_get_ptr();
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (menu_driver->toggle)
menu_driver->toggle(latch);
if (latch)
menu_driver_ctl(RARCH_MENU_CTL_SET_ALIVE, NULL);
else
menu_driver_ctl(RARCH_MENU_CTL_UNSET_ALIVE, NULL);
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL))
{
menu_entries_set_refresh(false);
/* Menu should always run with vsync on. */
event_command(EVENT_CMD_VIDEO_SET_BLOCKING_STATE);
/* Stop all rumbling before entering the menu. */
event_command(EVENT_CMD_RUMBLE_STOP);
if (settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_STOP);
/* Override keyboard callback to redirect to menu instead.
* We'll use this later for something ...
* FIXME: This should probably be moved to menu_common somehow. */
if (global)
{
global->frontend_key_event = system->key_event;
system->key_event = menu_input_key_event;
runloop_ctl(RUNLOOP_CTL_SET_FRAME_TIME_LAST, NULL);
}
}
else
{
if (!runloop_ctl(RUNLOOP_CTL_IS_SHUTDOWN, NULL))
driver_set_nonblock_state();
if (settings && settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_START);
/* Prevent stray input from going to libretro core */
input_driver_ctl(RARCH_INPUT_CTL_SET_FLUSHING_INPUT, NULL);
/* Restore libretro keyboard callback. */
if (global)
system->key_event = global->frontend_key_event;
}
}
static int playlist_association_left(unsigned type, const char *label,
bool wraparound)
{
unsigned idx = type - MENU_SETTINGS_PLAYLIST_ASSOCIATION_START;
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)idx;
(void)system;
return 0;
}
static int core_setting_left(unsigned type, const char *label,
bool wraparound)
{
unsigned idx = type - MENU_SETTINGS_CORE_OPTION_START;
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)label;
core_option_prev(system->core_options, idx);
return 0;
}
static void qnx_handle_navigator_event(
qnx_input_t *qnx, bps_event_t *event)
{
int rc;
navigator_window_state_t state;
bps_event_t *event_pause = NULL;
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)rc;
switch (bps_event_get_code(event))
{
case NAVIGATOR_SWIPE_DOWN:
qnx->lifecycle_state ^= (UINT64_C(1) << RARCH_MENU_TOGGLE);
break;
case NAVIGATOR_EXIT:
/* Catch this in thumbnail loop. */
break;
case NAVIGATOR_WINDOW_STATE:
state = navigator_event_get_window_state(event);
switch(state)
{
case NAVIGATOR_WINDOW_THUMBNAIL:
for(;;)
{
/* Block until we get a resume or exit event. */
rc = bps_get_event(&event_pause, -1);
if(bps_event_get_code(event_pause) == NAVIGATOR_WINDOW_STATE)
{
state = navigator_event_get_window_state(event_pause);
if(state == NAVIGATOR_WINDOW_FULLSCREEN)
break;
}
else if (bps_event_get_code(event_pause) == NAVIGATOR_EXIT)
{
system->shutdown = true;
break;
}
}
break;
case NAVIGATOR_WINDOW_FULLSCREEN:
break;
case NAVIGATOR_WINDOW_INVISIBLE:
break;
}
break;
default:
break;
}
}
static int action_start_core_setting(unsigned type,
const char *label)
{
unsigned idx = type - MENU_SETTINGS_CORE_OPTION_START;
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)label;
if (system)
core_option_set_default(system->core_options, idx);
return 0;
}
/**
* input_keyboard_event:
* @down : Keycode was pressed down?
* @code : Keycode.
* @character : Character inputted.
* @mod : TODO/FIXME: ???
*
* Keyboard event utils. Called by drivers when keyboard events are fired.
* This interfaces with the global system driver struct and libretro callbacks.
**/
void input_keyboard_event(bool down, unsigned code,
uint32_t character, uint16_t mod, unsigned device)
{
static bool deferred_wait_keys;
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (deferred_wait_keys)
{
if (down)
return;
input_keyboard_wait_keys_cancel();
deferred_wait_keys = false;
}
else if (g_keyboard_press_cb)
{
if (!down)
return;
if (code == RETROK_UNKNOWN)
return;
if (g_keyboard_press_cb(g_keyboard_press_data, code))
return;
deferred_wait_keys = true;
}
else if (g_keyboard_line)
{
if (!down)
return;
switch (device)
{
case RETRO_DEVICE_POINTER:
if (!input_keyboard_line_event(g_keyboard_line, (code != 0x12d) ? (char)code : character))
return;
break;
default:
if (!input_keyboard_line_event(g_keyboard_line, character))
return;
break;
}
/* Line is complete, can free it now. */
input_keyboard_line_free(g_keyboard_line);
g_keyboard_line = NULL;
/* Unblock all hotkeys. */
input_driver_keyboard_mapping_set_block(false);
}
else if (system->key_event)
system->key_event(down, code, character, mod);
}
/**
* rarch_game_specific_options:
* @cmd : Output variable with path to core options file.
*
* Environment callback function implementation.
*
* Returns: true (1) if a game specific core options path has been found,
* otherwise false (0).
**/
static bool rarch_game_specific_options(char **output)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
const char *core_name = NULL;
const char *game_name = NULL;
config_file_t *option_file = NULL;
char game_path[PATH_MAX_LENGTH] = {0};
char config_directory[PATH_MAX_LENGTH] = {0};
core_name = system ? system->info.library_name : NULL;
game_name = global ? path_basename(global->name.base) : NULL;
if (!core_name || !game_name)
return false;
if (core_name[0] == '\0' || game_name[0] == '\0')
return false;
RARCH_LOG("Per-Game Options: core name: %s\n", core_name);
RARCH_LOG("Per-Game Options: game name: %s\n", game_name);
/* Config directory: config_directory.
* Try config directory setting first,
* fallback to the location of the current configuration file. */
if (settings->menu_config_directory[0] != '\0')
strlcpy(config_directory, settings->menu_config_directory, PATH_MAX_LENGTH);
else if (global->path.config[0] != '\0')
fill_pathname_basedir(config_directory, global->path.config, PATH_MAX_LENGTH);
else
{
RARCH_WARN("Per-Game Options: no config directory set\n");
return false;
}
/* Concatenate strings into full paths for game_path */
fill_pathname_join(game_path, config_directory, core_name, PATH_MAX_LENGTH);
fill_pathname_join(game_path, game_path, game_name, PATH_MAX_LENGTH);
strlcat(game_path, ".opt", PATH_MAX_LENGTH);
option_file = config_file_new(game_path);
if (!option_file)
return false;
config_file_free(option_file);
RARCH_LOG("Per-Game Options: game-specific core options found at %s\n", game_path);
*output = strdup(game_path);
return true;
}
void menu_driver_toggle(bool latch)
{
driver_t *driver = driver_get_ptr();
const menu_ctx_driver_t *menu_driver = menu_ctx_driver_get_ptr();
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (menu_driver->toggle)
menu_driver->toggle(latch);
menu_alive = latch;
if (menu_alive == true)
{
menu_entries_set_refresh(false);
/* Menu should always run with vsync on. */
event_command(EVENT_CMD_VIDEO_SET_BLOCKING_STATE);
/* Stop all rumbling before entering the menu. */
event_command(EVENT_CMD_RUMBLE_STOP);
if (settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_STOP);
/* Override keyboard callback to redirect to menu instead.
* We'll use this later for something ...
* FIXME: This should probably be moved to menu_common somehow. */
if (global)
{
global->frontend_key_event = system->key_event;
system->key_event = menu_input_key_event;
system->frame_time_last = 0;
}
}
else
{
driver_set_nonblock_state(driver->nonblock_state);
if (settings && settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_START);
/* Prevent stray input from going to libretro core */
driver->flushing_input = true;
/* Restore libretro keyboard callback. */
if (global)
system->key_event = global->frontend_key_event;
}
}
void uninit_location(void)
{
driver_t *driver = driver_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (driver->location_data && driver->location)
{
if (system->location_callback.deinitialized)
system->location_callback.deinitialized();
if (driver->location->free)
driver->location->free(driver->location_data);
}
driver->location_data = NULL;
}
void uninit_camera(void)
{
driver_t *driver = driver_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (driver->camera_data && driver->camera)
{
if (system->camera_callback.deinitialized)
system->camera_callback.deinitialized();
if (driver->camera->free)
driver->camera->free(driver->camera_data);
}
driver->camera_data = NULL;
}
static void driver_adjust_system_rates(void)
{
rarch_system_info_t *system = rarch_system_info_get_ptr();
driver_t *driver = driver_get_ptr();
audio_monitor_adjust_system_rates();
video_monitor_adjust_system_rates();
if (!driver->video_data)
return;
if (system->force_nonblock)
event_command(EVENT_CMD_VIDEO_SET_NONBLOCKING_STATE);
else
driver_set_nonblock_state(driver->nonblock_state);
}
bool video_monitor_get_fps(char *buf, size_t size,
char *buf_fps, size_t size_fps)
{
static float last_fps;
retro_time_t new_time;
static retro_time_t curr_time;
static retro_time_t fps_time;
uint64_t frame_count = video_driver_get_frame_count();
rarch_system_info_t *system = rarch_system_info_get_ptr();
*buf = '\0';
new_time = rarch_get_time_usec();
if (frame_count)
{
bool ret = false;
unsigned write_index = video_state.frame_time_samples_count++ &
(MEASURE_FRAME_TIME_SAMPLES_COUNT - 1);
video_state.frame_time_samples[write_index] = new_time - fps_time;
fps_time = new_time;
if ((frame_count % FPS_UPDATE_INTERVAL) == 0)
{
last_fps = TIME_TO_FPS(curr_time, new_time, FPS_UPDATE_INTERVAL);
curr_time = new_time;
snprintf(buf, size, "%s || FPS: %6.1f || Frames: " U64_SIGN,
system->title_buf, last_fps, (unsigned long long)frame_count);
ret = true;
}
if (buf_fps)
snprintf(buf_fps, size_fps, "FPS: %6.1f || Frames: " U64_SIGN,
last_fps, (unsigned long long)frame_count);
return ret;
}
curr_time = fps_time = new_time;
strlcpy(buf, system->title_buf, size);
if (buf_fps)
strlcpy(buf_fps, "N/A", size_fps);
return true;
}
/**
* event_disk_control_set_index:
* @idx : Index of disk to set as current.
*
* Sets current disk to @index.
**/
static void event_disk_control_set_index(unsigned idx)
{
unsigned num_disks;
char msg[PATH_MAX_LENGTH] = {0};
rarch_system_info_t *info = rarch_system_info_get_ptr();
const struct retro_disk_control_callback *control =
info ? (const struct retro_disk_control_callback*)&info->disk_control : NULL;
bool error = false;
if (!control || !control->get_num_images)
return;
*msg = '\0';
num_disks = control->get_num_images();
if (control->set_image_index(idx))
{
if (idx < num_disks)
snprintf(msg, sizeof(msg), "Setting disk %u of %u in tray.",
idx + 1, num_disks);
else
strlcpy(msg,
msg_hash_to_str(MSG_REMOVED_DISK_FROM_TRAY),
sizeof(msg));
}
else
{
if (idx < num_disks)
snprintf(msg, sizeof(msg), "Failed to set disk %u of %u.",
idx + 1, num_disks);
else
strlcpy(msg,
msg_hash_to_str(MSG_FAILED_TO_REMOVE_DISK_FROM_TRAY),
sizeof(msg));
error = true;
}
if (*msg)
{
if (error)
RARCH_ERR("%s\n", msg);
else
RARCH_LOG("%s\n", msg);
rarch_main_msg_queue_push(msg, 1, 180, true);
}
}
/**
* event_disk_control_append_image:
* @path : Path to disk image.
*
* Appends disk image to disk image list.
**/
void event_disk_control_append_image(const char *path)
{
unsigned new_idx;
char msg[PATH_MAX_LENGTH] = {0};
struct retro_game_info info = {0};
global_t *global = global_get_ptr();
rarch_system_info_t *sysinfo = rarch_system_info_get_ptr();
const struct retro_disk_control_callback *control =
sysinfo ? (const struct retro_disk_control_callback*)&sysinfo->disk_control
: NULL;
if (!control)
return;
event_disk_control_set_eject(true, false);
control->add_image_index();
new_idx = control->get_num_images();
if (!new_idx)
return;
new_idx--;
info.path = path;
control->replace_image_index(new_idx, &info);
strlcpy(msg, "Appended disk: ", sizeof(msg));
strlcat(msg, path, sizeof(msg));
RARCH_LOG("%s\n", msg);
rarch_main_msg_queue_push(msg, 0, 180, true);
event_command(EVENT_CMD_AUTOSAVE_DEINIT);
/* TODO: Need to figure out what to do with subsystems case. */
if (!*global->subsystem)
{
/* Update paths for our new image.
* If we actually use append_image, we assume that we
* started out in a single disk case, and that this way
* of doing it makes the most sense. */
rarch_set_paths(path);
rarch_fill_pathnames();
}
event_command(EVENT_CMD_AUTOSAVE_INIT);
event_disk_control_set_eject(false, false);
}
static int deferred_push_default(menu_displaylist_info_t *info)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
info->type_default = MENU_FILE_PLAIN;
info->setting = menu_setting_find(info->label);
if (info->setting && info->setting->browser_selection_type == ST_DIR) {}
else if (global->menu.info.valid_extensions)
{
if (*global->menu.info.valid_extensions)
strlcpy(info->exts, global->menu.info.valid_extensions,
sizeof(info->exts));
}
else
strlcpy(info->exts, system->valid_extensions, sizeof(info->exts));
(void)settings;
if (settings->multimedia.builtin_mediaplayer_enable ||
settings->multimedia.builtin_imageviewer_enable)
{
struct retro_system_info sysinfo = {0};
(void)sysinfo;
#ifdef HAVE_FFMPEG
if (settings->multimedia.builtin_mediaplayer_enable)
{
libretro_ffmpeg_retro_get_system_info(&sysinfo);
strlcat(info->exts, "|", sizeof(info->exts));
strlcat(info->exts, sysinfo.valid_extensions, sizeof(info->exts));
}
#endif
#ifdef HAVE_IMAGEVIEWER
if (settings->multimedia.builtin_imageviewer_enable)
{
libretro_imageviewer_retro_get_system_info(&sysinfo);
strlcat(info->exts, "|", sizeof(info->exts));
strlcat(info->exts, sysinfo.valid_extensions, sizeof(info->exts));
}
#endif
}
return menu_displaylist_push_list(info, DISPLAYLIST_DEFAULT);
}
/**
* time_to_exit:
*
* rarch_main_iterate() checks this to see if it's time to
* exit out of the main loop.
*
* Reasons for exiting:
* a) Shutdown environment callback was invoked.
* b) Quit key was pressed.
* c) Frame count exceeds or equals maximum amount of frames to run.
* d) Video driver no longer alive.
* e) End of BSV movie and BSV EOF exit is true. (TODO/FIXME - explain better)
*
* Returns: 1 if any of the above conditions are true, otherwise 0.
**/
static INLINE int time_to_exit(driver_t *driver, global_t *global,
runloop_t *runloop, event_cmd_state_t *cmd)
{
const video_driver_t *video = driver ? (const video_driver_t*)driver->video : NULL;
rarch_system_info_t *system = rarch_system_info_get_ptr();
bool shutdown_pressed = system->shutdown;
bool video_alive = video->alive(driver->video_data);
bool movie_end = (global->bsv.movie_end && global->bsv.eof_exit);
uint64_t frame_count = video_driver_get_frame_count();
bool frame_count_end = (runloop->frames.video.max &&
frame_count >= runloop->frames.video.max);
if (shutdown_pressed || cmd->quit_key_pressed || frame_count_end || movie_end
|| !video_alive)
return 1;
return 0;
}
int core_setting_right(unsigned type, const char *label,
bool wraparound)
{
driver_t * driver = driver_get_ptr();
const ui_companion_driver_t *ui = ui_companion_get_ptr();
unsigned idx = type - MENU_SETTINGS_CORE_OPTION_START;
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)label;
core_option_next(system->core_options, idx);
if (ui->notify_refresh && ui_companion_is_on_foreground())
ui->notify_refresh(driver->ui_companion_data);
return 0;
}
/**
* rarch_main_load_dummy_core:
*
* Quits out of RetroArch main loop.
*
* On special case, loads dummy core
* instead of exiting RetroArch completely.
* Aborts core shutdown if invoked.
*
* Returns: -1 if we are about to quit, otherwise 0.
**/
static int rarch_main_iterate_quit(settings_t *settings, global_t *global)
{
rarch_system_info_t *system = rarch_system_info_get_ptr();
if (global->core_shutdown_initiated
&& settings->load_dummy_on_core_shutdown)
{
if (!event_command(EVENT_CMD_PREPARE_DUMMY))
return -1;
system->shutdown = false;
global->core_shutdown_initiated = false;
return 0;
}
return -1;
}
/**
* driver_set_nonblock_state:
* @enable : Enable nonblock state?
*
* Sets audio and video drivers to nonblock state.
*
* If @enable is false, sets blocking state for both
* audio and video drivers instead.
**/
void driver_set_nonblock_state(bool enable)
{
settings_t *settings = config_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
driver_t *driver = driver_get_ptr();
/* Only apply non-block-state for video if we're using vsync. */
if (driver->video_active && driver->video_data)
{
bool video_nonblock = enable;
if (!settings->video.vsync || system->force_nonblock)
video_nonblock = true;
video_driver_set_nonblock_state(video_nonblock);
}
audio_driver_set_nonblocking_state(enable);
}
static void menu_action_setting_disp_set_label(file_list_t* list,
unsigned *w, unsigned type, unsigned i,
const char *label,
char *s, size_t len,
const char *entry_label,
const char *path,
char *s2, size_t len2)
{
rarch_system_info_t *system = rarch_system_info_get_ptr();
uint32_t hash_label = menu_hash_calculate(label);
*s = '\0';
*w = 19;
switch (hash_label)
{
case MENU_LABEL_LOAD_CONTENT_HISTORY:
*w = strlen(label);
break;
case MENU_LABEL_SYSTEM_INFORMATION:
*w = 2;
break;
case MENU_LABEL_DEBUG_INFORMATION:
*w = 2;
break;
}
if (type >= MENU_SETTINGS_CORE_OPTION_START)
{
const char *core_opt = NULL;
if (!system)
return;
core_opt = core_option_get_val(system->core_options,
type - MENU_SETTINGS_CORE_OPTION_START);
strlcpy(s, core_opt ? core_opt : "", len);
}
else
setting_get_label(list, s,
len, w, type, label, entry_label, i);
strlcpy(s2, path, len2);
}
/* Time to exit out of the main loop?
* Reasons for exiting:
* a) Shutdown environment callback was invoked.
* b) Quit key was pressed.
* c) Frame count exceeds or equals maximum amount of frames to run.
* d) Video driver no longer alive.
* e) End of BSV movie and BSV EOF exit is true. (TODO/FIXME - explain better)
*/
static INLINE int rarch_main_iterate_time_to_exit(event_cmd_state_t *cmd)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
driver_t *driver = driver_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
video_driver_t *video = driver ? (video_driver_t*)driver->video : NULL;
bool shutdown_pressed = (system && system->shutdown) || cmd->quit_key_pressed;
bool video_alive = video && video->alive(driver->video_data);
bool movie_end = (global->bsv.movie_end && global->bsv.eof_exit);
uint64_t *frame_count = video_driver_get_frame_count();
bool frame_count_end = main_max_frames && (*frame_count >= main_max_frames);
if (shutdown_pressed || frame_count_end || movie_end || !video_alive || global->exec)
{
if (global->exec)
global->exec = false;
/* Quits out of RetroArch main loop.
* On special case, loads dummy core
* instead of exiting RetroArch completely.
* Aborts core shutdown if invoked.
*/
if (global->core_shutdown_initiated
&& settings->load_dummy_on_core_shutdown)
{
if (!event_command(EVENT_CMD_PREPARE_DUMMY))
return -1;
system->shutdown = false;
global->core_shutdown_initiated = false;
return 0;
}
return -1;
}
return 1;
}
