Replaced SDL_GetRendererInfo() with SDL_GetRendererName()

The texture formats are available via the SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER property

Fixes https://github.com/libsdl-org/SDL/issues/9851

docs/README-migration.md

@@ -1143,6 +1143,8 @@ SDL_CreateRenderer()'s flags parameter has been removed. See specific flags belo
 
 SDL_CreateWindowAndRenderer() now takes the window title as the first parameter.
 
+SDL_GetRendererInfo() has been removed, the name of a renderer can be retrieved using SDL_GetRendererName(), and the other information is available as properties on the renderer.
+
 Mouse and touch events are no longer filtered to change their coordinates, instead you
 can call SDL_ConvertEventToRenderCoordinates() to explicitly map event coordinates into
 the rendering viewport.

include/SDL3/SDL_render.h

@@ -70,18 +70,6 @@ extern "C" {
  */
 #define SDL_SOFTWARE_RENDERER   "software"
 
-/**
- * Information on the capabilities of a render driver or context.
- *
- * \since This struct is available since SDL 3.0.0.
- */
-typedef struct SDL_RendererInfo
-{
-    const char *name;           /**< The name of the renderer */
-    int num_texture_formats;    /**< The number of available texture formats */
-    const SDL_PixelFormatEnum *texture_formats; /**< The available texture formats */
-} SDL_RendererInfo;
-
 /**
  * Vertex structure.
  *
@@ -225,7 +213,7 @@ extern SDL_DECLSPEC int SDLCALL SDL_CreateWindowAndRenderer(const char *title, i
  * \sa SDL_DestroyRenderer
  * \sa SDL_GetNumRenderDrivers
  * \sa SDL_GetRenderDriver
- * \sa SDL_GetRendererInfo
+ * \sa SDL_GetRendererName
  */
 extern SDL_DECLSPEC SDL_Renderer * SDLCALL SDL_CreateRenderer(SDL_Window *window, const char *name);
 
@@ -276,7 +264,7 @@ extern SDL_DECLSPEC SDL_Renderer * SDLCALL SDL_CreateRenderer(SDL_Window *window
  * \sa SDL_CreateRenderer
  * \sa SDL_CreateSoftwareRenderer
  * \sa SDL_DestroyRenderer
- * \sa SDL_GetRendererInfo
+ * \sa SDL_GetRendererName
  */
 extern SDL_DECLSPEC SDL_Renderer * SDLCALL SDL_CreateRendererWithProperties(SDL_PropertiesID props);
 
@@ -334,20 +322,19 @@ extern SDL_DECLSPEC SDL_Renderer *SDLCALL SDL_GetRenderer(SDL_Window *window);
 extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_GetRenderWindow(SDL_Renderer *renderer);
 
 /**
- * Get information about a rendering context.
+ * Get the name of a renderer.
+ *
+ * The returned string follows the SDL_GetStringRule.
  *
  * \param renderer the rendering context
- * \param info an SDL_RendererInfo structure filled with information about the
+ * \returns the name of the selected renderer, or NULL if the renderer is invalid.
- *             current renderer
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
  *
  * \since This function is available since SDL 3.0.0.
  *
  * \sa SDL_CreateRenderer
  * \sa SDL_CreateRendererWithProperties
  */
-extern SDL_DECLSPEC int SDLCALL SDL_GetRendererInfo(SDL_Renderer *renderer, SDL_RendererInfo *info);
+extern SDL_DECLSPEC const char *SDLCALL SDL_GetRendererName(SDL_Renderer *renderer);
 
 /**
  * Get the properties associated with a renderer.
@@ -362,6 +349,7 @@ extern SDL_DECLSPEC int SDLCALL SDL_GetRendererInfo(SDL_Renderer *renderer, SDL_
  * - `SDL_PROP_RENDERER_VSYNC_NUMBER`: the current vsync setting
  * - `SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER`: the maximum texture width
  *   and height
+ * - `SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER`: a (const SDL_PixelFormatEnum *) array of pixel formats, terminated with SDL_PIXELFORMAT_UNKNOWN, representing the available texture formats for this renderer.
  * - `SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER`: an SDL_ColorSpace value
  *   describing the colorspace for output to the display, defaults to
  *   SDL_COLORSPACE_SRGB.
@@ -433,6 +421,7 @@ extern SDL_DECLSPEC SDL_PropertiesID SDLCALL SDL_GetRendererProperties(SDL_Rende
 #define SDL_PROP_RENDERER_SURFACE_POINTER                           "SDL.renderer.surface"
 #define SDL_PROP_RENDERER_VSYNC_NUMBER                              "SDL.renderer.vsync"
 #define SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER                   "SDL.renderer.max_texture_size"
+#define SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER                   "SDL.renderer.texture_formats"
 #define SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER                  "SDL.renderer.output_colorspace"
 #define SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN                       "SDL.renderer.HDR_enabled"
 #define SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT                     "SDL.renderer.SDR_white_point"

src/core/winrt/SDL_winrtapp_direct3d.cpp

@@ -137,7 +137,7 @@ static void WINRT_ProcessWindowSizeChange() // TODO: Pass an SDL_Window-identify
             }
 #endif
 
-            const Uint32 latestFlags = WINRT_DetectWindowFlags(window);
+            const SDL_WindowFlags latestFlags = WINRT_DetectWindowFlags(window);
             if (latestFlags & SDL_WINDOW_MAXIMIZED) {
                 SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_MAXIMIZED, 0, 0);
             } else {
@@ -479,7 +479,7 @@ void SDL_WinRTApp::OnVisibilityChanged(CoreWindow ^ sender, VisibilityChangedEve
     m_windowVisible = args->Visible;
     if (WINRT_GlobalSDLWindow) {
         SDL_bool wasSDLWindowSurfaceValid = WINRT_GlobalSDLWindow->surface_valid;
-        Uint32 latestWindowFlags = WINRT_DetectWindowFlags(WINRT_GlobalSDLWindow);
+        SDL_WindowFlags latestWindowFlags = WINRT_DetectWindowFlags(WINRT_GlobalSDLWindow);
         if (args->Visible) {
             SDL_SendWindowEvent(WINRT_GlobalSDLWindow, SDL_EVENT_WINDOW_SHOWN, 0, 0);
             SDL_SendWindowEvent(WINRT_GlobalSDLWindow, SDL_EVENT_WINDOW_FOCUS_GAINED, 0, 0);
@@ -612,7 +612,7 @@ void SDL_WinRTApp::OnSuspending(Platform::Object ^ sender, SuspendingEventArgs ^
 #if SDL_VIDEO_RENDER_D3D11
         if (WINRT_GlobalSDLWindow) {
             SDL_Renderer *renderer = SDL_GetRenderer(WINRT_GlobalSDLWindow);
-            if (renderer && (SDL_strcmp(renderer->info.name, "direct3d11") == 0)) {
+            if (renderer && (SDL_strcmp(renderer->name, "direct3d11") == 0)) {
                 D3D11_Trim(renderer);
             }
         }

src/dynapi/SDL_dynapi.sym

@@ -402,7 +402,7 @@ SDL3_0.0.0 {
     SDL_GetRenderWindow;
     SDL_GetRenderer;
     SDL_GetRendererFromTexture;
-    SDL_GetRendererInfo;
+    SDL_GetRendererName;
     SDL_GetRendererProperties;
     SDL_GetRevision;
     SDL_GetSIMDAlignment;

src/dynapi/SDL_dynapi_overrides.h

@@ -427,7 +427,7 @@
 #define SDL_GetRenderWindow SDL_GetRenderWindow_REAL
 #define SDL_GetRenderer SDL_GetRenderer_REAL
 #define SDL_GetRendererFromTexture SDL_GetRendererFromTexture_REAL
-#define SDL_GetRendererInfo SDL_GetRendererInfo_REAL
+#define SDL_GetRendererName SDL_GetRendererName_REAL
 #define SDL_GetRendererProperties SDL_GetRendererProperties_REAL
 #define SDL_GetRevision SDL_GetRevision_REAL
 #define SDL_GetSIMDAlignment SDL_GetSIMDAlignment_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -447,7 +447,7 @@ SDL_DYNAPI_PROC(int,SDL_GetRenderViewport,(SDL_Renderer *a, SDL_Rect *b),(a,b),r
 SDL_DYNAPI_PROC(SDL_Window*,SDL_GetRenderWindow,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(SDL_Renderer*,SDL_GetRenderer,(SDL_Window *a),(a),return)
 SDL_DYNAPI_PROC(SDL_Renderer*,SDL_GetRendererFromTexture,(SDL_Texture *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetRendererInfo,(SDL_Renderer *a, SDL_RendererInfo *b),(a,b),return)
+SDL_DYNAPI_PROC(const char *,SDL_GetRendererName,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetRendererProperties,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetRevision,(void),(),return)
 SDL_DYNAPI_PROC(size_t,SDL_GetSIMDAlignment,(void),(),return)

src/render/SDL_render.c

@@ -136,12 +136,14 @@ static const SDL_RenderDriver *render_drivers[] = {
 
 int SDL_AddSupportedTextureFormat(SDL_Renderer *renderer, SDL_PixelFormatEnum format)
 {
-    SDL_PixelFormatEnum *texture_formats = (SDL_PixelFormatEnum *)SDL_realloc((void *)renderer->info.texture_formats, (renderer->info.num_texture_formats + 1) * sizeof(SDL_PixelFormatEnum));
+    SDL_PixelFormatEnum *texture_formats = (SDL_PixelFormatEnum *)SDL_realloc((void *)renderer->texture_formats, (renderer->num_texture_formats + 2) * sizeof(SDL_PixelFormatEnum));
     if (!texture_formats) {
         return -1;
     }
-    texture_formats[renderer->info.num_texture_formats++] = format;
+    texture_formats[renderer->num_texture_formats++] = format;
-    renderer->info.texture_formats = texture_formats;
+    texture_formats[renderer->num_texture_formats] = SDL_PIXELFORMAT_UNKNOWN;
+    renderer->texture_formats = texture_formats;
+    SDL_SetProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, texture_formats);
     return 0;
 }
 
@@ -1068,7 +1070,7 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
     }
 
     new_props = SDL_GetRendererProperties(renderer);
-    SDL_SetStringProperty(new_props, SDL_PROP_RENDERER_NAME_STRING, renderer->info.name);
+    SDL_SetStringProperty(new_props, SDL_PROP_RENDERER_NAME_STRING, renderer->name);
     if (window) {
         SDL_SetProperty(new_props, SDL_PROP_RENDERER_WINDOW_POINTER, window);
     }
@@ -1098,7 +1100,7 @@ SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
     SDL_CalculateSimulatedVSyncInterval(renderer, window);
 
     SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,
-                "Created renderer: %s", renderer->info.name);
+                "Created renderer: %s", renderer->name);
 
 #ifdef SDL_PLATFORM_ANDROID
     Android_ActivityMutex_Unlock();
@@ -1115,7 +1117,7 @@ error:
 #ifdef SDL_PLATFORM_ANDROID
     Android_ActivityMutex_Unlock();
 #endif
-    SDL_free((void *)renderer->info.texture_formats);
+    SDL_free(renderer->texture_formats);
     SDL_free(renderer);
     return NULL;
 
@@ -1162,12 +1164,11 @@ SDL_Window *SDL_GetRenderWindow(SDL_Renderer *renderer)
     return renderer->window;
 }
 
-int SDL_GetRendererInfo(SDL_Renderer *renderer, SDL_RendererInfo *info)
+const char *SDL_GetRendererName(SDL_Renderer *renderer)
 {
-    CHECK_RENDERER_MAGIC(renderer, -1);
+    CHECK_RENDERER_MAGIC(renderer, NULL);
 
-    SDL_copyp(info, &renderer->info);
+    return renderer->name;
-    return 0;
 }
 
 SDL_PropertiesID SDL_GetRendererProperties(SDL_Renderer *renderer)
@@ -1227,8 +1228,8 @@ static SDL_bool IsSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormatEnum fo
 {
     int i;
 
-    for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+    for (i = 0; i < renderer->num_texture_formats; ++i) {
-        if (renderer->info.texture_formats[i] == format) {
+        if (renderer->texture_formats[i] == format) {
             return SDL_TRUE;
         }
     }
@@ -1241,36 +1242,36 @@ static Uint32 GetClosestSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormatE
 
     if (SDL_ISPIXELFORMAT_FOURCC(format)) {
         /* Look for an exact match */
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (renderer->info.texture_formats[i] == format) {
+            if (renderer->texture_formats[i] == format) {
-                return renderer->info.texture_formats[i];
+                return renderer->texture_formats[i];
             }
         }
     } else if (SDL_ISPIXELFORMAT_10BIT(format) || SDL_ISPIXELFORMAT_FLOAT(format)) {
         if (SDL_ISPIXELFORMAT_10BIT(format)) {
-            for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+            for (i = 0; i < renderer->num_texture_formats; ++i) {
-                if (SDL_ISPIXELFORMAT_10BIT(renderer->info.texture_formats[i])) {
+                if (SDL_ISPIXELFORMAT_10BIT(renderer->texture_formats[i])) {
-                    return renderer->info.texture_formats[i];
+                    return renderer->texture_formats[i];
                 }
             }
         }
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (SDL_ISPIXELFORMAT_FLOAT(renderer->info.texture_formats[i])) {
+            if (SDL_ISPIXELFORMAT_FLOAT(renderer->texture_formats[i])) {
-                return renderer->info.texture_formats[i];
+                return renderer->texture_formats[i];
             }
         }
     } else {
         SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);
 
         /* We just want to match the first format that has the same channels */
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
+            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->texture_formats[i]) &&
-                SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == hasAlpha) {
+                SDL_ISPIXELFORMAT_ALPHA(renderer->texture_formats[i]) == hasAlpha) {
-                return renderer->info.texture_formats[i];
+                return renderer->texture_formats[i];
             }
         }
     }
