mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-28 19:20:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10679 from jdgleaver/retro-message-ext

Browse Source 
Add API extension to provide cores with finer grained control over environment callback messages
This commit is contained in:
Autechre 2020-05-26 17:39:49 +02:00 committed by GitHub
commit a62cac03e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 382 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
gfx/gfx_widgets.c
View File

@ -339,7 +339,6 @@ unsigned gfx_widgets_get_height(void)
return simple_widget_height;
}
unsigned gfx_widgets_get_generic_message_height(void)
{
return generic_message_height;
@ -355,6 +354,11 @@ unsigned gfx_widgets_get_last_video_height(void)
return last_video_height;
}
size_t gfx_widgets_get_msg_queue_size(void)
{
return current_msgs ? current_msgs->size : 0;
}
/* Widgets list */
const static gfx_widget_t* const widgets[] = {
&gfx_widget_screenshot,
@ -1500,6 +1504,7 @@ void gfx_widgets_frame(void *data)
video_frame_info_t *video_info;
bool framecount_show;
bool memory_show;
bool core_status_msg_show;
void *userdata;
unsigned video_width;
unsigned video_height;
@ -1521,6 +1526,7 @@ void gfx_widgets_frame(void *data)
video_info = (video_frame_info_t*)data;
framecount_show = video_info->framecount_show;
memory_show = video_info->memory_show;
core_status_msg_show = video_info->core_status_msg_show;
userdata = video_info->userdata;
video_width = video_info->width;
video_height = video_info->height;
@ -1705,26 +1711,11 @@ void gfx_widgets_frame(void *data)
}
#endif
/* Draw all messages */
for (i = 0; i < current_msgs->size; i++)
{
menu_widget_msg_t *msg = (menu_widget_msg_t*)current_msgs->list[i].userdata;
if (!msg)
continue;
if (msg->task_ptr)
gfx_widgets_draw_task_msg(msg, userdata,
video_width, video_height);
else
gfx_widgets_draw_regular_msg(msg, userdata,
video_width, video_height);
}
/* FPS Counter */
if ( fps_show
|| framecount_show
|| memory_show
|| core_status_msg_show
)
{
const char *text = *gfx_widgets_fps_text == '\0' ? "N/A" : gfx_widgets_fps_text;
@ -1798,6 +1789,22 @@ void gfx_widgets_frame(void *data)
widget->frame(data);
}
/* Draw all messages */
for (i = 0; i < current_msgs->size; i++)
{
menu_widget_msg_t *msg = (menu_widget_msg_t*)current_msgs->list[i].userdata;
if (!msg)
continue;
if (msg->task_ptr)
gfx_widgets_draw_task_msg(msg, userdata,
video_width, video_height);
else
gfx_widgets_draw_regular_msg(msg, userdata,
video_width, video_height);
}
#ifdef HAVE_MENU
/* Load content animation */
if (load_content_animation_running)

2
gfx/gfx_widgets.h
View File

@ -113,6 +113,8 @@ float* gfx_widgets_get_backdrop_orig(void);
unsigned gfx_widgets_get_last_video_width(void);
unsigned gfx_widgets_get_last_video_height(void);
unsigned gfx_widgets_get_generic_message_height(void);
/* Warning: not thread safe! */
size_t gfx_widgets_get_msg_queue_size(void);
float gfx_widgets_get_thumbnail_scale_factor(
const float dst_width, const float dst_height,

6
gfx/widgets/gfx_widget_generic_message.c
View File

@ -95,6 +95,7 @@ static void gfx_widget_generic_message_frame(void* data)
unsigned height = gfx_widgets_get_generic_message_height();
unsigned text_color = COLOR_TEXT_ALPHA(0xffffffff, (unsigned)(state->alpha*255.0f));
gfx_widget_font_data_t* font_regular = gfx_widgets_get_font_regular();
size_t msg_queue_size = gfx_widgets_get_msg_queue_size();
gfx_display_set_alpha(gfx_widgets_get_backdrop_orig(), state->alpha);
@ -111,6 +112,11 @@ static void gfx_widget_generic_message_frame(void* data)
video_width, video_height,
text_color, TEXT_ALIGN_CENTER,
false);
/* If the message queue is active, must flush the
* text here to avoid overlaps */
if (msg_queue_size > 0)
gfx_widgets_flush_text(video_width, video_height, font_regular);
}
}

