Fixed a few remaining functions to directly return their values instead of an error code.

src/core/SDL_core_unsupported.c

@@ -142,11 +142,11 @@ const char* SDL_GetAndroidExternalStoragePath()
     return NULL;
 }
 
-SDL_DECLSPEC int SDLCALL SDL_GetAndroidExternalStorageState(Uint32 *state);
-int SDL_GetAndroidExternalStorageState(Uint32 *state)
+SDL_DECLSPEC Uint32 SDLCALL SDL_GetAndroidExternalStorageState(void);
+Uint32 SDL_GetAndroidExternalStorageState(void)
 {
-    (void)state;
-    return SDL_Unsupported();
+    SDL_Unsupported();
+    return 0;
 }
 SDL_DECLSPEC const char *SDLCALL SDL_GetAndroidInternalStoragePath(void);
 const char *SDL_GetAndroidInternalStoragePath(void)

src/core/android/SDL_android.c

@@ -2507,22 +2507,19 @@ const char *SDL_GetAndroidInternalStoragePath(void)
     return s_AndroidInternalFilesPath;
 }
 
-int SDL_GetAndroidExternalStorageState(Uint32 *state)
+Uint32 SDL_GetAndroidExternalStorageState(void)
 {
     struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
     jmethodID mid;
     jclass cls;
     jstring stateString;
     const char *state_string;
-    int stateFlags;
+    Uint32 stateFlags;
 
     JNIEnv *env = Android_JNI_GetEnv();
     if (!LocalReferenceHolder_Init(&refs, env)) {
         LocalReferenceHolder_Cleanup(&refs);
-        if (state) {
-            *state = 0;
-        }
-        return -1;
+        return 0;
     }
 
     cls = (*env)->FindClass(env, "android/os/Environment");
@@ -2546,10 +2543,8 @@ int SDL_GetAndroidExternalStorageState(Uint32 *state)
     (*env)->ReleaseStringUTFChars(env, stateString, state_string);
 
     LocalReferenceHolder_Cleanup(&refs);
-    if (state) {
-        *state = stateFlags;
-    }
-    return 0;
+
+    return stateFlags;
 }
 
 // this caches a string until the process ends, so there's no need to use SDL_FreeLater.

src/dynapi/SDL_dynapi_procs.h