-    return renderer->info.texture_formats[0];
+    return renderer->texture_formats[0];
 }
 
 SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_PropertiesID props)
@@ -1286,7 +1287,7 @@ SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_Propert
     CHECK_RENDERER_MAGIC(renderer, NULL);
 
     if (!format) {
-        format = renderer->info.texture_formats[0];
+        format = renderer->texture_formats[0];
     }
     if (SDL_BYTESPERPIXEL(format) == 0) {
         SDL_SetError("Invalid texture format");
@@ -1356,7 +1357,7 @@ SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_Propert
         if (!texture_is_fourcc_and_target) {
             closest_format = GetClosestSupportedFormat(renderer, format);
         } else {
-            closest_format = renderer->info.texture_formats[0];
+            closest_format = renderer->texture_formats[0];
         }
 
         SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, texture->colorspace);
@@ -1476,15 +1477,15 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
     /* No alpha, but a colorkey => promote to alpha */
     if (!fmt->Amask && SDL_SurfaceHasColorKey(surface)) {
         if (fmt->format == SDL_PIXELFORMAT_XRGB8888) {
-            for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+            for (i = 0; i < renderer->num_texture_formats; ++i) {
-                if (renderer->info.texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) {
+                if (renderer->texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) {
                     format = SDL_PIXELFORMAT_ARGB8888;
                     break;
                 }
             }
         } else if (fmt->format == SDL_PIXELFORMAT_XBGR8888) {
-            for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+            for (i = 0; i < renderer->num_texture_formats; ++i) {
-                if (renderer->info.texture_formats[i] == SDL_PIXELFORMAT_ABGR8888) {
+                if (renderer->texture_formats[i] == SDL_PIXELFORMAT_ABGR8888) {
                     format = SDL_PIXELFORMAT_ABGR8888;
                     break;
                 }
@@ -1492,8 +1493,8 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
         }
     } else {
         /* Exact match would be fine */
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (renderer->info.texture_formats[i] == fmt->format) {
+            if (renderer->texture_formats[i] == fmt->format) {
                 format = fmt->format;
                 break;
             }
@@ -1502,9 +1503,9 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
 
     /* Look for 10-bit pixel formats if needed */
     if (format == SDL_PIXELFORMAT_UNKNOWN && SDL_ISPIXELFORMAT_10BIT(fmt->format)) {
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (SDL_ISPIXELFORMAT_10BIT(renderer->info.texture_formats[i])) {
+            if (SDL_ISPIXELFORMAT_10BIT(renderer->texture_formats[i])) {
-                format = renderer->info.texture_formats[i];
+                format = renderer->texture_formats[i];
                 break;
             }
         }
@@ -1513,9 +1514,9 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
     /* Look for floating point pixel formats if needed */
     if (format == SDL_PIXELFORMAT_UNKNOWN &&
         (SDL_ISPIXELFORMAT_10BIT(fmt->format) || SDL_ISPIXELFORMAT_FLOAT(fmt->format))) {
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (SDL_ISPIXELFORMAT_FLOAT(renderer->info.texture_formats[i])) {
+            if (SDL_ISPIXELFORMAT_FLOAT(renderer->texture_formats[i])) {
-                format = renderer->info.texture_formats[i];
+                format = renderer->texture_formats[i];
                 break;
             }
         }
@@ -1523,11 +1524,11 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
 
     /* Fallback, choose a valid pixel format */
     if (format == SDL_PIXELFORMAT_UNKNOWN) {
-        format = renderer->info.texture_formats[0];
+        format = renderer->texture_formats[0];
-        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
-            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
+            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->texture_formats[i]) &&
-                SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) {
+                SDL_ISPIXELFORMAT_ALPHA(renderer->texture_formats[i]) == needAlpha) {
-                format = renderer->info.texture_formats[i];
+                format = renderer->texture_formats[i];
                 break;
             }
         }
@@ -4597,7 +4598,7 @@ void SDL_DestroyRenderer(SDL_Renderer *renderer)
         SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, SDL_FALSE);  // It's no longer magical...
     }
 
-    SDL_free((void *)renderer->info.texture_formats);
+    SDL_free(renderer->texture_formats);
     SDL_free(renderer);
 }
 

src/render/SDL_sysrender.h

@@ -214,7 +214,9 @@ struct SDL_Renderer
     int (*AddVulkanRenderSemaphores)(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore);
 
     /* The current renderer info */
-    SDL_RendererInfo info;
+    const char *name;
+    SDL_PixelFormatEnum *texture_formats;
+    int num_texture_formats;
     SDL_bool software;
 
     /* The window associated with the renderer */

src/render/direct3d/SDL_render_d3d.c

@@ -1645,7 +1645,7 @@ int D3D_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propertie
     renderer->driverdata = data;
     D3D_InvalidateCachedState(renderer);
 
-    renderer->info.name = D3D_RenderDriver.name;
+    renderer->name = D3D_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
 
     SDL_GetWindowSizeInPixels(window, &w, &h);

src/render/direct3d11/SDL_render_d3d11.c

@@ -2820,7 +2820,7 @@ static int D3D11_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
     renderer->driverdata = data;
     D3D11_InvalidateCachedState(renderer);
 
-    renderer->info.name = D3D11_RenderDriver.name;
+    renderer->name = D3D11_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR2101010);

src/render/direct3d12/SDL_render_d3d12.c

@@ -3274,7 +3274,7 @@ int D3D12_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Propert
     renderer->driverdata = data;
     D3D12_InvalidateCachedState(renderer);
 
-    renderer->info.name = D3D12_RenderDriver.name;
+    renderer->name = D3D12_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR2101010);