6
gfx/widgets/gfx_widget_libretro_message.c
View File

@ -103,6 +103,7 @@ static void gfx_widget_libretro_message_frame(void *data)
float* backdrop_orign = gfx_widgets_get_backdrop_orig();
unsigned text_color = COLOR_TEXT_ALPHA(0xffffffff, (unsigned)(state->alpha*255.0f));
gfx_widget_font_data_t* font_regular = gfx_widgets_get_font_regular();
size_t msg_queue_size = gfx_widgets_get_msg_queue_size();
gfx_display_set_alpha(backdrop_orign, state->alpha);
@ -119,6 +120,11 @@ static void gfx_widget_libretro_message_frame(void *data)
video_width, video_height,
text_color, TEXT_ALIGN_LEFT,
false);
/* If the message queue is active, must flush the
* text here to avoid overlaps */
if (msg_queue_size > 0)
gfx_widgets_flush_text(video_width, video_height, font_regular);
}
}

128
libretro-common/include/libretro.h
View File

@ -1288,6 +1288,36 @@ enum retro_mod
* based systems).
*/
#define RETRO_ENVIRONMENT_GET_MESSAGE_INTERFACE_VERSION 59
/* unsigned * --
* Unsigned value is the API version number of the message
* interface supported by the frontend. If callback returns
* false, API version is assumed to be 0.
*
* In legacy code, messages may be displayed in an
* implementation-specific manner by passing a struct
* of type retro_message to RETRO_ENVIRONMENT_SET_MESSAGE.
* This may be still be done regardless of the message
* interface version.
*
* If version is >= 1 however, messages may instead be
* displayed by passing a struct of type retro_message_ext
* to RETRO_ENVIRONMENT_SET_MESSAGE_EXT. This allows the
* core to specify message logging level, priority and
* destination (OSD, logging interface or both).
*/
#define RETRO_ENVIRONMENT_SET_MESSAGE_EXT 60
/* const struct retro_message_ext * --
* Sets a message to be displayed in an implementation-specific
* manner for a certain amount of 'frames'. Additionally allows
* the core to specify message logging level, priority and
* destination (OSD, logging interface or both).
* Should not be used for trivial messages, which should simply be
* logged via RETRO_ENVIRONMENT_GET_LOG_INTERFACE (or as a
* fallback, stderr).
*/
/* VFS functionality */
/* File paths:
@ -2507,6 +2537,104 @@ struct retro_message
unsigned frames; /* Duration in frames of message. */
};
enum retro_message_target
{
RETRO_MESSAGE_TARGET_ALL = 0,
RETRO_MESSAGE_TARGET_OSD,
RETRO_MESSAGE_TARGET_LOG
};
enum retro_message_type
{
RETRO_MESSAGE_TYPE_NOTIFICATION = 0,
RETRO_MESSAGE_TYPE_NOTIFICATION_ALT,
RETRO_MESSAGE_TYPE_STATUS,
RETRO_MESSAGE_TYPE_PROGRESS
};
struct retro_message_ext
{
/* Message string to be displayed/logged */
const char *msg;
/* Duration (in ms) of message when targeting the OSD */
unsigned duration;
/* Message priority when targeting the OSD
* > When multiple concurrent messages are sent to
* the frontend and the frontend does not have the
* capacity to display them all, messages with the
* *highest* priority value should be shown
* > There is no upper limit to a message priority
* value (within the bounds of the unsigned data type)
* > In the reference frontend (RetroArch), the same
* priority values are used for frontend-generated
* notifications, which are typically assigned values
* between 0 and 3 depending upon importance */
unsigned priority;
/* Message logging level (info, warn, error, etc.) */
enum retro_log_level level;
/* Message destination: OSD, logging interface or both */
enum retro_message_target target;
/* Message 'type' when targeting the OSD
* > RETRO_MESSAGE_TYPE_NOTIFICATION: Specifies that a
* message should be handled in identical fashion to
* a standard frontend-generated notification
* > RETRO_MESSAGE_TYPE_NOTIFICATION_ALT: Specifies that
* message is a notification that requires user attention
* or action, but that it should be displayed in a manner
* that differs from standard frontend-generated notifications.
* This would typically correspond to messages that should be
* displayed immediately (independently from any internal
* frontend message queue), and/or which should be visually
* distinguishable from frontend-generated notifications.
* For example, a core may wish to inform the user of
* information related to a disk-change event. It is
* expected that the frontend itself may provide a
* notification in this case; if the core sends a
* message of type RETRO_MESSAGE_TYPE_NOTIFICATION, an
* uncomfortable 'double-notification' may occur. A message
* of RETRO_MESSAGE_TYPE_NOTIFICATION_ALT should therefore
* be presented such that visual conflict with regular
* notifications does not occur
* > RETRO_MESSAGE_TYPE_STATUS: Indicates that message
* is not a standard notification. This typically
* corresponds to 'status' indicators, such as a core's
* internal FPS, which are intended to be displayed
* either permanently while a core is running, or in
* a manner that does not suggest user attention or action
* is required. 'Status' type messages should therefore be
* displayed in a different on-screen location and in a manner
* easily distinguishable from both standard frontend-generated
* notifications and messages of type RETRO_MESSAGE_TYPE_NOTIFICATION_ALT
* > RETRO_MESSAGE_TYPE_PROGRESS: Indicates that message reports
* the progress of an internal core task. For example, in cases
* where a core itself handles the loading of content from a file,
* this may correspond to the percentage of the file that has been
* read. Alternatively, an audio/video playback core may use a
* message of type RETRO_MESSAGE_TYPE_PROGRESS to display the current
* playback position as a percentage of the runtime. 'Progress' type
* messages should therefore be displayed as a literal progress bar,
* where:
* - 'retro_message_ext.msg' is the progress bar title/label
* - 'retro_message_ext.progress' determines the length of
* the progress bar
* NOTE: Message type is a *hint*, and may be ignored
* by the frontend. If a frontend lacks support for
* displaying messages via alternate means than standard
* frontend-generated notifications, it will treat *all*
* messages as having the type RETRO_MESSAGE_TYPE_NOTIFICATION */
enum retro_message_type type;
/* Task progress when targeting the OSD and message is
* of type RETRO_MESSAGE_TYPE_PROGRESS
* > -1: Unmetered/indeterminate
* > 0-100: Current progress percentage
* NOTE: Since message type is a hint, a frontend may ignore
* progress values. Where relevant, a core should therefore
* include progress percentage within the message string,
* such that the message intent remains clear when displayed
* as a standard frontend-generated notification */
int8_t progress;
};
/* Describes how the libretro implementation maps a libretro input bind
* to its internal input system through a human readable string.
* This string can be used to better let a user configure input. */

