Remove unneeded video_driver_set_gpu_device_string/get_gpu_device_string

LibretroAdmin · LibretroAdmin · commit bef29c466b60 · 2023-09-06T03:08:48.000+02:00
diff --git a/gfx/common/gl2_common.h b/gfx/common/gl2_common.h
@@ -254,6 +254,7 @@ struct gl2
    struct video_tex_info prev_info[GFX_MAX_TEXTURES]; /* unsigned alignment */
    struct video_fbo_rect fbo_rect[GFX_MAX_SHADERS];   /* unsigned alignment */
 
+   char device_str[128];
    bool pbo_readback_valid[4];
 };
 
diff --git a/gfx/common/vulkan_common.c b/gfx/common/vulkan_common.c
@@ -175,7 +175,7 @@ static void vulkan_emulated_mailbox_loop(void *userdata)
 {
    VkFence fence;
    VkFenceCreateInfo info;
-   struct vulkan_emulated_mailbox *mailbox = 
+   struct vulkan_emulated_mailbox *mailbox =
       (struct vulkan_emulated_mailbox*)userdata;
 
    if (!mailbox)
@@ -190,7 +190,7 @@ static void vulkan_emulated_mailbox_loop(void *userdata)
    for (;;)
    {
       slock_lock(mailbox->lock);
-      while (   !(mailbox->flags & VK_MAILBOX_FLAG_DEAD) 
+      while (   !(mailbox->flags & VK_MAILBOX_FLAG_DEAD)
              && !(mailbox->flags & VK_MAILBOX_FLAG_REQUEST_ACQUIRE))
          scond_wait(mailbox->cond, mailbox->lock);
 
@@ -207,9 +207,9 @@ static void vulkan_emulated_mailbox_loop(void *userdata)
             mailbox->device, mailbox->swapchain, UINT64_MAX,
             VK_NULL_HANDLE, fence, &mailbox->index);
 #ifdef ANDROID
-      /* VK_SUBOPTIMAL_KHR can be returned on Android 10 
+      /* VK_SUBOPTIMAL_KHR can be returned on Android 10
        * when prerotate is not dealt with.
-       * This is not an error we need to care about, 
+       * This is not an error we need to care about,
        * and we'll treat it as SUCCESS. */
       if (mailbox->result == VK_SUBOPTIMAL_KHR)
          mailbox->result = VK_SUCCESS;
@@ -569,7 +569,7 @@ static bool vulkan_context_init_device(gfx_ctx_vulkan_data_t *vk)
 
    unsigned enabled_device_extension_count = 0;
 
-   struct retro_hw_render_context_negotiation_interface_vulkan 
+   struct retro_hw_render_context_negotiation_interface_vulkan
                                     *iface = (struct retro_hw_render_context_negotiation_interface_vulkan*)
                                     video_st->hw_render_context_negotiation;
 
@@ -593,7 +593,7 @@ static bool vulkan_context_init_device(gfx_ctx_vulkan_data_t *vk)
 
    if (iface)
    {
-      if (iface->interface_type != RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN) 
+      if (iface->interface_type != RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN)
       {
          RARCH_WARN("[Vulkan]: Got HW context negotiation interface, but it's the wrong API.\n");
          iface = NULL;
@@ -713,29 +713,14 @@ static bool vulkan_context_init_device(gfx_ctx_vulkan_data_t *vk)
    RARCH_LOG("[Vulkan]: Using GPU: \"%s\".\n", vk->context.gpu_properties.deviceName);
 
    {
-      char device_str[128];
       char version_str[128];
-      size_t len            = strlcpy(device_str, vk->context.gpu_properties.deviceName, sizeof(device_str));
-      device_str[len  ]     = ' ';
-      device_str[++len]     = '\0';
-
-      len                  += snprintf(device_str + len, sizeof(device_str) - len, "%u", VK_VERSION_MAJOR(vk->context.gpu_properties.driverVersion));
-      device_str[len  ]     = '.';
-      device_str[++len]     = '\0';
-      len                  += snprintf(device_str + len, sizeof(device_str) - len, "%u", VK_VERSION_MINOR(vk->context.gpu_properties.driverVersion));
-      device_str[len  ]     = '.';
-      device_str[++len]     = '\0';
-      snprintf(device_str + len, sizeof(device_str) - len, "%u", VK_VERSION_PATCH(vk->context.gpu_properties.driverVersion));
-
-      len                   = snprintf(version_str      , sizeof(version_str)      , "%u", VK_VERSION_MAJOR(vk->context.gpu_properties.apiVersion));
-      version_str[len  ]    = '.';
+      size_t len            = snprintf(version_str      , sizeof(version_str)      , "%u", VK_VERSION_MAJOR(vk->context.gpu_properties.apiVersion));
+      version_str[  len]    = '.';
       version_str[++len]    = '\0';
       len                  += snprintf(version_str + len, sizeof(version_str) - len, "%u", VK_VERSION_MINOR(vk->context.gpu_properties.apiVersion));
-      version_str[len  ]    = '.';
+      version_str[  len]    = '.';
       version_str[++len]    = '\0';
       snprintf(version_str + len, sizeof(version_str) - len, "%u", VK_VERSION_PATCH(vk->context.gpu_properties.apiVersion));
-
-      video_driver_set_gpu_device_string(device_str);
       video_driver_set_gpu_api_version_string(version_str);
    }
 
@@ -1126,7 +1111,7 @@ static bool vulkan_create_display_surface(gfx_ctx_vulkan_data_t *vk,
          vkGetDisplayPlaneCapabilitiesKHR(vk->context.gpu,
                best_mode, i, &plane_caps);
 
-         if (    plane_caps.supportedAlpha 
+         if (    plane_caps.supportedAlpha
                & VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR)
          {
             best_plane = j;
@@ -1257,7 +1242,7 @@ static VkSemaphore vulkan_get_wsi_acquire_semaphore(struct vulkan_context *ctx)
    if (ctx->num_recycled_acquire_semaphores == 0)
    {
       VkSemaphoreCreateInfo sem_info;
-      
+
       sem_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
       sem_info.pNext = NULL;
       sem_info.flags = 0;
@@ -1756,7 +1741,7 @@ void vulkan_acquire_next_image(gfx_ctx_vulkan_data_t *vk)
    fence_info.sType               = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
    fence_info.pNext               = NULL;
    fence_info.flags               = 0;
-   
+
    sem_info.sType                 = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
    sem_info.pNext                 = NULL;
    sem_info.flags                 = 0;
@@ -1811,9 +1796,9 @@ void vulkan_acquire_next_image(gfx_ctx_vulkan_data_t *vk)
             vk->swapchain, UINT64_MAX,
             semaphore, fence, &vk->context.current_swapchain_index);
 #ifdef ANDROID
-      /* VK_SUBOPTIMAL_KHR can be returned on Android 10 
+      /* VK_SUBOPTIMAL_KHR can be returned on Android 10
        * when prerotate is not dealt with.
-       * This is not an error we need to care about, and 
+       * This is not an error we need to care about, and
        * we'll treat it as SUCCESS. */
       if (err == VK_SUBOPTIMAL_KHR)
          err = VK_SUCCESS;
@@ -1973,7 +1958,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
             &&   (vk->mailbox.swapchain != VK_NULL_HANDLE))
       {
          VkResult res = VK_SUCCESS;
-         /* We are tearing down, and entering a state 
+         /* We are tearing down, and entering a state
           * where we are supposed to have
           * acquired an image, so block until we have acquired. */
          if (! (vk->context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
@@ -2026,7 +2011,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
    vk->context.swap_interval = swap_interval;
    for (i = 0; i < present_mode_count; i++)
    {
-      if (     !swap_interval 
+      if (     !swap_interval
             && (present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR))
       {
          swapchain_present_mode = VK_PRESENT_MODE_MAILBOX_KHR;
@@ -2038,7 +2023,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
          swapchain_present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
          break;
       }
-      else if ( swap_interval 
+      else if ( swap_interval
             && (present_modes[i] == VK_PRESENT_MODE_FIFO_KHR))
       {
          /* Kind of tautological since FIFO must always be present. */
@@ -2058,7 +2043,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
          vk->vk_surface, &format_count, formats);
 
    format.format = VK_FORMAT_UNDEFINED;
-   if (     format_count == 1 
+   if (     format_count == 1
          && (formats[0].format == VK_FORMAT_UNDEFINED))
    {
       format        = formats[0];
@@ -2070,7 +2055,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
       {
          RARCH_ERR("[Vulkan]: Surface has no formats.\n");
          return false;
-      }  
+      }
 
 #ifdef VULKAN_HDR_SWAPCHAIN
       if (settings->bools.video_hdr_enable)
@@ -2206,7 +2191,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
    info.imageExtent.height     = swapchain_size.height;
    info.imageArrayLayers       = 1;
    info.imageUsage             =  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
-	   			| VK_IMAGE_USAGE_TRANSFER_SRC_BIT 
+	   			| VK_IMAGE_USAGE_TRANSFER_SRC_BIT
 				| VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    info.imageSharingMode       = VK_SHARING_MODE_EXCLUSIVE;
    info.queueFamilyIndexCount  = 0;
@@ -2298,7 +2283,7 @@ bool vulkan_context_init(gfx_ctx_vulkan_data_t *vk,
    PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
    const char *prog_name          = NULL;
    video_driver_state_t *video_st = video_state_get_ptr();
-   struct retro_hw_render_context_negotiation_interface_vulkan 
+   struct retro_hw_render_context_negotiation_interface_vulkan
                            *iface = (struct retro_hw_render_context_negotiation_interface_vulkan*)video_st->hw_render_context_negotiation;
 
    if (iface && iface->interface_type != RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN)
@@ -2418,8 +2403,8 @@ bool vulkan_context_init(gfx_ctx_vulkan_data_t *vk,
    }
    else
    {
-      if (     iface 
-            && iface->interface_version >= 2 
+      if (     iface
+            && iface->interface_version >= 2
             && iface->create_instance)
          vk->context.instance = iface->create_instance(
                GetInstanceProcAddr, &app,
@@ -2495,7 +2480,7 @@ void vulkan_context_destroy(gfx_ctx_vulkan_data_t *vk,
 
    vulkan_destroy_swapchain(vk);
 
-   if (     destroy_surface 
+   if (     destroy_surface
          && (vk->vk_surface != VK_NULL_HANDLE))
    {
       vkDestroySurfaceKHR(vk->context.instance,
@@ -2570,9 +2555,9 @@ void vulkan_present(gfx_ctx_vulkan_data_t *vk, unsigned index)
    err = vkQueuePresentKHR(vk->context.queue, &present);
 
 #ifdef ANDROID
-   /* VK_SUBOPTIMAL_KHR can be returned on 
+   /* VK_SUBOPTIMAL_KHR can be returned on
     * Android 10 when prerotate is not dealt with.
-    * This is not an error we need to care about, 
+    * This is not an error we need to care about,
     * and we'll treat it as SUCCESS. */
    if (result == VK_SUBOPTIMAL_KHR)
       result = VK_SUCCESS;
diff --git a/gfx/drivers/d3d10.c b/gfx/drivers/d3d10.c
@@ -2011,7 +2011,6 @@ static void *d3d10_gfx_init(const video_info_t* video,
          d3d10->current_adapter = d3d10->adapters[gpu_index];
          d3d10->adapter         = d3d10->current_adapter;
          RARCH_LOG("[D3D10]: Using GPU index %d.\n", gpu_index);
-         video_driver_set_gpu_device_string(d3d10->gpu_list->elems[gpu_index].data);
       }
       else
       {
diff --git a/gfx/drivers/d3d11.c b/gfx/drivers/d3d11.c
@@ -2620,7 +2620,6 @@ static void *d3d11_gfx_init(const video_info_t* video,
          d3d11->current_adapter = d3d11->adapters[gpu_index];
          d3d11->adapter         = d3d11->current_adapter;
          RARCH_LOG("[D3D11]: Using GPU index %d.\n", gpu_index);
-         video_driver_set_gpu_device_string(d3d11->gpu_list->elems[gpu_index].data);
       }
       else
       {
diff --git a/gfx/drivers/d3d12.c b/gfx/drivers/d3d12.c
@@ -2506,8 +2506,6 @@ static void d3d12_init_base(d3d12_video_t* d3d12)
          d3d12->adapter = d3d12->adapters[gpu_index];
          AddRef(d3d12->adapter);
          RARCH_LOG("[D3D12]: Using GPU index %d.\n", gpu_index);
-         video_driver_set_gpu_device_string(
-               d3d12->gpu_list->elems[gpu_index].data);
       }
       else
       {
diff --git a/gfx/drivers/d3d9cg.c b/gfx/drivers/d3d9cg.c
@@ -1929,11 +1929,8 @@ static bool d3d9_cg_init_internal(d3d9_video_t *d3d,
             LOWORD(ident.DriverVersion.HighPart),
             HIWORD(ident.DriverVersion.LowPart),
             LOWORD(ident.DriverVersion.LowPart));
-
       RARCH_LOG("[D3D9]: Using GPU: \"%s\".\n", ident.Description);
       RARCH_LOG("[D3D9]: GPU API Version: %s\n", version_str);
-
-      video_driver_set_gpu_device_string(ident.Description);
       video_driver_set_gpu_api_version_string(version_str);
    }
 
diff --git a/gfx/drivers/d3d9hlsl.c b/gfx/drivers/d3d9hlsl.c
@@ -1516,8 +1516,6 @@ static bool d3d9_hlsl_init_internal(d3d9_video_t *d3d,
 
       RARCH_LOG("[D3D9]: Using GPU: \"%s\".\n", ident.Description);
       RARCH_LOG("[D3D9]: GPU API Version: %s\n", version_str);
-
-      video_driver_set_gpu_device_string(ident.Description);
       video_driver_set_gpu_api_version_string(version_str);
    }
 
diff --git a/gfx/drivers/gl1.c b/gfx/drivers/gl1.c
@@ -1115,26 +1115,8 @@ static void *gl1_init(const video_info_t *video,
    RARCH_LOG("[GL1]: Version: %s.\n", version);
    RARCH_LOG("[GL1]: Extensions: %s\n", extensions);
 
-   {
-      char device_str[128];
-      size_t len    = 0;
-      device_str[0] = '\0';
-
-      if (!string_is_empty(vendor))
-      {
-         len               = strlcpy(device_str, vendor, sizeof(device_str));
-         device_str[  len] = ' ';
-         device_str[++len] = '\0';
-      }
-
-      if (!string_is_empty(renderer))
-         strlcpy(device_str + len, renderer, sizeof(device_str) - len);
-
-      video_driver_set_gpu_device_string(device_str);
-
-      if (!string_is_empty(version))
-         video_driver_set_gpu_api_version_string(version);
-   }
+   if (!string_is_empty(version))
+      video_driver_set_gpu_api_version_string(version);
 
    if (gl1->ctx_driver->input_driver)
    {
diff --git a/gfx/drivers/gl2.c b/gfx/drivers/gl2.c
@@ -420,7 +420,8 @@ static void gfx_display_gl2_blend_end(void *data)
 
 #ifdef MALI_BUG
 static bool
-gfx_display_gl2_discard_draw_rectangle(gfx_display_ctx_draw_t *draw,
+gfx_display_gl2_discard_draw_rectangle(gl2_t *gl,
+      gfx_display_ctx_draw_t *draw,
       unsigned width, unsigned height)
 {
    static bool mali_4xx_detected     = false;
@@ -431,20 +432,15 @@ gfx_display_gl2_discard_draw_rectangle(gfx_display_ctx_draw_t *draw,
    if (!scissor_inited)
    {
       unsigned i;
-      const char *gpu_device_string = NULL;
       scissor_inited                = true;
+      const char *gpu_device_string = gl->device_string;
 
       scissor_set_rectangle(0,
             width - 1,
             0,
             height - 1,
             0);
 
-      /* TODO/FIXME - This might be thread unsafe in the long run -
-       * preferably call this once outside of the menu display driver
-       * and then just pass this string as a parameter */
-      gpu_device_string = video_driver_get_gpu_device_string();
-
       if (gpu_device_string)
       {
          for (i = 0; scissor_device_strings[i].len; ++i)
@@ -503,7 +499,7 @@ static void gfx_display_gl2_draw(gfx_display_ctx_draw_t *draw,
       return;
 
 #ifdef MALI_BUG
-   if (gfx_display_gl2_discard_draw_rectangle(draw, video_width,
+   if (gfx_display_gl2_discard_draw_rectangle(gl, draw, video_width,
             video_height))
    {
       /*RARCH_WARN("[Menu]: discarded draw rect: %.4i %.4i %.4i %.4i\n",
@@ -4323,21 +4319,17 @@ static void *gl2_init(const video_info_t *video,
       sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);
 
    {
-      char device_str[128];
       size_t len    = 0;
-      device_str[0] = '\0';
 
       if (!string_is_empty(vendor))
       {
-        len               = strlcpy(device_str, vendor, sizeof(device_str));
-        device_str[  len] = ' ';
-        device_str[++len] = '\0';
+        len                    = strlcpy(gl->device_str, vendor, sizeof(gl->device_str));
+        gl->device_str[  len]  = ' ';
+        gl->device_str[++len]  = '\0';
       }
 
       if (!string_is_empty(renderer))
-        strlcpy(device_str + len, renderer, sizeof(device_str) - len);
-
-      video_driver_set_gpu_device_string(device_str);
+        strlcpy(gl->device_str + len, renderer, sizeof(gl->device_str) - len);
 
       if (!string_is_empty(version))
         video_driver_set_gpu_api_version_string(version);
diff --git a/gfx/drivers/gl3.c b/gfx/drivers/gl3.c
@@ -1875,16 +1875,7 @@ static void *gl3_init(const video_info_t *video,
    if (!string_is_empty(version))
       sscanf(version, "%u.%u", &gl->version_major, &gl->version_minor);
 
-   {
-      char device_str[128];
-      size_t len        = strlcpy(device_str, vendor, sizeof(device_str));
-      device_str[  len] = ' ';
-      device_str[++len] = '\0';
-      strlcpy(device_str + len, renderer, sizeof(device_str) - len);
-
-      video_driver_set_gpu_device_string(device_str);
-      video_driver_set_gpu_api_version_string(version);
-   }
+   video_driver_set_gpu_api_version_string(version);
 
 #ifdef _WIN32
    if (   string_is_equal(vendor,   "Microsoft Corporation"))
diff --git a/gfx/gfx_thumbnail_path.c b/gfx/gfx_thumbnail_path.c
diff --git a/gfx/video_crt_switch.c b/gfx/video_crt_switch.c
diff --git a/gfx/video_driver.c b/gfx/video_driver.c
diff --git a/gfx/video_driver.h b/gfx/video_driver.h

Original file line number	Diff line number	Diff line change
`@@ -2011,7 +2011,6 @@ static void d3d10_gfx_init(const video_info_t video,`
`2011`	`2011`	`d3d10->current_adapter = d3d10->adapters[gpu_index];`
`2012`	`2012`	`d3d10->adapter = d3d10->current_adapter;`
`2013`	`2013`	`RARCH_LOG("[D3D10]: Using GPU index %d.\n", gpu_index);`
`2014`		`- video_driver_set_gpu_device_string(d3d10->gpu_list->elems[gpu_index].data);`
`2015`	`2014`	`}`
`2016`	`2015`	`else`
`2017`	`2016`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2620,7 +2620,6 @@ static void d3d11_gfx_init(const video_info_t video,`
`2620`	`2620`	`d3d11->current_adapter = d3d11->adapters[gpu_index];`
`2621`	`2621`	`d3d11->adapter = d3d11->current_adapter;`
`2622`	`2622`	`RARCH_LOG("[D3D11]: Using GPU index %d.\n", gpu_index);`
`2623`		`- video_driver_set_gpu_device_string(d3d11->gpu_list->elems[gpu_index].data);`
`2624`	`2623`	`}`
`2625`	`2624`	`else`
`2626`	`2625`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2506,8 +2506,6 @@ static void d3d12_init_base(d3d12_video_t* d3d12)`
`2506`	`2506`	`d3d12->adapter = d3d12->adapters[gpu_index];`
`2507`	`2507`	`AddRef(d3d12->adapter);`
`2508`	`2508`	`RARCH_LOG("[D3D12]: Using GPU index %d.\n", gpu_index);`
`2509`		`- video_driver_set_gpu_device_string(`
`2510`		`- d3d12->gpu_list->elems[gpu_index].data);`
`2511`	`2509`	`}`
`2512`	`2510`	`else`
`2513`	`2511`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1516,8 +1516,6 @@ static bool d3d9_hlsl_init_internal(d3d9_video_t *d3d,`
`1516`	`1516`
`1517`	`1517`	`RARCH_LOG("[D3D9]: Using GPU: \"%s\".\n", ident.Description);`
`1518`	`1518`	`RARCH_LOG("[D3D9]: GPU API Version: %s\n", version_str);`
`1519`		`-`
`1520`		`- video_driver_set_gpu_device_string(ident.Description);`
`1521`	`1519`	`video_driver_set_gpu_api_version_string(version_str);`
`1522`	`1520`	`}`
`1523`	`1521`