src/render/metal/SDL_render_metal.m

@@ -2147,7 +2147,7 @@ static int METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
         renderer->GetMetalLayer = METAL_GetMetalLayer;
         renderer->GetMetalCommandEncoder = METAL_GetMetalCommandEncoder;
 
-        renderer->info.name = METAL_RenderDriver.name;
+        renderer->name = METAL_RenderDriver.name;
         SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
         SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
         SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR2101010);

src/render/opengl/SDL_render_gl.c

@@ -1675,7 +1675,7 @@ static int GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pro
     GL_InvalidateCachedState(renderer);
     renderer->window = window;
 
-    renderer->info.name = GL_RenderDriver.name;
+    renderer->name = GL_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);

src/render/opengles2/SDL_render_gles2.c

@@ -2095,7 +2095,7 @@ static int GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_
     GLES2_InvalidateCachedState(renderer);
     renderer->window = window;
 
-    renderer->info.name = GLES2_RenderDriver.name;
+    renderer->name = GLES2_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA32);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRA32);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRX32);

src/render/ps2/SDL_render_ps2.c

@@ -699,7 +699,7 @@ static int PS2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
     PS2_InvalidateCachedState(renderer);
     renderer->window = window;
 
-    renderer->info.name = PS2_RenderDriver.name;
+    renderer->name = PS2_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
     SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 1024);