@@ -196,7 +196,7 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_GamepadSensorEnabled,(SDL_Gamepad *a, SDL_SensorTyp
 SDL_DYNAPI_PROC(void*,SDL_GetAndroidActivity,(void),(),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetAndroidCachePath,(void),(),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetAndroidExternalStoragePath,(void),(),return)
-SDL_DYNAPI_PROC(int,SDL_GetAndroidExternalStorageState,(Uint32 *a),(a),return)
+SDL_DYNAPI_PROC(Uint32,SDL_GetAndroidExternalStorageState,(void),(),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetAndroidInternalStoragePath,(void),(),return)
 SDL_DYNAPI_PROC(void*,SDL_GetAndroidJNIEnv,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetAndroidSDKVersion,(void),(),return)
@@ -433,8 +433,8 @@ SDL_DYNAPI_PROC(int,SDL_GetRectUnionFloat,(const SDL_FRect *a, const SDL_FRect *
 SDL_DYNAPI_PROC(SDL_bool,SDL_GetRelativeMouseMode,(void),(),return)
 SDL_DYNAPI_PROC(SDL_MouseButtonFlags,SDL_GetRelativeMouseState,(float *a, float *b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_GetRenderClipRect,(SDL_Renderer *a, SDL_Rect *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetRenderColorScale,(SDL_Renderer *a, float *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetRenderDrawBlendMode,(SDL_Renderer *a, SDL_BlendMode *b),(a,b),return)
+SDL_DYNAPI_PROC(float,SDL_GetRenderColorScale,(SDL_Renderer *a),(a),return)
+SDL_DYNAPI_PROC(SDL_BlendMode,SDL_GetRenderDrawBlendMode,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetRenderDrawColor,(SDL_Renderer *a, Uint8 *b, Uint8 *c, Uint8 *d, Uint8 *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(int,SDL_GetRenderDrawColorFloat,(SDL_Renderer *a, float *b, float *c, float *d, float *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetRenderDriver,(int a),(a),return)
@@ -475,9 +475,9 @@ SDL_DYNAPI_PROC(int,SDL_GetStoragePathInfo,(SDL_Storage *a, const char *b, SDL_P
 SDL_DYNAPI_PROC(Uint64,SDL_GetStorageSpaceRemaining,(SDL_Storage *a),(a),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetStringProperty,(SDL_PropertiesID a, const char *b, const char *c),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_GetSurfaceAlphaMod,(SDL_Surface *a, Uint8 *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_BlendMode,SDL_GetSurfaceBlendMode,(SDL_Surface *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetSurfaceClipRect,(SDL_Surface *a, SDL_Rect *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetSurfaceColorKey,(SDL_Surface *a, Uint32 *b),(a,b),return)
+SDL_DYNAPI_PROC(Uint32,SDL_GetSurfaceColorKey,(SDL_Surface *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetSurfaceColorMod,(SDL_Surface *a, Uint8 *b, Uint8 *c, Uint8 *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(SDL_Colorspace,SDL_GetSurfaceColorspace,(SDL_Surface *a),(a),return)
 SDL_DYNAPI_PROC(SDL_Palette*,SDL_GetSurfacePalette,(SDL_Surface *a),(a),return)
@@ -488,11 +488,11 @@ SDL_DYNAPI_PROC(void*,SDL_GetTLS,(SDL_TLSID *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetTextInputArea,(SDL_Window *a, SDL_Rect *b, int *c),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_GetTextureAlphaMod,(SDL_Texture *a, Uint8 *b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_GetTextureAlphaModFloat,(SDL_Texture *a, float *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetTextureBlendMode,(SDL_Texture *a, SDL_BlendMode *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_BlendMode,SDL_GetTextureBlendMode,(SDL_Texture *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetTextureColorMod,(SDL_Texture *a, Uint8 *b, Uint8 *c, Uint8 *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(int,SDL_GetTextureColorModFloat,(SDL_Texture *a, float *b, float *c, float *d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetTextureProperties,(SDL_Texture *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetTextureScaleMode,(SDL_Texture *a, SDL_ScaleMode *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_ScaleMode,SDL_GetTextureScaleMode,(SDL_Texture *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetTextureSize,(SDL_Texture *a, float *b, float *c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_ThreadID,SDL_GetThreadID,(SDL_Thread *a),(a),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetThreadName,(SDL_Thread *a),(a),return)

src/render/SDL_render.c

@@ -1641,7 +1641,6 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
 
     {
         Uint8 r, g, b, a;
-        SDL_BlendMode blendMode;
 
         SDL_GetSurfaceColorMod(surface, &r, &g, &b);
         SDL_SetTextureColorMod(texture, r, g, b);
@@ -1653,8 +1652,7 @@ SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *s
             /* We converted to a texture with alpha format */
             SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
         } else {
-            SDL_GetSurfaceBlendMode(surface, &blendMode);
-            SDL_SetTextureBlendMode(texture, blendMode);
+            SDL_SetTextureBlendMode(texture, SDL_GetSurfaceBlendMode(surface));
         }
     }
     return texture;
@@ -1799,6 +1797,10 @@ int SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode)
 
     CHECK_TEXTURE_MAGIC(texture, -1);
 
+    if (blendMode == SDL_BLENDMODE_INVALID) {
+        return SDL_InvalidParamError("blendMode");
+    }
+
     renderer = texture->renderer;
     if (!IsSupportedBlendMode(renderer, blendMode)) {
         return SDL_Unsupported();
@@ -1810,14 +1812,11 @@ int SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode)
     return 0;
 }
 
-int SDL_GetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode *blendMode)
+SDL_BlendMode SDL_GetTextureBlendMode(SDL_Texture *texture)
 {
-    CHECK_TEXTURE_MAGIC(texture, -1);
+    CHECK_TEXTURE_MAGIC(texture, SDL_BLENDMODE_INVALID);
 
-    if (blendMode) {
-        *blendMode = texture->blendMode;
-    }
-    return 0;
+    return texture->blendMode;
 }
 
 int SDL_SetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode scaleMode)
@@ -1836,14 +1835,11 @@ int SDL_SetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode scaleMode)
     return 0;
 }
 
-int SDL_GetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode *scaleMode)
+SDL_ScaleMode SDL_GetTextureScaleMode(SDL_Texture *texture)
 {
-    CHECK_TEXTURE_MAGIC(texture, -1);
+    CHECK_TEXTURE_MAGIC(texture, SDL_SCALEMODE_LINEAR);
 
-    if (scaleMode) {
-        *scaleMode = texture->scaleMode;
-    }
-    return 0;
+    return texture->scaleMode;
 }
 
 #if SDL_HAVE_YUV
@@ -3069,20 +3065,21 @@ int SDL_SetRenderColorScale(SDL_Renderer *renderer, float scale)
     return 0;
 }
 
-int SDL_GetRenderColorScale(SDL_Renderer *renderer, float *scale)
+float SDL_GetRenderColorScale(SDL_Renderer *renderer)
 {
-    CHECK_RENDERER_MAGIC(renderer, -1);
+    CHECK_RENDERER_MAGIC(renderer, 1.0f);
 
-    if (scale) {
-        *scale = renderer->color_scale / renderer->SDR_white_point;
-    }
-    return 0;
+    return renderer->color_scale / renderer->SDR_white_point;
 }
 
 int SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
 {
     CHECK_RENDERER_MAGIC(renderer, -1);
 
+    if (blendMode == SDL_BLENDMODE_INVALID) {
+        return SDL_InvalidParamError("blendMode");
+    }
+
     if (!IsSupportedBlendMode(renderer, blendMode)) {
         return SDL_Unsupported();
     }
@@ -3090,20 +3087,18 @@ int SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
     return 0;
 }
 
-int SDL_GetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode *blendMode)
+SDL_BlendMode SDL_GetRenderDrawBlendMode(SDL_Renderer *renderer)
 {
-    CHECK_RENDERER_MAGIC(renderer, -1);
+    CHECK_RENDERER_MAGIC(renderer, SDL_BLENDMODE_INVALID);
 
-    *blendMode = renderer->blendMode;
-    return 0;
+    return renderer->blendMode;
 }
 
 int SDL_RenderClear(SDL_Renderer *renderer)
 {
-    int retval;
     CHECK_RENDERER_MAGIC(renderer, -1);
-    retval = QueueCmdClear(renderer);
-    return retval;
+
+    return QueueCmdClear(renderer);
 }
 
 int SDL_RenderPoint(SDL_Renderer *renderer, float x, float y)
@@ -3970,7 +3965,7 @@ static int SDLCALL SDL_SW_RenderGeometryRaw(SDL_Renderer *renderer,
     float r = 0, g = 0, b = 0, a = 0;
 
     /* Save */
-    SDL_GetRenderDrawBlendMode(renderer, &blendMode);
+    blendMode = SDL_GetRenderDrawBlendMode(renderer);
     SDL_GetRenderDrawColorFloat(renderer, &r, &g, &b, &a);
 
     if (texture) {

src/render/software/SDL_render_sw.c

@@ -355,7 +355,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
         return -1;
     }
 
-    SDL_GetSurfaceBlendMode(src, &blendmode);
+    blendmode = SDL_GetSurfaceBlendMode(src);
     SDL_GetSurfaceAlphaMod(src, &alphaMod);
     SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
 
@@ -841,7 +841,7 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
                         SDL_BlendMode blendmode;
                         Uint8 alphaMod, rMod, gMod, bMod;
 
-                        SDL_GetSurfaceBlendMode(src, &blendmode);
+                        blendmode = SDL_GetSurfaceBlendMode(src);
                         SDL_GetSurfaceAlphaMod(src, &alphaMod);
                         SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
 

src/render/software/SDL_rotate.c

@@ -78,11 +78,7 @@ Returns colorkey info for a surface
 */
 static Uint32 get_colorkey(SDL_Surface *src)
 {
-    Uint32 key = 0;
-    if (SDL_SurfaceHasColorKey(src)) {
-        SDL_GetSurfaceColorKey(src, &key);
-    }
-    return key;
+    return SDL_GetSurfaceColorKey(src);
 }
 
 /* rotate (sx, sy) by (angle, center) into (dx, dy) */
@@ -501,9 +497,8 @@ SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, in
     }
 
     if (SDL_SurfaceHasColorKey(src)) {
-        if (SDL_GetSurfaceColorKey(src, &colorkey) == 0) {
-            colorKeyAvailable = SDL_TRUE;
-        }
+        colorkey = SDL_GetSurfaceColorKey(src);
+        colorKeyAvailable = SDL_TRUE;
     }
     /* This function requires a 32-bit surface or 8-bit surface with a colorkey */
     is8bit = src->internal->format->bits_per_pixel == 8 && colorKeyAvailable;
@@ -536,7 +531,7 @@ SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, in
     /* Adjust for guard rows */
     rz_dst->h = rect_dest->h;
 
-    SDL_GetSurfaceBlendMode(src, &blendmode);
+    blendmode = SDL_GetSurfaceBlendMode(src);
 
     if (colorKeyAvailable == SDL_TRUE) {
         /* If available, the colorkey will be used to discard the pixels that are outside of the rotated area. */

src/render/software/SDL_triangle.c

@@ -524,7 +524,7 @@ int SDL_SW_BlitTriangle(
 
     bounding_rect_fixedpoint(d0, d1, d2, &dstrect);
 
-    SDL_GetSurfaceBlendMode(src, &blend);
+    blend = SDL_GetSurfaceBlendMode(src);
 
     /* TRIANGLE_GET_TEXTCOORD interpolates up to the max values included, so reduce by 1 */
     {

src/video/SDL_surface.c

@@ -515,20 +515,13 @@ SDL_bool SDL_SurfaceHasColorKey(SDL_Surface *surface)
     return SDL_TRUE;
 }
 
-int SDL_GetSurfaceColorKey(SDL_Surface *surface, Uint32 *key)
+Uint32 SDL_GetSurfaceColorKey(SDL_Surface *surface)
 {
     if (!SDL_SurfaceValid(surface)) {
-        return SDL_InvalidParamError("surface");
+        return 0;
     }
 
-    if (!(surface->internal->map.info.flags & SDL_COPY_COLORKEY)) {
-        return SDL_SetError("Surface doesn't have a colorkey");
-    }
-
-    if (key) {
-        *key = surface->internal->map.info.colorkey;
-    }
-    return 0;
+    return surface->internal->map.info.colorkey;
 }
 
 /* This is a fairly slow function to switch from colorkey to alpha
@@ -706,6 +699,10 @@ int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
         return SDL_InvalidParamError("surface");
     }
 
+    if (blendMode == SDL_BLENDMODE_INVALID) {
+        return SDL_InvalidParamError("blendMode");
+    }
+
     status = 0;
     flags = surface->internal->map.info.flags;
     surface->internal->map.info.flags &= ~(SDL_COPY_BLEND | SDL_COPY_BLEND_PREMULTIPLIED | SDL_COPY_ADD | SDL_COPY_ADD_PREMULTIPLIED | SDL_COPY_MOD | SDL_COPY_MUL);
@@ -742,40 +739,39 @@ int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
     return status;
 }
 
-int SDL_GetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode *blendMode)
+SDL_BlendMode SDL_GetSurfaceBlendMode(SDL_Surface *surface)
 {
-    if (!SDL_SurfaceValid(surface)) {
-        return SDL_InvalidParamError("surface");
-    }
+    SDL_BlendMode blendMode;
 
-    if (!blendMode) {
-        return 0;
+    if (!SDL_SurfaceValid(surface)) {
+        SDL_InvalidParamError("surface");
+        return SDL_BLENDMODE_INVALID;
     }
 
     switch (surface->internal->map.info.flags & (SDL_COPY_BLEND | SDL_COPY_BLEND_PREMULTIPLIED | SDL_COPY_ADD | SDL_COPY_ADD_PREMULTIPLIED | SDL_COPY_MOD | SDL_COPY_MUL)) {
     case SDL_COPY_BLEND:
-        *blendMode = SDL_BLENDMODE_BLEND;
+        blendMode = SDL_BLENDMODE_BLEND;
         break;
     case SDL_COPY_BLEND_PREMULTIPLIED:
-        *blendMode = SDL_BLENDMODE_BLEND_PREMULTIPLIED;
+        blendMode = SDL_BLENDMODE_BLEND_PREMULTIPLIED;
         break;
     case SDL_COPY_ADD:
-        *blendMode = SDL_BLENDMODE_ADD;
+        blendMode = SDL_BLENDMODE_ADD;
         break;
     case SDL_COPY_ADD_PREMULTIPLIED:
-        *blendMode = SDL_BLENDMODE_ADD_PREMULTIPLIED;
+        blendMode = SDL_BLENDMODE_ADD_PREMULTIPLIED;
         break;
     case SDL_COPY_MOD:
-        *blendMode = SDL_BLENDMODE_MOD;
+        blendMode = SDL_BLENDMODE_MOD;
         break;
     case SDL_COPY_MUL:
-        *blendMode = SDL_BLENDMODE_MUL;
+        blendMode = SDL_BLENDMODE_MUL;
         break;
     default:
-        *blendMode = SDL_BLENDMODE_NONE;
+        blendMode = SDL_BLENDMODE_NONE;
         break;
     }
-    return 0;
+    return blendMode;
 }
 
 SDL_bool SDL_SetSurfaceClipRect(SDL_Surface *surface, const SDL_Rect *rect)
@@ -1151,7 +1147,7 @@ int SDL_BlitSurfaceUncheckedScaled(SDL_Surface *src, const SDL_Rect *srcrect,
             /* Save source infos */
             SDL_GetSurfaceColorMod(src, &r, &g, &b);
             SDL_GetSurfaceAlphaMod(src, &alpha);
-            SDL_GetSurfaceBlendMode(src, &blendMode);
+            blendMode = SDL_GetSurfaceBlendMode(src);
             srcrect2.x = srcrect->x;
             srcrect2.y = srcrect->y;
             srcrect2.w = srcrect->w;