ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(video_driver.c) Uniquely namespace static variables

This commit is contained in:
twinaphex 2015-11-30 07:14:23 +01:00
parent 91b40523bd
commit 2fe9ef736c
1 changed files with 197 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

397
gfx/video_driver.c
View File

@ -75,26 +75,26 @@ typedef struct video_pixel_scaler
void *scaler_out; void *scaler_out;
} video_pixel_scaler_t; } video_pixel_scaler_t;
static bool video_active; static bool video_driver_active;
/* Last message given to the video driver */ /* Last message given to the video driver */
static char current_msg[PATH_MAX_LENGTH]; static char video_driver_current_msg[PATH_MAX_LENGTH];
/* If set during context deinit, the driver should keep /* If set during context deinit, the driver should keep
* graphics context alive to avoid having to reset all * graphics context alive to avoid having to reset all
* context state. */ * context state. */
static bool video_cache_context; static bool video_driver_cache_context;
/* Set to true by driver if context caching succeeded. */ /* Set to true by driver if context caching succeeded. */
static bool video_cache_context_ack; static bool video_driver_cache_context_ack;
/* Opaque handles to currently running window. /* Opaque handles to currently running window.
* Used by e.g. input drivers which bind to a window. * Used by e.g. input drivers which bind to a window.
* Drivers are responsible for setting these if an input driver * Drivers are responsible for setting these if an input driver
* could potentially make use of this. */ * could potentially make use of this. */
static uintptr_t video_display; static uintptr_t video_driver_display;
static uintptr_t video_window; static uintptr_t video_driver_window;
static enum rarch_display_type display_type; static enum rarch_display_type video_driver_display_type;
/* Graphics driver requires RGBA byte order data (ABGR on little-endian) /* Graphics driver requires RGBA byte order data (ABGR on little-endian)
* for 32-bit. * for 32-bit.
@ -102,23 +102,23 @@ static enum rarch_display_type display_type;
* data into graphics driver. Kinda hackish to place it here, it is only * data into graphics driver. Kinda hackish to place it here, it is only
* used for GLES. * used for GLES.
* TODO: Refactor this better. */ * TODO: Refactor this better. */
static bool gfx_use_rgba; static bool video_driver_use_rgba;
static uint64_t video_frame_count; static uint64_t video_driver_frame_count;
static void *video_data; static void *video_driver_data;
static bool video_data_own; static bool video_driver_data_own;
static const video_driver_t *current_video; static const video_driver_t *current_video;
/* Interface for "poking". */ /* Interface for "poking". */
static const video_poke_interface_t *video_poke; static const video_poke_interface_t *video_driver_poke;
static struct retro_system_av_info video_viewport_av_info; static struct retro_system_av_info video_viewport_av_info;
static video_driver_state_t video_state; static video_driver_state_t video_driver_state;
/* Used for 16-bit -> 16-bit conversions that take place before /* Used for 16-bit -> 16-bit conversions that take place before
* being passed to video driver. */ * being passed to video driver. */
static video_pixel_scaler_t *scaler_ptr; static video_pixel_scaler_t *video_driver_scaler_ptr;
char rotation_lut[4][32] = char rotation_lut[4][32] =
{ {
@ -256,7 +256,7 @@ static bool find_video_driver(void)
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
#if defined(HAVE_OPENGL) && defined(HAVE_FBO) #if defined(HAVE_OPENGL) && defined(HAVE_FBO)
if (video_state.hw_render_callback.context_type) if (video_driver_state.hw_render_callback.context_type)
{ {
RARCH_LOG("Using HW render, OpenGL driver forced.\n"); RARCH_LOG("Using HW render, OpenGL driver forced.\n");
current_video = &video_gl; current_video = &video_gl;
@ -310,11 +310,11 @@ void *video_driver_get_ptr(bool force_nonthreaded_data)
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
if (settings->video.threaded if (settings->video.threaded
&& !video_state.hw_render_callback.context_type && !force_nonthreaded_data) && !video_driver_state.hw_render_callback.context_type && !force_nonthreaded_data)
return rarch_threaded_video_get_ptr(NULL); return rarch_threaded_video_get_ptr(NULL);
#endif #endif
return video_data; return video_driver_data;
} }
const char *video_driver_get_ident(void) const char *video_driver_get_ident(void)
@ -324,7 +324,7 @@ const char *video_driver_get_ident(void)
const video_poke_interface_t *video_driver_get_poke(void) const video_poke_interface_t *video_driver_get_poke(void)
{ {
return video_poke; return video_driver_poke;
} }
/** /**
@ -337,16 +337,16 @@ const video_poke_interface_t *video_driver_get_poke(void)
**/ **/
uintptr_t video_driver_get_current_framebuffer(void) uintptr_t video_driver_get_current_framebuffer(void)
{ {
if (video_poke->get_current_framebuffer) if (video_driver_poke->get_current_framebuffer)
return video_poke->get_current_framebuffer(video_data); return video_driver_poke->get_current_framebuffer(video_driver_data);
return 0; return 0;
} }
retro_proc_address_t video_driver_get_proc_address(const char *sym) retro_proc_address_t video_driver_get_proc_address(const char *sym)
{ {
if (video_poke->get_proc_address) if (video_driver_poke->get_proc_address)
return video_poke->get_proc_address(video_data, sym); return video_driver_poke->get_proc_address(video_driver_data, sym);
return NULL; return NULL;
} }
@ -354,19 +354,19 @@ bool video_driver_set_shader(enum rarch_shader_type type,
const char *path) const char *path)
{ {
if (current_video->set_shader) if (current_video->set_shader)
return current_video->set_shader(video_data, type, path); return current_video->set_shader(video_driver_data, type, path);
return false; return false;
} }
static void deinit_video_filter(void) static void deinit_video_filter(void)
{ {
rarch_softfilter_free(video_state.filter.filter); rarch_softfilter_free(video_driver_state.filter.filter);
#ifdef _3DS #ifdef _3DS
linearFree(video_state.filter.buffer); linearFree(video_driver_state.filter.buffer);
#else #else
free(video_state.filter.buffer); free(video_driver_state.filter.buffer);
#endif #endif
memset(&video_state.filter, 0, sizeof(video_state.filter)); memset(&video_driver_state.filter, 0, sizeof(video_driver_state.filter));
} }
static void init_video_filter(enum retro_pixel_format colfmt) static void init_video_filter(enum retro_pixel_format colfmt)
@ -386,7 +386,7 @@ static void init_video_filter(enum retro_pixel_format colfmt)
if (colfmt == RETRO_PIXEL_FORMAT_0RGB1555) if (colfmt == RETRO_PIXEL_FORMAT_0RGB1555)
colfmt = RETRO_PIXEL_FORMAT_RGB565; colfmt = RETRO_PIXEL_FORMAT_RGB565;
if (video_state.hw_render_callback.context_type) if (video_driver_state.hw_render_callback.context_type)
{ {
RARCH_WARN("Cannot use CPU filters when hardware rendering is used.\n"); RARCH_WARN("Cannot use CPU filters when hardware rendering is used.\n");
return; return;
@ -400,36 +400,36 @@ static void init_video_filter(enum retro_pixel_format colfmt)
width = geom->max_width; width = geom->max_width;
height = geom->max_height; height = geom->max_height;
video_state.filter.filter = rarch_softfilter_new( video_driver_state.filter.filter = rarch_softfilter_new(
settings->video.softfilter_plugin, settings->video.softfilter_plugin,
RARCH_SOFTFILTER_THREADS_AUTO, colfmt, width, height); RARCH_SOFTFILTER_THREADS_AUTO, colfmt, width, height);
if (!video_state.filter.filter) if (!video_driver_state.filter.filter)
{ {
RARCH_ERR("Failed to load filter.\n"); RARCH_ERR("Failed to load filter.\n");
return; return;
} }
rarch_softfilter_get_max_output_size(video_state.filter.filter, rarch_softfilter_get_max_output_size(video_driver_state.filter.filter,
&width, &height); &width, &height);
pow2_x = next_pow2(width); pow2_x = next_pow2(width);
pow2_y = next_pow2(height); pow2_y = next_pow2(height);
maxsize = max(pow2_x, pow2_y); maxsize = max(pow2_x, pow2_y);
video_state.filter.scale = maxsize / RARCH_SCALE_BASE; video_driver_state.filter.scale = maxsize / RARCH_SCALE_BASE;
video_state.filter.out_rgb32 = rarch_softfilter_get_output_format( video_driver_state.filter.out_rgb32 = rarch_softfilter_get_output_format(
video_state.filter.filter) == RETRO_PIXEL_FORMAT_XRGB8888; video_driver_state.filter.filter) == RETRO_PIXEL_FORMAT_XRGB8888;
video_state.filter.out_bpp = video_state.filter.out_rgb32 ? video_driver_state.filter.out_bpp = video_driver_state.filter.out_rgb32 ?
sizeof(uint32_t) : sizeof(uint16_t); sizeof(uint32_t) : sizeof(uint16_t);
/* TODO: Aligned output. */ /* TODO: Aligned output. */
#ifdef _3DS #ifdef _3DS
video_state.filter.buffer = linearMemAlign(width * height * video_state.filter.out_bpp, 0x80); video_driver_state.filter.buffer = linearMemAlign(width * height * video_driver_state.filter.out_bpp, 0x80);
#else #else
video_state.filter.buffer = malloc(width * height * video_state.filter.out_bpp); video_driver_state.filter.buffer = malloc(width * height * video_driver_state.filter.out_bpp);
#endif #endif
if (!video_state.filter.buffer) if (!video_driver_state.filter.buffer)
goto error; goto error;
return; return;
@ -446,7 +446,7 @@ static void init_video_input(const input_driver_t *tmp)
return; return;
/* Reset video frame count */ /* Reset video frame count */
video_frame_count = 0; video_driver_frame_count = 0;
/* Video driver didn't provide an input driver, /* Video driver didn't provide an input driver,
* so we use configured one. */ * so we use configured one. */
@ -497,7 +497,7 @@ static void video_monitor_compute_fps_statistics(void)
return; return;
} }
if (video_state.frame_time_samples_count < 2 * MEASURE_FRAME_TIME_SAMPLES_COUNT) if (video_driver_state.frame_time_samples_count < 2 * MEASURE_FRAME_TIME_SAMPLES_COUNT)
{ {
RARCH_LOG( RARCH_LOG(
"Does not have enough samples for monitor refresh rate estimation. Requires to run for at least %u frames.\n", "Does not have enough samples for monitor refresh rate estimation. Requires to run for at least %u frames.\n",
@ -514,22 +514,22 @@ static void video_monitor_compute_fps_statistics(void)
static void deinit_pixel_converter(void) static void deinit_pixel_converter(void)
{ {
if (!scaler_ptr) if (!video_driver_scaler_ptr)
return; return;
scaler_ctx_gen_reset(scaler_ptr->scaler); scaler_ctx_gen_reset(video_driver_scaler_ptr->scaler);
if (scaler_ptr->scaler) if (video_driver_scaler_ptr->scaler)
free(scaler_ptr->scaler); free(video_driver_scaler_ptr->scaler);
scaler_ptr->scaler = NULL; video_driver_scaler_ptr->scaler = NULL;
if (scaler_ptr->scaler_out) if (video_driver_scaler_ptr->scaler_out)
free(scaler_ptr->scaler_out); free(video_driver_scaler_ptr->scaler_out);
scaler_ptr->scaler_out = NULL; video_driver_scaler_ptr->scaler_out = NULL;
if (scaler_ptr) if (video_driver_scaler_ptr)
free(scaler_ptr); free(video_driver_scaler_ptr);
scaler_ptr = NULL; video_driver_scaler_ptr = NULL;
} }
static bool uninit_video_input(void) static bool uninit_video_input(void)
@ -541,15 +541,15 @@ static bool uninit_video_input(void)
if ( if (
!input_driver_ctl(RARCH_INPUT_CTL_OWNS_DRIVER, NULL) && !input_driver_ctl(RARCH_INPUT_CTL_OWNS_DRIVER, NULL) &&
!input_driver_data_ptr_is_same(video_data) !input_driver_data_ptr_is_same(video_driver_data)
) )
input_driver_ctl(RARCH_INPUT_CTL_DEINIT, NULL); input_driver_ctl(RARCH_INPUT_CTL_DEINIT, NULL);
if ( if (
!video_data_own && !video_driver_data_own &&
video_data && video_driver_data &&
current_video->free) current_video->free)
current_video->free(video_data); current_video->free(video_driver_data);
deinit_pixel_converter(); deinit_pixel_converter();
@ -559,14 +559,14 @@ static bool uninit_video_input(void)
event_command(EVENT_CMD_SHADER_DIR_DEINIT); event_command(EVENT_CMD_SHADER_DIR_DEINIT);
video_monitor_compute_fps_statistics(); video_monitor_compute_fps_statistics();
if (hw_render->context_destroy && !video_cache_context) if (hw_render->context_destroy && !video_driver_cache_context)
hw_render->context_destroy(); hw_render->context_destroy();
video_driver_ctl(RARCH_DISPLAY_CTL_UNSET_RGBA, NULL); video_driver_ctl(RARCH_DISPLAY_CTL_UNSET_RGBA, NULL);
current_video = NULL; current_video = NULL;
if (!video_data_own) if (!video_driver_data_own)
video_data = NULL; video_driver_data = NULL;
return true; return true;
} }
@ -584,41 +584,41 @@ static bool init_video_pixel_converter(unsigned size)
RARCH_WARN("0RGB1555 pixel format is deprecated, and will be slower. For 15/16-bit, RGB565 format is preferred.\n"); RARCH_WARN("0RGB1555 pixel format is deprecated, and will be slower. For 15/16-bit, RGB565 format is preferred.\n");
scaler_ptr = (video_pixel_scaler_t*)calloc(1, sizeof(*scaler_ptr)); video_driver_scaler_ptr = (video_pixel_scaler_t*)calloc(1, sizeof(*video_driver_scaler_ptr));
if (!scaler_ptr) if (!video_driver_scaler_ptr)
goto error; goto error;
scaler_ptr->scaler = (struct scaler_ctx*)calloc(1, sizeof(*scaler_ptr->scaler)); video_driver_scaler_ptr->scaler = (struct scaler_ctx*)calloc(1, sizeof(*video_driver_scaler_ptr->scaler));
if (!scaler_ptr->scaler) if (!video_driver_scaler_ptr->scaler)
goto error; goto error;
scaler_ptr->scaler->scaler_type = SCALER_TYPE_POINT; video_driver_scaler_ptr->scaler->scaler_type = SCALER_TYPE_POINT;
scaler_ptr->scaler->in_fmt = SCALER_FMT_0RGB1555; video_driver_scaler_ptr->scaler->in_fmt = SCALER_FMT_0RGB1555;
/* TODO: Pick either ARGB8888 or RGB565 depending on driver. */ /* TODO: Pick either ARGB8888 or RGB565 depending on driver. */
scaler_ptr->scaler->out_fmt = SCALER_FMT_RGB565; video_driver_scaler_ptr->scaler->out_fmt = SCALER_FMT_RGB565;
if (!scaler_ctx_gen_filter(scaler_ptr->scaler)) if (!scaler_ctx_gen_filter(video_driver_scaler_ptr->scaler))
goto error; goto error;
scaler_ptr->scaler_out = calloc(sizeof(uint16_t), size * size); video_driver_scaler_ptr->scaler_out = calloc(sizeof(uint16_t), size * size);
if (!scaler_ptr->scaler_out) if (!video_driver_scaler_ptr->scaler_out)
goto error; goto error;
return true; return true;
error: error:
if (scaler_ptr->scaler_out) if (video_driver_scaler_ptr->scaler_out)
free(scaler_ptr->scaler_out); free(video_driver_scaler_ptr->scaler_out);
if (scaler_ptr->scaler) if (video_driver_scaler_ptr->scaler)
free(scaler_ptr->scaler); free(video_driver_scaler_ptr->scaler);
if (scaler_ptr) if (video_driver_scaler_ptr)
free(scaler_ptr); free(video_driver_scaler_ptr);
scaler_ptr = NULL; video_driver_scaler_ptr = NULL;
return false; return false;
} }
@ -636,7 +636,7 @@ static bool init_video(void)
struct retro_system_av_info *av_info = struct retro_system_av_info *av_info =
video_viewport_get_system_av_info(); video_viewport_get_system_av_info();
init_video_filter(video_state.pix_fmt); init_video_filter(video_driver_state.pix_fmt);
event_command(EVENT_CMD_SHADER_DIR_INIT); event_command(EVENT_CMD_SHADER_DIR_INIT);
if (av_info) if (av_info)
@ -652,8 +652,8 @@ static bool init_video(void)
scale = next_pow2(max_dim) / RARCH_SCALE_BASE; scale = next_pow2(max_dim) / RARCH_SCALE_BASE;
scale = max(scale, 1); scale = max(scale, 1);
if (video_state.filter.filter) if (video_driver_state.filter.filter)
scale = video_state.filter.scale; scale = video_driver_state.filter.scale;
/* Update core-dependent aspect ratio values. */ /* Update core-dependent aspect ratio values. */
video_driver_ctl(RARCH_DISPLAY_CTL_SET_VIEWPORT_SQUARE_PIXEL, NULL); video_driver_ctl(RARCH_DISPLAY_CTL_SET_VIEWPORT_SQUARE_PIXEL, NULL);
@ -719,21 +719,21 @@ static bool init_video(void)
#endif #endif
video.smooth = settings->video.smooth; video.smooth = settings->video.smooth;
video.input_scale = scale; video.input_scale = scale;
video.rgb32 = video_state.filter.filter ? video.rgb32 = video_driver_state.filter.filter ?
video_state.filter.out_rgb32 : video_driver_state.filter.out_rgb32 :
(video_state.pix_fmt == RETRO_PIXEL_FORMAT_XRGB8888); (video_driver_state.pix_fmt == RETRO_PIXEL_FORMAT_XRGB8888);
tmp = input_get_ptr(); tmp = input_get_ptr();
/* Need to grab the "real" video driver interface on a reinit. */ /* Need to grab the "real" video driver interface on a reinit. */
video_driver_ctl(RARCH_DISPLAY_CTL_FIND_DRIVER, NULL); video_driver_ctl(RARCH_DISPLAY_CTL_FIND_DRIVER, NULL);
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
if (settings->video.threaded && !video_state.hw_render_callback.context_type) if (settings->video.threaded && !video_driver_state.hw_render_callback.context_type)
{ {
/* Can't do hardware rendering with threaded driver currently. */ /* Can't do hardware rendering with threaded driver currently. */
RARCH_LOG("Starting threaded video driver ...\n"); RARCH_LOG("Starting threaded video driver ...\n");
if (!rarch_threaded_video_init(&current_video, &video_data, if (!rarch_threaded_video_init(&current_video, &video_driver_data,
input_get_double_ptr(), input_driver_get_data_ptr(), input_get_double_ptr(), input_driver_get_data_ptr(),
current_video, &video)) current_video, &video))
{ {
@ -743,18 +743,18 @@ static bool init_video(void)
} }
else else
#endif #endif
video_data = current_video->init(&video, input_get_double_ptr(), video_driver_data = current_video->init(&video, input_get_double_ptr(),
input_driver_get_data_ptr()); input_driver_get_data_ptr());
if (!video_data) if (!video_driver_data)
{ {
RARCH_ERR("Cannot open video driver ... Exiting ...\n"); RARCH_ERR("Cannot open video driver ... Exiting ...\n");
goto error; goto error;
} }
video_poke = NULL; video_driver_poke = NULL;
if (current_video->poke_interface) if (current_video->poke_interface)
current_video->poke_interface(video_data, &video_poke); current_video->poke_interface(video_driver_data, &video_driver_poke);
if (current_video->viewport_info && (!custom_vp->width || if (current_video->viewport_info && (!custom_vp->width ||
!custom_vp->height)) !custom_vp->height))
@ -790,7 +790,7 @@ error:
bool video_driver_suppress_screensaver(bool enable) bool video_driver_suppress_screensaver(bool enable)
{ {
return current_video->suppress_screensaver(video_data, enable); return current_video->suppress_screensaver(video_driver_data, enable);
} }
@ -799,7 +799,7 @@ bool video_driver_set_viewport(unsigned width, unsigned height,
{ {
if (current_video->set_viewport) if (current_video->set_viewport)
{ {
current_video->set_viewport(video_data, width, height, current_video->set_viewport(video_driver_data, width, height,
force_fullscreen, allow_rotate); force_fullscreen, allow_rotate);
return true; return true;
} }
@ -810,7 +810,7 @@ bool video_driver_set_rotation(unsigned rotation)
{ {
if (current_video->set_rotation) if (current_video->set_rotation)
{ {
current_video->set_rotation(video_data, rotation); current_video->set_rotation(video_driver_data, rotation);
return true; return true;
} }
return false; return false;
@ -820,9 +820,9 @@ bool video_driver_set_rotation(unsigned rotation)
bool video_driver_set_video_mode(unsigned width, bool video_driver_set_video_mode(unsigned width,
unsigned height, bool fullscreen) unsigned height, bool fullscreen)
{ {
if (video_poke->set_video_mode) if (video_driver_poke->set_video_mode)
{ {
video_poke->set_video_mode(video_data, width, height, fullscreen); video_driver_poke->set_video_mode(video_driver_data, width, height, fullscreen);
return true; return true;
} }
@ -831,9 +831,9 @@ bool video_driver_set_video_mode(unsigned width,
bool video_driver_get_video_output_size(unsigned *width, unsigned *height) bool video_driver_get_video_output_size(unsigned *width, unsigned *height)
{ {
if (video_poke->get_video_output_size) if (video_driver_poke->get_video_output_size)
{ {
video_poke->get_video_output_size(video_data, width, height); video_driver_poke->get_video_output_size(video_driver_data, width, height);
return true; return true;
} }
return false; return false;
@ -844,15 +844,15 @@ bool video_driver_get_video_output_size(unsigned *width, unsigned *height)
void video_driver_set_osd_msg(const char *msg, void video_driver_set_osd_msg(const char *msg,
const struct font_params *params, void *font) const struct font_params *params, void *font)
{ {
if (video_poke->set_osd_msg) if (video_driver_poke->set_osd_msg)
video_poke->set_osd_msg(video_data, msg, params, font); video_driver_poke->set_osd_msg(video_driver_data, msg, params, font);
} }
void video_driver_set_texture_enable(bool enable, bool fullscreen) void video_driver_set_texture_enable(bool enable, bool fullscreen)
{ {
#ifdef HAVE_MENU #ifdef HAVE_MENU
if (video_poke->set_texture_enable) if (video_driver_poke->set_texture_enable)
video_poke->set_texture_enable(video_data, enable, fullscreen); video_driver_poke->set_texture_enable(video_driver_data, enable, fullscreen);
#endif #endif
} }
@ -860,8 +860,8 @@ void video_driver_set_texture_frame(const void *frame, bool rgb32,
unsigned width, unsigned height, float alpha) unsigned width, unsigned height, float alpha)
{ {
#ifdef HAVE_MENU #ifdef HAVE_MENU
if (video_poke->set_texture_frame) if (video_driver_poke->set_texture_frame)
video_poke->set_texture_frame(video_data, frame, rgb32, width, height, alpha); video_driver_poke->set_texture_frame(video_driver_data, frame, rgb32, width, height, alpha);
#endif #endif
} }
@ -869,7 +869,7 @@ bool video_driver_viewport_info(struct video_viewport *vp)
{ {
if (current_video->viewport_info) if (current_video->viewport_info)
{ {
current_video->viewport_info(video_data, vp); current_video->viewport_info(video_driver_data, vp);
return true; return true;
} }
return false; return false;
@ -881,7 +881,7 @@ bool video_driver_overlay_interface(const video_overlay_interface_t **iface)
{ {
if (current_video->overlay_interface) if (current_video->overlay_interface)
{ {
current_video->overlay_interface(video_data, iface); current_video->overlay_interface(video_driver_data, iface);
return true; return true;
} }
return false; return false;
@ -892,15 +892,15 @@ void *video_driver_read_frame_raw(unsigned *width,
unsigned *height, size_t *pitch) unsigned *height, size_t *pitch)
{ {
if (current_video->read_frame_raw) if (current_video->read_frame_raw)
return current_video->read_frame_raw(video_data, width, return current_video->read_frame_raw(video_driver_data, width,
height, pitch); height, pitch);
return NULL; return NULL;
} }
void video_driver_set_filtering(unsigned index, bool smooth) void video_driver_set_filtering(unsigned index, bool smooth)
{ {
if (video_poke->set_filtering) if (video_driver_poke->set_filtering)
video_poke->set_filtering(video_data, index, smooth); video_driver_poke->set_filtering(video_driver_data, index, smooth);
} }
void video_driver_cached_frame_set_ptr(const void *data) void video_driver_cached_frame_set_ptr(const void *data)
@ -908,45 +908,45 @@ void video_driver_cached_frame_set_ptr(const void *data)
if (!data) if (!data)
return; return;
video_state.frame_cache.data = data; video_driver_state.frame_cache.data = data;
} }
void video_driver_cached_frame_set(const void *data, unsigned width, void video_driver_cached_frame_set(const void *data, unsigned width,
unsigned height, size_t pitch) unsigned height, size_t pitch)
{ {
video_state.frame_cache.data = data; video_driver_state.frame_cache.data = data;
video_state.frame_cache.width = width; video_driver_state.frame_cache.width = width;
video_state.frame_cache.height = height; video_driver_state.frame_cache.height = height;
video_state.frame_cache.pitch = pitch; video_driver_state.frame_cache.pitch = pitch;
} }
void video_driver_cached_frame_get(const void **data, unsigned *width, void video_driver_cached_frame_get(const void **data, unsigned *width,
unsigned *height, size_t *pitch) unsigned *height, size_t *pitch)
{ {
if (data) if (data)
*data = video_state.frame_cache.data; *data = video_driver_state.frame_cache.data;
if (width) if (width)
*width = video_state.frame_cache.width; *width = video_driver_state.frame_cache.width;
if (height) if (height)
*height = video_state.frame_cache.height; *height = video_driver_state.frame_cache.height;
if (pitch) if (pitch)
*pitch = video_state.frame_cache.pitch; *pitch = video_driver_state.frame_cache.pitch;
} }
void video_driver_get_size(unsigned *width, unsigned *height) void video_driver_get_size(unsigned *width, unsigned *height)
{ {
if (width) if (width)
*width = video_state.video_width; *width = video_driver_state.video_width;
if (height) if (height)
*height = video_state.video_height; *height = video_driver_state.video_height;
} }
void video_driver_set_size(unsigned *width, unsigned *height) void video_driver_set_size(unsigned *width, unsigned *height)
{ {
if (width) if (width)
video_state.video_width = *width; video_driver_state.video_width = *width;
if (height) if (height)
video_state.video_height = *height; video_driver_state.video_height = *height;
} }
/** /**
@ -992,19 +992,19 @@ bool video_monitor_fps_statistics(double *refresh_rate,
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
samples = min(MEASURE_FRAME_TIME_SAMPLES_COUNT, samples = min(MEASURE_FRAME_TIME_SAMPLES_COUNT,
video_state.frame_time_samples_count); video_driver_state.frame_time_samples_count);
if (settings->video.threaded || (samples < 2)) if (settings->video.threaded || (samples < 2))
return false; return false;
/* Measure statistics on frame time (microsecs), *not* FPS. */ /* Measure statistics on frame time (microsecs), *not* FPS. */
for (i = 0; i < samples; i++) for (i = 0; i < samples; i++)
accum += video_state.frame_time_samples[i]; accum += video_driver_state.frame_time_samples[i];
#if 0 #if 0
for (i = 0; i < samples; i++) for (i = 0; i < samples; i++)
RARCH_LOG("Interval #%u: %d usec / frame.\n", RARCH_LOG("Interval #%u: %d usec / frame.\n",
i, (int)video_state.frame_time_samples[i]); i, (int)video_driver_state.frame_time_samples[i]);
#endif #endif
avg = accum / samples; avg = accum / samples;
@ -1012,7 +1012,7 @@ bool video_monitor_fps_statistics(double *refresh_rate,
/* Drop first measurement. It is likely to be bad. */ /* Drop first measurement. It is likely to be bad. */
for (i = 0; i < samples; i++) for (i = 0; i < samples; i++)
{ {
retro_time_t diff = video_state.frame_time_samples[i] - avg; retro_time_t diff = video_driver_state.frame_time_samples[i] - avg;
accum_var += diff * diff; accum_var += diff * diff;
} }
@ -1061,29 +1061,29 @@ bool video_monitor_get_fps(char *buf, size_t size,
new_time = retro_get_time_usec(); new_time = retro_get_time_usec();
if (video_frame_count) if (video_driver_frame_count)
{ {
static float last_fps; static float last_fps;
bool ret = false; bool ret = false;
unsigned write_index = video_state.frame_time_samples_count++ & unsigned write_index = video_driver_state.frame_time_samples_count++ &
(MEASURE_FRAME_TIME_SAMPLES_COUNT - 1); (MEASURE_FRAME_TIME_SAMPLES_COUNT - 1);
video_state.frame_time_samples[write_index] = new_time - fps_time; video_driver_state.frame_time_samples[write_index] = new_time - fps_time;
fps_time = new_time; fps_time = new_time;
if ((video_frame_count % FPS_UPDATE_INTERVAL) == 0) if ((video_driver_frame_count % FPS_UPDATE_INTERVAL) == 0)
{ {
last_fps = TIME_TO_FPS(curr_time, new_time, FPS_UPDATE_INTERVAL); last_fps = TIME_TO_FPS(curr_time, new_time, FPS_UPDATE_INTERVAL);
curr_time = new_time; curr_time = new_time;
snprintf(buf, size, "%s || FPS: %6.1f || Frames: " U64_SIGN, snprintf(buf, size, "%s || FPS: %6.1f || Frames: " U64_SIGN,
system->title_buf, last_fps, (unsigned long long)video_frame_count); system->title_buf, last_fps, (unsigned long long)video_driver_frame_count);
ret = true; ret = true;
} }
if (buf_fps) if (buf_fps)
snprintf(buf_fps, size_fps, "FPS: %6.1f || Frames: " U64_SIGN, snprintf(buf_fps, size_fps, "FPS: %6.1f || Frames: " U64_SIGN,
last_fps, (unsigned long long)video_frame_count); last_fps, (unsigned long long)video_driver_frame_count);
return ret; return ret;
} }
@ -1098,17 +1098,17 @@ bool video_monitor_get_fps(char *buf, size_t size,
float video_driver_get_aspect_ratio(void) float video_driver_get_aspect_ratio(void)
{ {
return video_state.aspect_ratio; return video_driver_state.aspect_ratio;
} }
void video_driver_set_aspect_ratio_value(float value) void video_driver_set_aspect_ratio_value(float value)
{ {
video_state.aspect_ratio = value; video_driver_state.aspect_ratio = value;
} }
struct retro_hw_render_callback *video_driver_callback(void) struct retro_hw_render_callback *video_driver_callback(void)
{ {
return &video_state.hw_render_callback; return &video_driver_state.hw_render_callback;
} }
@ -1123,22 +1123,22 @@ bool video_driver_frame_filter(const void *data,
rarch_perf_init(&softfilter_process, "softfilter_process"); rarch_perf_init(&softfilter_process, "softfilter_process");
if (!video_state.filter.filter || !data) if (!video_driver_state.filter.filter || !data)
return false; return false;
rarch_softfilter_get_output_size(video_state.filter.filter, rarch_softfilter_get_output_size(video_driver_state.filter.filter,
output_width, output_height, width, height); output_width, output_height, width, height);
*output_pitch = (*output_width) * video_state.filter.out_bpp; *output_pitch = (*output_width) * video_driver_state.filter.out_bpp;
retro_perf_start(&softfilter_process); retro_perf_start(&softfilter_process);
rarch_softfilter_process(video_state.filter.filter, rarch_softfilter_process(video_driver_state.filter.filter,
video_state.filter.buffer, *output_pitch, video_driver_state.filter.buffer, *output_pitch,
data, width, height, pitch); data, width, height, pitch);
retro_perf_stop(&softfilter_process); retro_perf_stop(&softfilter_process);
if (settings->video.post_filter_record) if (settings->video.post_filter_record)
recording_dump_frame(video_state.filter.buffer, recording_dump_frame(video_driver_state.filter.buffer,
*output_width, *output_height, *output_pitch); *output_width, *output_height, *output_pitch);
return true; return true;
@ -1146,22 +1146,22 @@ bool video_driver_frame_filter(const void *data,
rarch_softfilter_t *video_driver_frame_filter_get_ptr(void) rarch_softfilter_t *video_driver_frame_filter_get_ptr(void)
{ {
return video_state.filter.filter; return video_driver_state.filter.filter;
} }
void *video_driver_frame_filter_get_buf_ptr(void) void *video_driver_frame_filter_get_buf_ptr(void)
{ {
return video_state.filter.buffer; return video_driver_state.filter.buffer;
} }
enum retro_pixel_format video_driver_get_pixel_format(void) enum retro_pixel_format video_driver_get_pixel_format(void)
{ {
return video_state.pix_fmt; return video_driver_state.pix_fmt;
} }
void video_driver_set_pixel_format(enum retro_pixel_format fmt) void video_driver_set_pixel_format(enum retro_pixel_format fmt)
{ {
video_state.pix_fmt = fmt; video_driver_state.pix_fmt = fmt;
} }
/** /**
@ -1186,11 +1186,11 @@ static bool video_driver_cached_frame(void)
*/ */
if (driver->retro_ctx.frame_cb) if (driver->retro_ctx.frame_cb)
driver->retro_ctx.frame_cb( driver->retro_ctx.frame_cb(
(video_state.frame_cache.data == RETRO_HW_FRAME_BUFFER_VALID) (video_driver_state.frame_cache.data == RETRO_HW_FRAME_BUFFER_VALID)
? NULL : video_state.frame_cache.data, ? NULL : video_driver_state.frame_cache.data,
video_state.frame_cache.width, video_driver_state.frame_cache.width,
video_state.frame_cache.height, video_driver_state.frame_cache.height,
video_state.frame_cache.pitch); video_driver_state.frame_cache.pitch);
driver->recording_data = recording; driver->recording_data = recording;
@ -1469,24 +1469,24 @@ bool video_driver_ctl(enum rarch_display_ctl_state state, void *data)
} }
return true; return true;
case RARCH_DISPLAY_CTL_SET_RGBA: case RARCH_DISPLAY_CTL_SET_RGBA:
gfx_use_rgba = true; video_driver_use_rgba = true;
break; break;
case RARCH_DISPLAY_CTL_UNSET_RGBA: case RARCH_DISPLAY_CTL_UNSET_RGBA:
gfx_use_rgba = false; video_driver_use_rgba = false;
break; break;
case RARCH_DISPLAY_CTL_SUPPORTS_RGBA: case RARCH_DISPLAY_CTL_SUPPORTS_RGBA:
return gfx_use_rgba; return video_driver_use_rgba;
case RARCH_DISPLAY_CTL_GET_NEXT_VIDEO_OUT: case RARCH_DISPLAY_CTL_GET_NEXT_VIDEO_OUT:
if (video_poke->get_video_output_next) if (video_driver_poke->get_video_output_next)
{ {
video_poke->get_video_output_next(video_data); video_driver_poke->get_video_output_next(video_driver_data);
return true; return true;
} }
return gfx_ctx_get_video_output_next(gfx_ctx_data_get_ptr()); return gfx_ctx_get_video_output_next(gfx_ctx_data_get_ptr());
case RARCH_DISPLAY_CTL_GET_PREV_VIDEO_OUT: case RARCH_DISPLAY_CTL_GET_PREV_VIDEO_OUT:
if (video_poke->get_video_output_prev) if (video_driver_poke->get_video_output_prev)
{ {
video_poke->get_video_output_prev(video_data); video_driver_poke->get_video_output_prev(video_driver_data);
return true; return true;
} }
return gfx_ctx_get_video_output_next(gfx_ctx_data_get_ptr()); return gfx_ctx_get_video_output_next(gfx_ctx_data_get_ptr());
@ -1495,22 +1495,22 @@ bool video_driver_ctl(enum rarch_display_ctl_state state, void *data)
case RARCH_DISPLAY_CTL_DEINIT: case RARCH_DISPLAY_CTL_DEINIT:
return uninit_video_input(); return uninit_video_input();
case RARCH_DISPLAY_CTL_MONITOR_RESET: case RARCH_DISPLAY_CTL_MONITOR_RESET:
video_state.frame_time_samples_count = 0; video_driver_state.frame_time_samples_count = 0;
return true; return true;
case RARCH_DISPLAY_CTL_MONITOR_ADJUST_SYSTEM_RATES: case RARCH_DISPLAY_CTL_MONITOR_ADJUST_SYSTEM_RATES:
video_monitor_adjust_system_rates(); video_monitor_adjust_system_rates();
return true; return true;
case RARCH_DISPLAY_CTL_SET_ASPECT_RATIO: case RARCH_DISPLAY_CTL_SET_ASPECT_RATIO:
if (!video_poke->set_aspect_ratio) if (!video_driver_poke->set_aspect_ratio)
return false; return false;
video_poke->set_aspect_ratio(video_data, settings->video.aspect_ratio_idx); video_driver_poke->set_aspect_ratio(video_driver_data, settings->video.aspect_ratio_idx);
return true; return true;
case RARCH_DISPLAY_CTL_SHOW_MOUSE: case RARCH_DISPLAY_CTL_SHOW_MOUSE:
{ {
bool *toggle = (bool*)data; bool *toggle = (bool*)data;
if (video_poke->show_mouse) if (video_driver_poke->show_mouse)
video_poke->show_mouse(video_data, *toggle); video_driver_poke->show_mouse(video_driver_data, *toggle);
} }
return true; return true;
case RARCH_DISPLAY_CTL_SET_NONBLOCK_STATE: case RARCH_DISPLAY_CTL_SET_NONBLOCK_STATE:
@ -1521,48 +1521,48 @@ bool video_driver_ctl(enum rarch_display_ctl_state state, void *data)
return false; return false;
if (current_video->set_nonblock_state) if (current_video->set_nonblock_state)
current_video->set_nonblock_state(video_data, *toggle); current_video->set_nonblock_state(video_driver_data, *toggle);
} }
return true; return true;
case RARCH_DISPLAY_CTL_FIND_DRIVER: case RARCH_DISPLAY_CTL_FIND_DRIVER:
return find_video_driver(); return find_video_driver();
case RARCH_DISPLAY_CTL_APPLY_STATE_CHANGES: case RARCH_DISPLAY_CTL_APPLY_STATE_CHANGES:
if (video_poke->apply_state_changes) if (video_driver_poke->apply_state_changes)
video_poke->apply_state_changes(video_data); video_driver_poke->apply_state_changes(video_driver_data);
return true; return true;
case RARCH_DISPLAY_CTL_READ_VIEWPORT: case RARCH_DISPLAY_CTL_READ_VIEWPORT:
if (current_video->read_viewport) if (current_video->read_viewport)
return current_video->read_viewport(video_data, return current_video->read_viewport(video_driver_data,
(uint8_t*)data); (uint8_t*)data);
return false; return false;
case RARCH_DISPLAY_CTL_CACHED_FRAME_HAS_VALID_FB: case RARCH_DISPLAY_CTL_CACHED_FRAME_HAS_VALID_FB:
if (!video_state.frame_cache.data) if (!video_driver_state.frame_cache.data)
return false; return false;
return (video_state.frame_cache.data == RETRO_HW_FRAME_BUFFER_VALID); return (video_driver_state.frame_cache.data == RETRO_HW_FRAME_BUFFER_VALID);
case RARCH_DISPLAY_CTL_CACHED_FRAME_RENDER: case RARCH_DISPLAY_CTL_CACHED_FRAME_RENDER:
if (!current_video) if (!current_video)
return false; return false;
return video_driver_cached_frame(); return video_driver_cached_frame();
case RARCH_DISPLAY_CTL_IS_ALIVE: case RARCH_DISPLAY_CTL_IS_ALIVE:
return current_video->alive(video_data); return current_video->alive(video_driver_data);
case RARCH_DISPLAY_CTL_IS_FOCUSED: case RARCH_DISPLAY_CTL_IS_FOCUSED:
return current_video->focus(video_data); return current_video->focus(video_driver_data);
case RARCH_DISPLAY_CTL_HAS_WINDOWED: case RARCH_DISPLAY_CTL_HAS_WINDOWED:
return current_video->has_windowed(video_data); return current_video->has_windowed(video_driver_data);
case RARCH_DISPLAY_CTL_GET_FRAME_COUNT: case RARCH_DISPLAY_CTL_GET_FRAME_COUNT:
{ {
uint64_t **ptr = (uint64_t**)data; uint64_t **ptr = (uint64_t**)data;
if (!ptr) if (!ptr)
return false; return false;
*ptr = &video_frame_count; *ptr = &video_driver_frame_count;
} }
return true; return true;
case RARCH_DISPLAY_CTL_FRAME_FILTER_ALIVE: case RARCH_DISPLAY_CTL_FRAME_FILTER_ALIVE:
if (video_state.filter.filter) if (video_driver_state.filter.filter)
return true; return true;
return false; return false;
case RARCH_DISPLAY_CTL_FRAME_FILTER_IS_32BIT: case RARCH_DISPLAY_CTL_FRAME_FILTER_IS_32BIT:
return video_state.filter.out_rgb32; return video_driver_state.filter.out_rgb32;
case RARCH_DISPLAY_CTL_DEFAULT_SETTINGS: case RARCH_DISPLAY_CTL_DEFAULT_SETTINGS:
{ {
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
@ -1631,37 +1631,37 @@ bool video_driver_ctl(enum rarch_display_ctl_state state, void *data)
} }
return true; return true;
case RARCH_DISPLAY_CTL_SET_OWN_DRIVER: case RARCH_DISPLAY_CTL_SET_OWN_DRIVER:
video_data_own = true; video_driver_data_own = true;
break; break;
case RARCH_DISPLAY_CTL_UNSET_OWN_DRIVER: case RARCH_DISPLAY_CTL_UNSET_OWN_DRIVER:
video_data_own = false; video_driver_data_own = false;
break; break;
case RARCH_DISPLAY_CTL_OWNS_DRIVER: case RARCH_DISPLAY_CTL_OWNS_DRIVER:
return video_data_own; return video_driver_data_own;
case RARCH_DISPLAY_CTL_SET_VIDEO_CACHE_CONTEXT: case RARCH_DISPLAY_CTL_SET_VIDEO_CACHE_CONTEXT:
video_cache_context = true; video_driver_cache_context = true;
break; break;
case RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT: case RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT:
video_cache_context = false; video_driver_cache_context = false;
break; break;
case RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT: case RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT:
return video_cache_context; return video_driver_cache_context;
case RARCH_DISPLAY_CTL_SET_VIDEO_CACHE_CONTEXT_ACK: case RARCH_DISPLAY_CTL_SET_VIDEO_CACHE_CONTEXT_ACK:
video_cache_context_ack = true; video_driver_cache_context_ack = true;
break; break;
case RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT_ACK: case RARCH_DISPLAY_CTL_UNSET_VIDEO_CACHE_CONTEXT_ACK:
video_cache_context_ack = false; video_driver_cache_context_ack = false;
break; break;
case RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT_ACK: case RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT_ACK:
return video_cache_context_ack; return video_driver_cache_context_ack;
case RARCH_DISPLAY_CTL_SET_ACTIVE: case RARCH_DISPLAY_CTL_SET_ACTIVE:
video_active = true; video_driver_active = true;
break; break;
case RARCH_DISPLAY_CTL_UNSET_ACTIVE: case RARCH_DISPLAY_CTL_UNSET_ACTIVE:
video_active = false; video_driver_active = false;
break; break;
case RARCH_DISPLAY_CTL_IS_ACTIVE: case RARCH_DISPLAY_CTL_IS_ACTIVE:
return video_active; return video_driver_active;
case RARCH_DISPLAY_CTL_NONE: case RARCH_DISPLAY_CTL_NONE:
default: default:
break; break;
@ -1778,7 +1778,7 @@ static bool video_pixel_frame_scale(const void *data,
size_t pitch) size_t pitch)
{ {
static struct retro_perf_counter video_frame_conv = {0}; static struct retro_perf_counter video_frame_conv = {0};
video_pixel_scaler_t *scaler = scaler_ptr; video_pixel_scaler_t *scaler = video_driver_scaler_ptr;
rarch_perf_init(&video_frame_conv, "video_frame_conv"); rarch_perf_init(&video_frame_conv, "video_frame_conv");
@ -1817,7 +1817,6 @@ static bool video_pixel_frame_scale(const void *data,
void video_frame(const void *data, unsigned width, void video_frame(const void *data, unsigned width,
unsigned height, size_t pitch) unsigned height, size_t pitch)
{ {
uint64_t *frame_count = NULL;
unsigned output_width = 0; unsigned output_width = 0;
unsigned output_height = 0; unsigned output_height = 0;
unsigned output_pitch = 0; unsigned output_pitch = 0;
@ -1825,12 +1824,12 @@ void video_frame(const void *data, unsigned width,
global_t *global = global_get_ptr(); global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
if (!video_active) if (!video_driver_active)
return; return;
if (video_pixel_frame_scale(data, width, height, pitch)) if (video_pixel_frame_scale(data, width, height, pitch))
{ {
video_pixel_scaler_t *scaler = scaler_ptr; video_pixel_scaler_t *scaler = video_driver_scaler_ptr;
data = scaler->scaler_out; data = scaler->scaler_out;
pitch = scaler->scaler->out_stride; pitch = scaler->scaler->out_stride;
@ -1859,47 +1858,45 @@ void video_frame(const void *data, unsigned width,
msg = rarch_main_msg_queue_pull(); msg = rarch_main_msg_queue_pull();
*current_msg = 0; *video_driver_current_msg = 0;
if (msg) if (msg)
strlcpy(current_msg, msg, sizeof(current_msg)); strlcpy(video_driver_current_msg, msg, sizeof(video_driver_current_msg));
video_driver_ctl(RARCH_DISPLAY_CTL_GET_FRAME_COUNT, &frame_count);
if (!current_video->frame( if (!current_video->frame(
video_data, data, width, height, *frame_count, video_driver_data, data, width, height, video_driver_frame_count,
pitch, current_msg)) pitch, video_driver_current_msg))
video_active = false; video_driver_active = false;
*frame_count = *frame_count + 1; video_driver_frame_count++;
} }
void video_driver_display_type_set(enum rarch_display_type type) void video_driver_display_type_set(enum rarch_display_type type)
{ {
display_type = type; video_driver_display_type = type;
} }
uintptr_t video_driver_display_get(void) uintptr_t video_driver_display_get(void)
{ {
return video_display; return video_driver_display;
} }
void video_driver_display_set(uintptr_t idx) void video_driver_display_set(uintptr_t idx)
{ {
video_display = idx; video_driver_display = idx;
} }
enum rarch_display_type video_driver_display_type_get(void) enum rarch_display_type video_driver_display_type_get(void)
{ {
return display_type; return video_driver_display_type;
} }
void video_driver_window_set(uintptr_t idx) void video_driver_window_set(uintptr_t idx)
{ {
video_window = idx; video_driver_window = idx;
} }
uintptr_t video_driver_window_get(void) uintptr_t video_driver_window_get(void)
{ {
return video_window; return video_driver_window;
} }