src/render/psp/SDL_render_psp.c

@@ -1326,7 +1326,7 @@ static int PSP_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_Pr
     PSP_InvalidateCachedState(renderer);
     renderer->window = window;
 
-    renderer->info.name = PSP_RenderDriver.name;
+    renderer->name = PSP_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGR565);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR4444);

src/render/software/SDL_render_sw.c

@@ -1158,7 +1158,7 @@ int SW_CreateRendererForSurface(SDL_Renderer *renderer, SDL_Surface *surface, SD
     renderer->driverdata = data;
     SW_InvalidateCachedState(renderer);
 
-    renderer->info.name = SW_RenderDriver.name;
+    renderer->name = SW_RenderDriver.name;
 
     SW_SelectBestFormats(renderer, surface->format->format);
 

src/render/vitagxm/SDL_render_vita_gxm.c

@@ -235,7 +235,7 @@ static int VITA_GXM_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, S
     VITA_GXM_InvalidateCachedState(renderer);
     renderer->window = window;
 
-    renderer->info.name = VITA_GXM_RenderDriver.name;
+    renderer->name = VITA_GXM_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGB565);

src/render/vulkan/SDL_render_vulkan.c

@@ -4101,7 +4101,7 @@ static int VULKAN_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL
     renderer->driverdata = rendererData;
     VULKAN_InvalidateCachedState(renderer);
 
