Move hw_render_callbakc to video driver state and take it out

of global state

command_event.c

@@ -1081,21 +1081,25 @@ bool event_command(enum event_command cmd)
          rarch_main_set_state(RARCH_ACTION_STATE_QUIT);
          break;
       case EVENT_CMD_REINIT:
-         driver->video_cache_context = 
+         {
-            global->system.hw_render_callback.cache_context;
+            const struct retro_hw_render_callback *hw_render =
-         driver->video_cache_context_ack = false;
+               (const struct retro_hw_render_callback*)video_driver_callback();
-         event_command(EVENT_CMD_RESET_CONTEXT);
-         driver->video_cache_context = false;
 
-         /* Poll input to avoid possibly stale data to corrupt things. */
+            driver->video_cache_context     = hw_render->cache_context;
-         input_driver_poll();
+            driver->video_cache_context_ack = false;
+            event_command(EVENT_CMD_RESET_CONTEXT);
+            driver->video_cache_context     = false;
+
+            /* Poll input to avoid possibly stale data to corrupt things. */
+            input_driver_poll();
 
 #ifdef HAVE_MENU
-         menu_display_fb_set_dirty();
+            menu_display_fb_set_dirty();
 
-         if (menu_driver_alive())
+            if (menu_driver_alive())
-            event_command(EVENT_CMD_VIDEO_SET_BLOCKING_STATE);
+               event_command(EVENT_CMD_VIDEO_SET_BLOCKING_STATE);
 #endif
+         }
          break;
       case EVENT_CMD_CHEATS_DEINIT:
          if (!global)

driver.c

@@ -383,13 +383,16 @@ void init_drivers(int flags)
 
    if (flags & DRIVER_VIDEO)
    {
+      const struct retro_hw_render_callback *hw_render = 
+         (const struct retro_hw_render_callback*)video_driver_callback();
+
       video_monitor_reset();
 
       init_video();
 
       if (!driver->video_cache_context_ack
-            && global->system.hw_render_callback.context_reset)
+            && hw_render->context_reset)
-         global->system.hw_render_callback.context_reset();
+         hw_render->context_reset();
       driver->video_cache_context_ack = false;
 
       global->system.frame_time_last = 0;
@@ -469,11 +472,11 @@ void uninit_drivers(int flags)
 
    if (flags & DRIVER_VIDEO)
    {
-      global_t *global = global_get_ptr();
+      const struct retro_hw_render_callback *hw_render = 
+         (const struct retro_hw_render_callback*)video_driver_callback();
 
-      if (global->system.hw_render_callback.context_destroy &&
+      if (hw_render->context_destroy && !driver->video_cache_context)
-               !driver->video_cache_context)
+            hw_render->context_destroy();
-            global->system.hw_render_callback.context_destroy();
    }
 
    if ((flags & DRIVER_VIDEO) && !driver->video_data_own)

dynamic.c

