static bool take_screenshot_choice(const char *name_base, bool savestate,
bool is_paused, bool is_idle, bool has_valid_framebuffer)
{
size_t old_pitch;
unsigned old_width, old_height;
bool ret = false;
void *frame_data = NULL;
const void* old_data = NULL;
settings_t *settings = config_get_ptr();
const char *screenshot_dir = settings->paths.directory_screenshot;
/* No way to infer screenshot directory. */
if ( string_is_empty(screenshot_dir)
&& string_is_empty(name_base))
return false;
if (video_driver_supports_viewport_read())
{
/* Avoid taking screenshot of GUI overlays. */
video_driver_set_texture_enable(false, false);
if (!is_idle)
video_driver_cached_frame();
#if defined(VITA)
return take_screenshot_raw(name_base, NULL, savestate, is_idle, is_paused);
#else
return take_screenshot_viewport(name_base, savestate, is_idle, is_paused);
#endif
}
if (!has_valid_framebuffer)
return take_screenshot_raw(name_base, NULL, savestate, is_idle, is_paused);
if (!video_driver_supports_read_frame_raw())
return false;
video_driver_cached_frame_get(&old_data, &old_width, &old_height,
&old_pitch);
frame_data = video_driver_read_frame_raw(
&old_width, &old_height, &old_pitch);
video_driver_cached_frame_set(old_data, old_width, old_height,
old_pitch);
if (frame_data)
{
video_driver_set_cached_frame_ptr(frame_data);
if (take_screenshot_raw(name_base, frame_data, savestate, is_idle, is_paused))
ret = true;
}
return ret;
}
static bool take_screenshot_choice(const char *global_name_base)
{
settings_t *settings = config_get_ptr();
/* No way to infer screenshot directory. */
if (string_is_empty(settings->directory.screenshot) && (!*global_name_base))
return false;
if (video_driver_supports_viewport_read())
{
/* Avoid taking screenshot of GUI overlays. */
video_driver_set_texture_enable(false, false);
video_driver_cached_frame_render();
return take_screenshot_viewport(global_name_base);
}
if (!video_driver_cached_frame_has_valid_framebuffer())
return take_screenshot_raw(global_name_base);
if (video_driver_supports_read_frame_raw())
{
unsigned old_width, old_height;
size_t old_pitch;
bool ret = false;
void *frame_data = NULL;
const void* old_data = NULL;
video_driver_cached_frame_get(&old_data, &old_width, &old_height,
&old_pitch);
frame_data = video_driver_read_frame_raw(
&old_width, &old_height, &old_pitch);
video_driver_cached_frame_set(old_data, old_width, old_height,
old_pitch);
if (frame_data)
{
video_driver_set_cached_frame_ptr(frame_data);
if (take_screenshot_raw(global_name_base))
ret = true;
free(frame_data);
}
return ret;
}
return false;
}
bool menu_display_libretro(void)
{
video_driver_set_texture_enable(true, false);
if (menu_display_libretro_running())
{
if (!input_driver_is_libretro_input_blocked())
input_driver_set_libretro_input_blocked();
core_run();
input_driver_unset_libretro_input_blocked();
return true;
}
return video_driver_cached_frame_render();
}
/**
** menu_display_fb:
*
* Draws menu graphics onscreen.
**/
void menu_display_fb(void)
{
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
video_driver_set_texture_enable(true, false);
if (!settings->menu.pause_libretro)
{
if (global->main_is_init && !global->libretro_dummy)
{
bool block_libretro_input = driver->block_libretro_input;
driver->block_libretro_input = true;
pretro_run();
driver->block_libretro_input = block_libretro_input;
return;
}
}
rarch_render_cached_frame();
}
void rarch_main_set_state(unsigned cmd)
{
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
switch (cmd)
{
case RARCH_ACTION_STATE_MENU_RUNNING:
#ifdef HAVE_MENU
{
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return;
menu_driver_toggle(true);
/* 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 = global->system.key_event;
global->system.key_event = menu_input_key_event;
global->system.frame_time_last = 0;
}
menu_set_refresh();
menu_driver_set_alive();
}
#endif
break;
case RARCH_ACTION_STATE_LOAD_CONTENT:
#ifdef HAVE_MENU
/* If content loading fails, we go back to menu. */
if (!menu_load_content())
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING);
#endif
if (driver->frontend_ctx && driver->frontend_ctx->content_loaded)
driver->frontend_ctx->content_loaded();
break;
case RARCH_ACTION_STATE_MENU_RUNNING_FINISHED:
#ifdef HAVE_MENU
menu_setting_apply_deferred();
menu_driver_toggle(false);
menu_driver_unset_alive();
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)
global->system.key_event = global->frontend_key_event;
#endif
video_driver_set_texture_enable(false, false);
break;
case RARCH_ACTION_STATE_QUIT:
if (global)
global->system.shutdown = true;
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
break;
case RARCH_ACTION_STATE_FORCE_QUIT:
if (global)
global->lifecycle_state = 0;
rarch_main_set_state(RARCH_ACTION_STATE_QUIT);
break;
case RARCH_ACTION_STATE_NONE:
default:
break;
}
}
bool rarch_ctl(enum rarch_ctl_state state, void *data)
{
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
switch(state)
{
case RARCH_ACTION_STATE_REPLACE_CONFIG:
{
char *path = (char*)data;
if (!path)
return false;
/* If config file to be replaced is the same as the
* current config file, exit. */
if (!strcmp(path, global->path.config))
return false;
if (settings->config_save_on_exit && *global->path.config)
config_save_file(global->path.config);
strlcpy(global->path.config, path, sizeof(global->path.config));
global->block_config_read = false;
*settings->libretro = '\0'; /* Load core in new config. */
}
event_command(EVENT_CMD_PREPARE_DUMMY);
return true;
case RARCH_ACTION_STATE_MENU_RUNNING:
#ifdef HAVE_MENU
menu_driver_toggle(true);
#endif
#ifdef HAVE_OVERLAY
if (settings->input.overlay_hide_in_menu)
event_command(EVENT_CMD_OVERLAY_DEINIT);
#endif
break;
case RARCH_ACTION_STATE_LOAD_CONTENT:
#ifdef HAVE_MENU
/* If content loading fails, we go back to menu. */
if (!menu_load_content(CORE_TYPE_PLAIN))
rarch_ctl(RARCH_ACTION_STATE_MENU_RUNNING, NULL);
#endif
if (driver->frontend_ctx && driver->frontend_ctx->content_loaded)
driver->frontend_ctx->content_loaded();
break;
#ifdef HAVE_FFMPEG
case RARCH_ACTION_STATE_LOAD_CONTENT_FFMPEG:
#ifdef HAVE_MENU
/* If content loading fails, we go back to menu. */
if (!menu_load_content(CORE_TYPE_FFMPEG))
rarch_ctl(RARCH_ACTION_STATE_MENU_RUNNING, NULL);
#endif
if (driver->frontend_ctx && driver->frontend_ctx->content_loaded)
driver->frontend_ctx->content_loaded();
break;
#endif
case RARCH_ACTION_STATE_LOAD_CONTENT_IMAGEVIEWER:
#ifdef HAVE_MENU
/* If content loading fails, we go back to menu. */
if (!menu_load_content(CORE_TYPE_IMAGEVIEWER))
rarch_ctl(RARCH_ACTION_STATE_MENU_RUNNING, NULL);
#endif
if (driver->frontend_ctx && driver->frontend_ctx->content_loaded)
driver->frontend_ctx->content_loaded();
break;
case RARCH_ACTION_STATE_MENU_RUNNING_FINISHED:
#ifdef HAVE_MENU
menu_driver_toggle(false);
#endif
video_driver_set_texture_enable(false, false);
#ifdef HAVE_OVERLAY
if (settings && settings->input.overlay_hide_in_menu)
event_command(EVENT_CMD_OVERLAY_INIT);
#endif
break;
case RARCH_ACTION_STATE_QUIT:
if (global)
system->shutdown = true;
rarch_ctl(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED, NULL);
break;
case RARCH_ACTION_STATE_FORCE_QUIT:
rarch_ctl(RARCH_ACTION_STATE_QUIT, NULL);
break;
case RARCH_ACTION_STATE_VALIDATE_CPU_FEATURES:
{
uint64_t cpu = retro_get_cpu_features();
(void)cpu;
#ifdef __SSE__
if (!(cpu & RETRO_SIMD_SSE))
FAIL_CPU("SSE");
#endif
#ifdef __SSE2__
if (!(cpu & RETRO_SIMD_SSE2))
FAIL_CPU("SSE2");
#endif
#ifdef __AVX__
if (!(cpu & RETRO_SIMD_AVX))
FAIL_CPU("AVX");
#endif
}
break;
case RARCH_ACTION_STATE_VERIFY_API_VERSION:
RARCH_LOG("Version of libretro API: %u\n", core.retro_api_version());
RARCH_LOG("Compiled against API: %u\n", RETRO_API_VERSION);
if (core.retro_api_version() != RETRO_API_VERSION)
RARCH_WARN("%s\n", msg_hash_to_str(MSG_LIBRETRO_ABI_BREAK));
break;
case RARCH_ACTION_STATE_FILL_PATHNAMES:
rarch_init_savefile_paths();
strlcpy(global->bsv.movie_path, global->name.savefile,
sizeof(global->bsv.movie_path));
if (!*global->name.base)
return false;
if (!*global->name.ups)
fill_pathname_noext(global->name.ups, global->name.base, ".ups",
sizeof(global->name.ups));
if (!*global->name.bps)
fill_pathname_noext(global->name.bps, global->name.base, ".bps",
sizeof(global->name.bps));
if (!*global->name.ips)
fill_pathname_noext(global->name.ips, global->name.base, ".ips",
sizeof(global->name.ips));
break;
case RARCH_ACTION_STATE_NONE:
default:
return false;
}
return true;
}
bool menu_display_ctl(enum menu_display_ctl_state state, void *data)
{
unsigned width, height;
menu_framebuf_t *frame_buf = menu_display_fb_get_ptr();
menu_display_t *disp = menu_display_get_ptr();
settings_t *settings = config_get_ptr();
switch (state)
{
case MENU_DISPLAY_CTL_FONT_BUF:
{
void **ptr = (void**)data;
if (!ptr)
return false;
*ptr = disp->font.buf;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_BUF:
{
void **ptr = (void**)data;
if (!ptr)
return false;
disp->font.buf = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FONT_FB:
{
uint8_t **ptr = (uint8_t**)data;
if (!ptr)
return false;
*ptr = (uint8_t*)disp->font.framebuf;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_FB:
{
uint8_t **ptr = (uint8_t**)data;
if (!ptr)
return false;
disp->font.framebuf = *ptr;
}
return true;
case MENU_DISPLAY_CTL_LIBRETRO_RUNNING:
{
global_t *global = global_get_ptr();
if (!settings->menu.pause_libretro)
if (global->inited.main && (global->inited.core.type != CORE_TYPE_DUMMY))
return true;
}
break;
case MENU_DISPLAY_CTL_LIBRETRO:
video_driver_set_texture_enable(true, false);
if (menu_display_ctl(MENU_DISPLAY_CTL_LIBRETRO_RUNNING, NULL))
{
driver_t *driver = driver_get_ptr();
bool block_libretro_input = driver->block_libretro_input;
driver->block_libretro_input = true;
core.retro_run();
driver->block_libretro_input = block_libretro_input;
return true;
}
video_driver_cached_frame();
return true;
case MENU_DISPLAY_CTL_SET_WIDTH:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
frame_buf->width = *ptr;
}
return true;
case MENU_DISPLAY_CTL_WIDTH:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = frame_buf->width;
}
return true;
case MENU_DISPLAY_CTL_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = frame_buf->height;
}
return true;
case MENU_DISPLAY_CTL_HEADER_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = disp->header_height;
}
return true;
case MENU_DISPLAY_CTL_SET_HEADER_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
disp->header_height = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FONT_SIZE:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
*ptr = disp->font.size;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_SIZE:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
disp->font.size = *ptr;
}
return true;
case MENU_DISPLAY_CTL_SET_HEIGHT:
{
unsigned *ptr = (unsigned*)data;
if (!ptr)
return false;
frame_buf->height = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FB_DATA:
{
uint16_t **ptr = (uint16_t**)data;
if (!ptr)
return false;
*ptr = frame_buf->data;
}
return true;
case MENU_DISPLAY_CTL_SET_FB_DATA:
{
uint16_t *ptr = (uint16_t*)data;
if (!ptr)
return false;
frame_buf->data = ptr;
}
return true;
case MENU_DISPLAY_CTL_FB_PITCH:
{
size_t *ptr = (size_t*)data;
if (!ptr)
return false;
*ptr = frame_buf->pitch;
}
return true;
case MENU_DISPLAY_CTL_SET_FB_PITCH:
{
size_t *ptr = (size_t*)data;
if (!ptr)
return false;
frame_buf->pitch = *ptr;
}
return true;
case MENU_DISPLAY_CTL_MSG_FORCE:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
*ptr = disp->msg_force;
}
return true;
case MENU_DISPLAY_CTL_SET_MSG_FORCE:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
disp->msg_force = *ptr;
}
return true;
case MENU_DISPLAY_CTL_FONT_DATA_INIT:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
*ptr = disp->font.alloc_framebuf;
}
return true;
case MENU_DISPLAY_CTL_SET_FONT_DATA_INIT:
{
bool *ptr = (bool*)data;
if (!ptr)
return false;
disp->font.alloc_framebuf = *ptr;
}
return true;
case MENU_DISPLAY_CTL_UPDATE_PENDING:
{
bool ptr;
menu_display_ctl(MENU_DISPLAY_CTL_GET_FRAMEBUFFER_DIRTY_FLAG, &ptr);
if (menu_animation_ctl(MENU_ANIMATION_CTL_IS_ACTIVE, NULL) || ptr)
return true;
}
return false;
case MENU_DISPLAY_CTL_SET_VIEWPORT:
video_driver_get_size(&width, &height);
video_driver_set_viewport(width,
height, true, false);
return true;
case MENU_DISPLAY_CTL_UNSET_VIEWPORT:
video_driver_get_size(&width, &height);
video_driver_set_viewport(width,
height, false, true);
return true;
case MENU_DISPLAY_CTL_GET_FRAMEBUFFER_DIRTY_FLAG:
{
bool *ptr = (bool*)data;
if (!ptr || !frame_buf)
return false;
*ptr = frame_buf->dirty;
}
return true;
case MENU_DISPLAY_CTL_SET_FRAMEBUFFER_DIRTY_FLAG:
if (frame_buf && frame_buf->data)
frame_buf->dirty = true;
return true;
case MENU_DISPLAY_CTL_UNSET_FRAMEBUFFER_DIRTY_FLAG:
if (frame_buf && frame_buf->data)
frame_buf->dirty = false;
return true;
case MENU_DISPLAY_CTL_GET_DPI:
{
float *dpi = (float*)data;
*dpi = menu_dpi_override_value;
if (!settings)
return true;
if (settings->menu.dpi.override_enable)
*dpi = settings->menu.dpi.override_value;
else if (!gfx_ctx_get_metrics(DISPLAY_METRIC_DPI, dpi))
*dpi = menu_dpi_override_value;
}
return true;
}
return false;
}