-    renderer->info.name = VULKAN_RenderDriver.name;
+    renderer->name = VULKAN_RenderDriver.name;
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
     SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR2101010);

src/test/SDL_test_common.c

@@ -1034,24 +1034,28 @@ static void SDLTest_PrintScaleMode(char *text, size_t maxlen, SDL_ScaleMode scal
 
 static void SDLTest_PrintRenderer(SDL_Renderer *renderer)
 {
-    SDL_RendererInfo info;
+    const char *name;
     int i;
     char text[1024];
     int max_texture_size;
+    const SDL_PixelFormatEnum *texture_formats;
 
-    SDL_GetRendererInfo(renderer, &info);
+    name = SDL_GetRendererName(renderer);
 
-    SDL_Log("  Renderer %s:\n", info.name);
+    SDL_Log("  Renderer %s:\n", name);
     SDL_Log("    VSync: %d\n", (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, 0));
 
-    (void)SDL_snprintf(text, sizeof(text), "    Texture formats (%d): ", info.num_texture_formats);
+    texture_formats = (const SDL_PixelFormatEnum *)SDL_GetProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, NULL);
-    for (i = 0; i < info.num_texture_formats; ++i) {
+    if (texture_formats) {
+        (void)SDL_snprintf(text, sizeof(text), "    Texture formats: ");
+        for (i = 0; texture_formats[i]; ++i) {
             if (i > 0) {
                 SDL_snprintfcat(text, sizeof(text), ", ");
             }
-        SDLTest_PrintPixelFormat(text, sizeof(text), info.texture_formats[i]);
+            SDLTest_PrintPixelFormat(text, sizeof(text), texture_formats[i]);
         }
         SDL_Log("%s\n", text);
+    }
 
     max_texture_size = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 0);
     if (max_texture_size) {
@@ -2511,7 +2515,7 @@ void SDLTest_CommonDrawWindowInfo(SDL_Renderer *renderer, SDL_Window *window, fl
     float scaleX, scaleY;
     SDL_MouseButtonFlags flags;
     SDL_DisplayID windowDisplayID = SDL_GetDisplayForWindow(window);
-    SDL_RendererInfo info;
+    const char *name;
     SDL_RendererLogicalPresentation logical_presentation;
     SDL_ScaleMode logical_scale_mode;
 
@@ -2535,11 +2539,10 @@ void SDLTest_CommonDrawWindowInfo(SDL_Renderer *renderer, SDL_Window *window, fl
 
     SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
 
-    if (0 == SDL_GetRendererInfo(renderer, &info)) {
+    name = SDL_GetRendererName(renderer);
-        (void)SDL_snprintf(text, sizeof(text), "SDL_GetRendererInfo: name: %s", info.name);
+    (void)SDL_snprintf(text, sizeof(text), "SDL_GetRendererName: %s", name);
     SDLTest_DrawString(renderer, 0.0f, textY, text);
     textY += lineHeight;
-    }
 
     if (0 == SDL_GetRenderOutputSize(renderer, &w, &h)) {
         (void)SDL_snprintf(text, sizeof(text), "SDL_GetRenderOutputSize: %dx%d", w, h);

src/video/SDL_video.c

@@ -281,12 +281,12 @@ static void SDLCALL SDL_CleanupWindowTextureData(void *userdata, void *value)
 
 static int SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window *window, SDL_PixelFormatEnum *format, void **pixels, int *pitch)
 {
-    SDL_RendererInfo info;
     SDL_PropertiesID props = SDL_GetWindowProperties(window);
     SDL_WindowTextureData *data = (SDL_WindowTextureData *)SDL_GetProperty(props, SDL_PROP_WINDOW_TEXTUREDATA_POINTER, NULL);
     const SDL_bool transparent = (window->flags & SDL_WINDOW_TRANSPARENT) ? SDL_TRUE : SDL_FALSE;
     int i;
     int w, h;
+    const SDL_PixelFormatEnum *texture_formats;
 
     SDL_GetWindowSizeInPixels(window, &w, &h);
 
@@ -301,10 +301,7 @@ static int SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window *window, S
         /* Check to see if there's a specific driver requested */
         if (specific_accelerated_renderer) {
             renderer = SDL_CreateRenderer(window, hint);
-            if (!renderer || (SDL_GetRendererInfo(renderer, &info) < 0)) {
+            if (!renderer) {
-                if (renderer) {
-                    SDL_DestroyRenderer(renderer);
-                }
                 return SDL_SetError("Requested renderer for " SDL_HINT_FRAMEBUFFER_ACCELERATION " is not available");
             }
         } else {
@@ -339,7 +336,8 @@ static int SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window *window, S
         data->renderer = renderer;
     }
 
-    if (SDL_GetRendererInfo(data->renderer, &info) < 0) {
+    texture_formats = (const SDL_PixelFormatEnum *)SDL_GetProperty(SDL_GetRendererProperties(data->renderer), SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, NULL);
+    if (!texture_formats) {
         return -1;
     }
 
@@ -352,10 +350,10 @@ static int SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window *window, S
     data->pixels = NULL;
 
     /* Find the first format with or without an alpha channel */
-    *format = info.texture_formats[0];
+    *format = texture_formats[0];
 
-    for (i = 0; i < info.num_texture_formats; ++i) {
+    for (i = 0; texture_formats[i] != SDL_PIXELFORMAT_UNKNOWN; ++i) {
-        SDL_PixelFormatEnum texture_format = info.texture_formats[i];
+        SDL_PixelFormatEnum texture_format = texture_formats[i];
         if (!SDL_ISPIXELFORMAT_FOURCC(texture_format) &&
             !SDL_ISPIXELFORMAT_10BIT(texture_format) &&
             !SDL_ISPIXELFORMAT_FLOAT(texture_format) &&

test/testcolorspace.c

@@ -76,7 +76,6 @@ static void UpdateHDRState(void)
 static void CreateRenderer(void)
 {
     SDL_PropertiesID props;
-    SDL_RendererInfo info;
 
     props = SDL_CreateProperties();
     SDL_SetProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window);
@@ -89,9 +88,8 @@ static void CreateRenderer(void)
         return;
     }
 
-    SDL_GetRendererInfo(renderer, &info);
+    renderer_name = SDL_GetRendererName(renderer);
-    SDL_Log("Created renderer %s\n", info.name);
+    SDL_Log("Created renderer %s\n", renderer_name);
-    renderer_name = info.name;
 
     UpdateHDRState();
 }

test/testffmpeg.c

@@ -111,7 +111,6 @@ static SDL_bool verbose;
 static SDL_bool CreateWindowAndRenderer(SDL_WindowFlags window_flags, const char *driver)
 {
     SDL_PropertiesID props;
-    SDL_RendererInfo info;
     SDL_bool useOpenGL = (driver && (SDL_strcmp(driver, "opengl") == 0 || SDL_strcmp(driver, "opengles2") == 0));
     SDL_bool useEGL = (driver && SDL_strcmp(driver, "opengles2") == 0);
     SDL_bool useVulkan = (driver && SDL_strcmp(driver, "vulkan") == 0);
@@ -177,9 +176,7 @@ static SDL_bool CreateWindowAndRenderer(SDL_WindowFlags window_flags, const char
         return SDL_FALSE;
     }
 
-    if (SDL_GetRendererInfo(renderer, &info) == 0) {
+    SDL_Log("Created renderer %s\n", SDL_GetRendererName(renderer));
-        SDL_Log("Created renderer %s\n", info.name);
-    }
 
 #ifdef HAVE_EGL
     if (useEGL) {