215
retroarch.c
View File

@ -1446,6 +1446,14 @@ typedef struct runloop_ctx_msg_info
bool flush;
} runloop_ctx_msg_info_t;
typedef struct
{
char str[128];
unsigned priority;
float duration;
bool set;
} runloop_core_status_msg_t;
struct rarch_dir_list
{
struct string_list *list;
@ -1772,6 +1780,14 @@ static retro_keyboard_event_t runloop_frontend_key_event = NULL;
static core_option_manager_t *runloop_core_options = NULL;
static msg_queue_t *runloop_msg_queue = NULL;
static runloop_core_status_msg_t runloop_core_status_msg =
{
"",
0,
0.0f,
false
};
static retro_usec_t runloop_frame_time_last = 0;
#ifdef HAVE_DISCORD
@ -10158,7 +10174,38 @@ static bool rarch_clear_all_thread_waits(unsigned clear_threads, void *data)
return true;
}
static void runloop_core_msg_queue_push(const struct retro_message_ext *msg)
{
struct retro_system_av_info *av_info = &video_driver_av_info;
enum message_queue_category category;
double fps;
unsigned duration_frames;
/* Assign category */
switch (msg->level)
{
case RETRO_LOG_WARN:
category = MESSAGE_QUEUE_CATEGORY_WARNING;
break;
case RETRO_LOG_ERROR:
category = MESSAGE_QUEUE_CATEGORY_ERROR;
break;
case RETRO_LOG_INFO:
case RETRO_LOG_DEBUG:
default:
category = MESSAGE_QUEUE_CATEGORY_INFO;
break;
}
/* Get duration in frames */
fps = av_info ? av_info->timing.fps : 60.0;
duration_frames = (unsigned)((fps * (float)msg->duration / 1000.0f) + 0.5f);
runloop_msg_queue_push(msg->msg,
msg->priority, duration_frames,
true, NULL, MESSAGE_QUEUE_ICON_DEFAULT,
category);
}
/**
* rarch_environment_cb:
@ -10301,6 +10348,11 @@ static bool rarch_environment_cb(unsigned cmd, void *data)
break;
case RETRO_ENVIRONMENT_GET_MESSAGE_INTERFACE_VERSION:
/* Current API version is 1 */
*(unsigned *)data = 1;
break;
case RETRO_ENVIRONMENT_SET_MESSAGE:
{
const struct retro_message *msg = (const struct retro_message*)data;
@ -10317,6 +10369,121 @@ static bool rarch_environment_cb(unsigned cmd, void *data)
break;
}
case RETRO_ENVIRONMENT_SET_MESSAGE_EXT:
{
const struct retro_message_ext *msg = (const struct retro_message_ext*)data;
/* Log message, if required */
if (msg->target != RETRO_MESSAGE_TARGET_OSD)
{
switch (msg->level)
{
case RETRO_LOG_DEBUG:
{
settings_t *settings = configuration_settings;
unsigned log_level = settings->uints.frontend_log_level;
if (log_level == RETRO_LOG_DEBUG)
RARCH_LOG("[Environ]: SET_MESSAGE_EXT: %s\n", msg->msg);
}
break;
case RETRO_LOG_WARN:
RARCH_WARN("[Environ]: SET_MESSAGE_EXT: %s\n", msg->msg);
break;
case RETRO_LOG_ERROR:
RARCH_ERR("[Environ]: SET_MESSAGE_EXT: %s\n", msg->msg);
break;
case RETRO_LOG_INFO:
default:
RARCH_LOG("[Environ]: SET_MESSAGE_EXT: %s\n", msg->msg);
break;
}
}
/* Display message via OSD, if required */
if (msg->target != RETRO_MESSAGE_TARGET_LOG)
{
switch (msg->type)
{
/* Handle 'status' messages */
case RETRO_MESSAGE_TYPE_STATUS:
/* Note: We need to lock a mutex here. Strictly
* speaking, runloop_core_status_msg is not part
* of the message queue, but:
* - It may be implemented as a queue in the future
* - It seems unnecessary to create a new slock_t
* object for this type of message when
* _runloop_msg_queue_lock is already available
* We therefore just call runloop_msg_queue_lock()/
* runloop_msg_queue_unlock() in this case */
runloop_msg_queue_lock();
/* If a message is already set, only overwrite
* it if the new message has the same or higher
* priority */
if (!runloop_core_status_msg.set ||
(runloop_core_status_msg.priority <= msg->priority))
{
if (!string_is_empty(msg->msg))
{
strlcpy(runloop_core_status_msg.str, msg->msg,
sizeof(runloop_core_status_msg.str));
runloop_core_status_msg.duration = (float)msg->duration;
runloop_core_status_msg.set = true;
}
else
{
/* Ensure sane behaviour if core sends an
* empty message */
runloop_core_status_msg.str[0] = '\0';
runloop_core_status_msg.priority = 0;
runloop_core_status_msg.duration = 0.0f;
runloop_core_status_msg.set = false;
}
}
runloop_msg_queue_unlock();
break;
#if defined(HAVE_GFX_WIDGETS)
/* Handle 'alternate' non-queued notifications */
case RETRO_MESSAGE_TYPE_NOTIFICATION_ALT:
if (gfx_widgets_active())
gfx_widget_set_libretro_message(msg->msg, msg->duration);
else
runloop_core_msg_queue_push(msg);
break;
/* Handle 'progress' messages
* TODO/FIXME: At present, we also display messages
* of type RETRO_MESSAGE_TYPE_PROGRESS via
* gfx_widget_set_libretro_message(). We need to
* implement a separate 'progress bar' widget to
* handle these correctly */
case RETRO_MESSAGE_TYPE_PROGRESS:
if (gfx_widgets_active())
gfx_widget_set_libretro_message(msg->msg, msg->duration);
else
runloop_core_msg_queue_push(msg);
break;
#endif
/* Handle standard (queued) notifications */
case RETRO_MESSAGE_TYPE_NOTIFICATION:
default:
runloop_core_msg_queue_push(msg);
break;
}
}
break;
}
case RETRO_ENVIRONMENT_SET_ROTATION:
{
unsigned rotation = *(const unsigned*)data;
@ -22909,6 +23076,52 @@ static void video_driver_frame(const void *data, unsigned width,
video_driver_window_title_update = true;
}
/* Add core status message to 'fps_text' string
* TODO/FIXME: fps_text is used for several status
* parameters, not just FPS. It should probably be
* renamed to reflect this... */
if (video_info.core_status_msg_show)
{
/* Note: We need to lock a mutex here. Strictly
* speaking, runloop_core_status_msg is not part
* of the message queue, but:
* - It may be implemented as a queue in the future
* - It seems unnecessary to create a new slock_t
* object for this type of message when
* _runloop_msg_queue_lock is already available
* We therefore just call runloop_msg_queue_lock()/
* runloop_msg_queue_unlock() in this case */
runloop_msg_queue_lock();
/* Check whether duration timer has elapsed */
runloop_core_status_msg.duration -= gfx_animation_get_delta_time();
if (runloop_core_status_msg.duration < 0.0f)
{
runloop_core_status_msg.str[0] = '\0';
runloop_core_status_msg.priority = 0;
runloop_core_status_msg.duration = 0.0f;
runloop_core_status_msg.set = false;
}
else
{
/* If 'fps_text' is already set, add status
* message at the end */
if (!string_is_empty(fps_text))
{
strlcat(fps_text,
" || ", sizeof(fps_text));
strlcat(fps_text,
runloop_core_status_msg.str, sizeof(fps_text));
}
else
strlcpy(fps_text, runloop_core_status_msg.str,
sizeof(fps_text));
}
runloop_msg_queue_unlock();
}
/* Slightly messy code,
* but we really need to do processing before blocking on VSync
* for best possible scheduling.
@ -23070,6 +23283,7 @@ static void video_driver_frame(const void *data, unsigned width,
if ( video_info.fps_show
|| video_info.framecount_show
|| video_info.memory_show
|| video_info.core_status_msg_show
)
{
#if defined(HAVE_GFX_WIDGETS)
@ -23220,6 +23434,7 @@ void video_driver_build_info(video_frame_info_t *video_info)
video_info->memory_show = settings->bools.video_memory_show;
video_info->statistics_show = settings->bools.video_statistics_show;
video_info->framecount_show = settings->bools.video_framecount_show;
video_info->core_status_msg_show = runloop_core_status_msg.set;
video_info->aspect_ratio_idx = settings->uints.video_aspect_ratio_idx;
video_info->post_filter_record = settings->bools.video_post_filter_record;
video_info->input_menu_swap_ok_cancel_buttons = settings->bools.input_menu_swap_ok_cancel_buttons;

1
retroarch.h
View File

@ -1098,6 +1098,7 @@ typedef struct video_frame_info
bool memory_show;
bool statistics_show;
bool framecount_show;
bool core_status_msg_show;
bool post_filter_record;
bool windowed_fullscreen;
bool fullscreen;