@@ -805,6 +805,7 @@ bool rarch_environment_cb(unsigned cmd, void *data)
       case RETRO_ENVIRONMENT_SET_HW_RENDER:
       case RETRO_ENVIRONMENT_SET_HW_RENDER | RETRO_ENVIRONMENT_EXPERIMENTAL:
       {
+         struct retro_hw_render_callback *hw_render = video_driver_callback();
          struct retro_hw_render_callback *cb = 
             (struct retro_hw_render_callback*)data;
 
@@ -866,10 +867,10 @@ bool rarch_environment_cb(unsigned cmd, void *data)
          cb->get_proc_address        = video_driver_get_proc_address;
 
          if (cmd & RETRO_ENVIRONMENT_EXPERIMENTAL) /* Old ABI. Don't copy garbage. */
-            memcpy(&global->system.hw_render_callback,
+            memcpy(hw_render,
                   cb, offsetof(struct retro_hw_render_callback, stencil));
          else
-            memcpy(&global->system.hw_render_callback, cb, sizeof(*cb));
+            memcpy(hw_render, cb, sizeof(*cb));
          break;
       }
 

gfx/drivers/gl.c

@@ -666,7 +666,8 @@ static bool gl_init_hw_render(gl_t *gl, unsigned width, unsigned height)
    unsigned i;
    bool depth = false, stencil = false;
    GLint max_fbo_size = 0, max_renderbuffer_size = 0;
-   global_t *global = global_get_ptr();
+   const struct retro_hw_render_callback *hw_render =
+      (const struct retro_hw_render_callback*)video_driver_callback();
 
    /* We can only share texture objects through contexts.
     * FBOs are "abstract" objects and are not shared. */
@@ -684,8 +685,8 @@ static bool gl_init_hw_render(gl_t *gl, unsigned width, unsigned height)
    glBindTexture(GL_TEXTURE_2D, 0);
    glGenFramebuffers(gl->textures, gl->hw_render_fbo);
 
-   depth   = global->system.hw_render_callback.depth;
+   depth   = hw_render->depth;
-   stencil = global->system.hw_render_callback.stencil;
+   stencil = hw_render->stencil;
 
 #ifdef HAVE_OPENGLES2
    if (stencil && !gl_query_extension(gl, "OES_packed_depth_stencil"))
@@ -1850,20 +1851,19 @@ static void gl_set_nonblock_state(void *data, bool state)
 static bool resolve_extensions(gl_t *gl, const char *context_ident)
 {
    driver_t *driver     = driver_get_ptr();
-   global_t *global     = global_get_ptr();
    settings_t *settings = config_get_ptr();
    const char *vendor   = (const char*)glGetString(GL_VENDOR);
    const char *renderer = (const char*)glGetString(GL_RENDERER);
    const char *version  = (const char*)glGetString(GL_VERSION);
+   const struct retro_hw_render_callback *hw_render =
+      (const struct retro_hw_render_callback*)video_driver_callback();
     
-   (void)global;
    (void)vendor;
    (void)renderer;
    (void)version;
 #ifndef HAVE_OPENGLES
    gl->core_context     = 
-      (global->system.hw_render_callback.context_type 
+      (hw_render->context_type == RETRO_HW_CONTEXT_OPENGL_CORE);
-       == RETRO_HW_CONTEXT_OPENGL_CORE);
    
    if (gl->core_context)
    {
@@ -2072,10 +2072,8 @@ static void gl_init_pbo_readback(gl_t *gl)
 
 static const gfx_ctx_driver_t *gl_get_context(gl_t *gl)
 {
-   global_t *global = global_get_ptr();
    const struct retro_hw_render_callback *cb = 
-      (const struct retro_hw_render_callback*)
+      (const struct retro_hw_render_callback*)video_driver_callback();
-      &global->system.hw_render_callback;
    unsigned major = cb->version_major;
    unsigned minor = cb->version_minor;
    settings_t *settings = config_get_ptr();
@@ -2253,7 +2251,6 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
    const char *version                = NULL;
    struct retro_hw_render_callback *hw_render = NULL;
    settings_t *settings               = config_get_ptr();
-   global_t   *global                 = global_get_ptr();
    driver_t                   *driver = driver_get_ptr();
 
    gl = (gl_t*)calloc(1, sizeof(gl_t));
@@ -2334,7 +2331,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
       gl->full_y = temp_height;
    }
 
-   hw_render         = &global->system.hw_render_callback;
+   hw_render         = video_driver_callback();
    gl->vertex_ptr    = hw_render->bottom_left_origin ? vertexes : vertexes_flipped;
 
    /* Better pipelining with GPU due to synchronous glSubTexImage.

gfx/drivers_context/drm_egl_ctx.c

@@ -600,7 +600,9 @@ static EGLint *egl_fill_attribs(EGLint *attr)
          bool debug       = true;
 #else
          global_t *global = global_get_ptr();
-         bool debug       = global->system.hw_render_callback.debug_context;
+         const struct retro_hw_render_callback *hw_render = 
+            (const struct retro_hw_render_callback*)video_driver_callback();
+         bool debug       = hw_render->debug_context;
 #endif
 
          if (core)

gfx/drivers_context/glx_ctx.c

@@ -347,7 +347,8 @@ static bool gfx_ctx_glx_init(void *data)
    GLXFBConfig *fbcs       = NULL;
    gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)calloc(1, sizeof(gfx_ctx_glx_data_t));
    driver_t *driver        = driver_get_ptr();
-   global_t *global        = global_get_ptr();
+   const struct retro_hw_render_callback *hw_render =
+      (const struct retro_hw_render_callback*)video_driver_callback();
 
    if (!glx)
       return false;
@@ -373,7 +374,7 @@ static bool gfx_ctx_glx_init(void *data)
 #ifdef GL_DEBUG
    glx->g_debug = true;
 #else
-   glx->g_debug = global->system.hw_render_callback.debug_context;
+   glx->g_debug = hw_render->debug_context;
 #endif
 
    /* Have to use ContextAttribs */

gfx/drivers_context/wayland_ctx.c

@@ -522,8 +522,9 @@ static EGLint *egl_fill_attribs(EGLint *attr)
 #ifdef GL_DEBUG
          bool debug = true;
 #else
-         global_t *global = global_get_ptr();
+         const struct retro_hw_render_callback *hw_render =
-         bool debug = global->system.hw_render_callback.debug_context;
+            (const struct retro_hw_render_callback*)video_driver_callback();
+         bool debug = hw_render->debug_context;
 #endif
 
          if (core)

gfx/drivers_context/wgl_ctx.c

@@ -107,9 +107,10 @@ static void setup_pixel_format(HDC hdc)
 static void create_gl_context(HWND hwnd)
 {
    bool core_context;
-   global_t *global = global_get_ptr();
+   const struct retro_hw_render_callback *hw_render =
+      (const struct retro_hw_render_callback*)video_driver_callback();
    driver_t *driver = driver_get_ptr();
-   bool debug       = global->system.hw_render_callback.debug_context;
+   bool debug       = hw_render->debug_context;
 
 #ifdef _WIN32
    dll_handle = (HINSTANCE)dylib_load("OpenGL32.dll");

gfx/drivers_context/xegl_ctx.c

@@ -381,10 +381,11 @@ static EGLint *xegl_fill_attribs(EGLint *attr)
 #ifdef EGL_KHR_create_context
       case GFX_CTX_OPENGL_API:
          {
+            const struct retro_hw_render_callback *hw_render =
+               (const struct retro_hw_render_callback*)video_driver_callback();
             unsigned version = g_major * 1000 + g_minor;
-            bool core = version >= 3001;
+            bool core        = version >= 3001;
-            global_t *global = global_get_ptr();
+            bool debug       = hw_render->debug_context;
-            bool debug = global->system.hw_render_callback.debug_context;
 
 #ifdef GL_DEBUG
             debug = true;

gfx/video_driver.c

@@ -31,6 +31,7 @@
 typedef struct video_driver_state
 {
    retro_time_t frame_time_samples[MEASURE_FRAME_TIME_SAMPLES_COUNT];
+   struct retro_hw_render_callback hw_render_callback;
    uint64_t frame_time_samples_count;
 
    unsigned video_width;
@@ -174,7 +175,7 @@ void find_video_driver(void)
    (void)global;
 
 #if defined(HAVE_OPENGL) && defined(HAVE_FBO)
-   if (global->system.hw_render_callback.context_type)
+   if (video_state.hw_render_callback.context_type)
    {
       RARCH_LOG("Using HW render, OpenGL driver forced.\n");
       driver->video = &video_gl;
@@ -229,7 +230,7 @@ void *video_driver_get_ptr(const video_driver_t **drv)
 
 #ifdef HAVE_THREADS
    if (settings->video.threaded
-         && !global->system.hw_render_callback.context_type)
+         && !video_state.hw_render_callback.context_type)
       return rarch_threaded_video_get_ptr(drv);
 #endif
    if (drv)
@@ -362,7 +363,7 @@ static void init_video_filter(enum retro_pixel_format colfmt)
    if (colfmt == RETRO_PIXEL_FORMAT_0RGB1555)
       colfmt = RETRO_PIXEL_FORMAT_RGB565;
 
-   if (global->system.hw_render_callback.context_type)
+   if (video_state.hw_render_callback.context_type)
    {
       RARCH_WARN("Cannot use CPU filters when hardware rendering is used.\n");
       return;
@@ -461,6 +462,7 @@ void uninit_video_input(void)
 
    deinit_video_filter();
 
+   video_driver_unset_callback();
    event_command(EVENT_CMD_SHADER_DIR_DEINIT);
    video_monitor_compute_fps_statistics();
 }
@@ -564,7 +566,7 @@ void init_video(void)
    find_video_driver();
 
 #ifdef HAVE_THREADS
-   if (settings->video.threaded && !global->system.hw_render_callback.context_type)
+   if (settings->video.threaded && !video_state.hw_render_callback.context_type)
    {
       /* Can't do hardware rendering with threaded driver currently. */
       RARCH_LOG("Starting threaded video driver ...\n");
@@ -1108,3 +1110,17 @@ void video_driver_set_aspect_ratio_value(float value)
 {
    video_state.aspect_ratio = value;
 }
+
+struct retro_hw_render_callback *video_driver_callback(void)
+{
+   return &video_state.hw_render_callback;
+}
+
+void video_driver_unset_callback(void)
+{
+   struct retro_hw_render_callback *hw_render =
+      video_driver_callback();
+
+   if (hw_render)
+      hw_render = NULL;
+}

gfx/video_driver.h

@@ -352,6 +352,10 @@ float video_driver_get_aspect_ratio(void);
 
 void video_driver_set_aspect_ratio_value(float value);
 
+struct retro_hw_render_callback *video_driver_callback(void);
+
+void video_driver_unset_callback(void);
+
 #ifdef __cplusplus
 }
 #endif

gfx/video_texture.c

@@ -84,10 +84,10 @@ unsigned video_texture_load(void *data,
       enum texture_filter_type  filter_type)
 {
    settings_t *settings = config_get_ptr();
-   global_t   *global   = global_get_ptr();
+   const struct retro_hw_render_callback *hw_render =
+      (const struct retro_hw_render_callback*)video_driver_callback();
 
-   if (settings->video.threaded
+   if (settings->video.threaded && !hw_render->context_type)
-         && !global->system.hw_render_callback.context_type)
    {
       driver_t     *driver = driver_get_ptr();
       thread_video_t *thr  = (thread_video_t*)driver->video_data;

menu/menu_display.c

@@ -134,10 +134,10 @@ bool menu_display_font_init_first(const void **font_driver,
       float font_size)
 {
    settings_t *settings = config_get_ptr();
-   global_t   *global   = global_get_ptr();
+   const struct retro_hw_render_callback *hw_render =
+      (const struct retro_hw_render_callback*)video_driver_callback();
 
-   if (settings->video.threaded
+   if (settings->video.threaded && !hw_render->context_type)
-         && !global->system.hw_render_callback.context_type)
    {
       driver_t *driver    = driver_get_ptr();
       thread_video_t *thr = (thread_video_t*)driver->video_data;

record/record_driver.c

@@ -292,6 +292,8 @@ bool recording_init(void)
    driver_t *driver     = driver_get_ptr();
    settings_t *settings = config_get_ptr();
    struct retro_system_av_info *av_info = video_viewport_get_system_av_info();
+   const struct retro_hw_render_callback *hw_render = 
+      (const struct retro_hw_render_callback*)video_driver_callback();
 
    if (!global->record.enable)
       return false;
@@ -302,8 +304,7 @@ bool recording_init(void)
       return false;
    }
 
-   if (!settings->video.gpu_record
+   if (!settings->video.gpu_record && hw_render->context_type)
-         && global->system.hw_render_callback.context_type)
    {
       RARCH_WARN("Libretro core is hardware rendered. Must use post-shaded recording as well.\n");
       return false;

runloop.h

@@ -168,7 +168,6 @@ typedef struct global
       retro_keyboard_event_t key_event;
 
       struct retro_disk_control_callback disk_control; 
-      struct retro_hw_render_callback hw_render_callback;
       struct retro_camera_callback camera_callback;
       struct retro_location_callback location_callback;
 

screenshot.c

@@ -262,13 +262,15 @@ bool take_screenshot(void)
    driver_t *driver     = driver_get_ptr();
    settings_t *settings = config_get_ptr();
    global_t *global     = global_get_ptr();
+   const struct retro_hw_render_callback *hw_render = 
+      (const struct retro_hw_render_callback*)video_driver_callback();
 
    /* No way to infer screenshot directory. */
    if ((!*settings->screenshot_directory) && (!*global->basename))
       return false;
 
    viewport_read = (settings->video.gpu_screenshot ||
-         ((global->system.hw_render_callback.context_type
+         ((hw_render->context_type
          != RETRO_HW_CONTEXT_NONE) && !driver->video->read_frame_raw))
          && driver->video->read_viewport && driver->video->viewport_info;