geemili
/
SDL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SDL API renaming: SDL_surface.h 

Fixes https://github.com/libsdl-org/SDL/issues/6884
main
Sam Lantinga 2022-12-27 06:36:39 -08:00
parent 2db699f48e
commit cc0296c934
47 changed files with 416 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
WhatsNew.txt
View File

@ -24,9 +24,16 @@ General:
* SDL_AudioStreamFlush => SDL_FlushAudioStream * SDL_AudioStreamFlush => SDL_FlushAudioStream
* SDL_AudioStreamGet => SDL_GetAudioStreamData * SDL_AudioStreamGet => SDL_GetAudioStreamData
* SDL_AudioStreamPut => SDL_PutAudioStreamData * SDL_AudioStreamPut => SDL_PutAudioStreamData
* SDL_FillRect => SDL_FillSurfaceRect
* SDL_FillRects => SDL_FillSurfaceRects
* SDL_FreeAudioStream => SDL_DestroyAudioStream * SDL_FreeAudioStream => SDL_DestroyAudioStream
* SDL_FreeFormat => SDL_DestroyPixelFormat * SDL_FreeFormat => SDL_DestroyPixelFormat
* SDL_FreePalette => SDL_DestroyPalette * SDL_FreePalette => SDL_DestroyPalette
* SDL_FreeSurface => SDL_DestroySurface
* SDL_GetClipRect => SDL_GetSurfaceClipRect
* SDL_GetColorKey => SDL_GetSurfaceColorKey
* SDL_HasColorKey => SDL_SurfaceHasColorKey
* SDL_HasSurfaceRLE => SDL_SurfaceHasRLE
* SDL_JoystickAttachVirtual => SDL_AttachVirtualJoystick * SDL_JoystickAttachVirtual => SDL_AttachVirtualJoystick
* SDL_JoystickAttachVirtualEx => SDL_AttachVirtualJoystickEx * SDL_JoystickAttachVirtualEx => SDL_AttachVirtualJoystickEx
* SDL_JoystickClose => SDL_CloseJoystick * SDL_JoystickClose => SDL_CloseJoystick
@ -76,6 +83,8 @@ General:
* SDL_JoystickSetVirtualButton => SDL_SetJoystickVirtualButton * SDL_JoystickSetVirtualButton => SDL_SetJoystickVirtualButton
* SDL_JoystickSetVirtualHat => SDL_SetJoystickVirtualHat * SDL_JoystickSetVirtualHat => SDL_SetJoystickVirtualHat
* SDL_JoystickUpdate => SDL_UpdateJoysticks * SDL_JoystickUpdate => SDL_UpdateJoysticks
* SDL_LowerBlit => SDL_BlitSurfaceUnchecked
* SDL_LowerBlitScaled => SDL_BlitSurfaceUncheckedScaled
* SDL_MasksToPixelFormatEnum => SDL_GetPixelFormatEnumForMasks * SDL_MasksToPixelFormatEnum => SDL_GetPixelFormatEnumForMasks
* SDL_NewAudioStream => SDL_CreateAudioStream * SDL_NewAudioStream => SDL_CreateAudioStream
* SDL_NumJoysticks => SDL_GetNumJoysticks * SDL_NumJoysticks => SDL_GetNumJoysticks
@ -126,6 +135,10 @@ General:
* SDL_SensorGetType => SDL_GetSensorType * SDL_SensorGetType => SDL_GetSensorType
* SDL_SensorOpen => SDL_OpenSensor * SDL_SensorOpen => SDL_OpenSensor
* SDL_SensorUpdate => SDL_UpdateSensors * SDL_SensorUpdate => SDL_UpdateSensors
* SDL_SetClipRect => SDL_SetSurfaceClipRect
* SDL_SetColorKey => SDL_SetSurfaceColorKey
* SDL_UpperBlit => SDL_BlitSurface
* SDL_UpperBlitScaled => SDL_BlitSurfaceScaled
* Removed the following functions from the API, see docs/README-migration.md for details: * Removed the following functions from the API, see docs/README-migration.md for details:
* SDL_AudioInit() * SDL_AudioInit()
* SDL_AudioQuit() * SDL_AudioQuit()

6
Xcode-iOS/Demos/src/accelerometer.c
View File

@ -123,7 +123,7 @@ initializeTextures(SDL_Renderer *renderer)
fatalError("could not ship.bmp"); fatalError("could not ship.bmp");
} }
/* set blue to transparent on the ship */ /* set blue to transparent on the ship */
SDL_SetColorKey(bmp_surface, 1, SDL_SetSurfaceColorKey(bmp_surface, 1,
SDL_MapRGB(bmp_surface->format, 0, 0, 255)); SDL_MapRGB(bmp_surface->format, 0, 0, 255));
/* create ship texture from surface */ /* create ship texture from surface */
@ -137,7 +137,7 @@ initializeTextures(SDL_Renderer *renderer)
shipData.rect.w = bmp_surface->w; shipData.rect.w = bmp_surface->w;
shipData.rect.h = bmp_surface->h; shipData.rect.h = bmp_surface->h;
SDL_FreeSurface(bmp_surface); SDL_DestroySurface(bmp_surface);
/* load the space background */ /* load the space background */
bmp_surface = SDL_LoadBMP("space.bmp"); bmp_surface = SDL_LoadBMP("space.bmp");
@ -149,7 +149,7 @@ initializeTextures(SDL_Renderer *renderer)
if (space == NULL) { if (space == NULL) {
fatalError("could not create space texture"); fatalError("could not create space texture");
} }
SDL_FreeSurface(bmp_surface); SDL_DestroySurface(bmp_surface);
} }

4
Xcode-iOS/Demos/src/fireworks.c
View File

@ -357,8 +357,8 @@ initializeTexture()
GL_RGBA, GL_UNSIGNED_BYTE, bmp_surface_rgba8888->pixels); GL_RGBA, GL_UNSIGNED_BYTE, bmp_surface_rgba8888->pixels);
/* free bmp surface and converted bmp surface */ /* free bmp surface and converted bmp surface */
SDL_FreeSurface(bmp_surface); SDL_DestroySurface(bmp_surface);
SDL_FreeSurface(bmp_surface_rgba8888); SDL_DestroySurface(bmp_surface_rgba8888);
} }

4
Xcode-iOS/Demos/src/happy.c
View File

@ -113,7 +113,7 @@ initializeTexture(SDL_Renderer *renderer)
fatalError("could not load bmp"); fatalError("could not load bmp");
} }
/* set white to transparent on the happyface */ /* set white to transparent on the happyface */
SDL_SetColorKey(bmp_surface, 1, SDL_SetSurfaceColorKey(bmp_surface, 1,
SDL_MapRGB(bmp_surface->format, 255, 255, 255)); SDL_MapRGB(bmp_surface->format, 255, 255, 255));
/* convert RGBA surface to texture */ /* convert RGBA surface to texture */
@ -124,7 +124,7 @@ initializeTexture(SDL_Renderer *renderer)
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
/* free up allocated memory */ /* free up allocated memory */
SDL_FreeSurface(bmp_surface); SDL_DestroySurface(bmp_surface);
} }
int int

6
Xcode-iOS/Demos/src/keyboard.c
View File

@ -171,7 +171,7 @@ loadFont(void)
return 0; return 0;
} else { } else {
/* set the transparent color for the bitmap font (hot pink) */ /* set the transparent color for the bitmap font (hot pink) */
SDL_SetColorKey(surface, 1, SDL_MapRGB(surface->format, 238, 0, 252)); SDL_SetSurfaceColorKey(surface, 1, SDL_MapRGB(surface->format, 238, 0, 252));
/* now we convert the surface to our desired pixel format */ /* now we convert the surface to our desired pixel format */
int format = SDL_PIXELFORMAT_ABGR8888; /* desired texture format */ int format = SDL_PIXELFORMAT_ABGR8888; /* desired texture format */
@ -186,8 +186,8 @@ loadFont(void)
/* set blend mode for our texture */ /* set blend mode for our texture */
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
} }
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
SDL_FreeSurface(converted); SDL_DestroySurface(converted);
return texture; return texture;
} }
} }

2
Xcode-iOS/Demos/src/touch.c
View File

@ -63,7 +63,7 @@ initializeTexture(SDL_Renderer *renderer)
} }
brush = brush =
SDL_CreateTextureFromSurface(renderer, bmp_surface); SDL_CreateTextureFromSurface(renderer, bmp_surface);
SDL_FreeSurface(bmp_surface); SDL_DestroySurface(bmp_surface);
if (brush == NULL) { if (brush == NULL) {
fatalError("could not create brush texture"); fatalError("could not create brush texture");
} }

15
docs/README-migration.md
View File

@ -509,6 +509,21 @@ But if you're migrating your code which uses masks, you probably have a format i
``` ```
The following functions have been renamed:
* SDL_FillRect => SDL_FillSurfaceRect
* SDL_FillRects => SDL_FillSurfaceRects
* SDL_FreeSurface => SDL_DestroySurface
* SDL_GetClipRect => SDL_GetSurfaceClipRect
* SDL_GetColorKey => SDL_GetSurfaceColorKey
* SDL_HasColorKey => SDL_SurfaceHasColorKey
* SDL_HasSurfaceRLE => SDL_SurfaceHasRLE
* SDL_LowerBlit => SDL_BlitSurfaceUnchecked
* SDL_LowerBlitScaled => SDL_BlitSurfaceUncheckedScaled
* SDL_SetClipRect => SDL_SetSurfaceClipRect
* SDL_SetColorKey => SDL_SetSurfaceColorKey
* SDL_UpperBlit => SDL_BlitSurface
* SDL_UpperBlitScaled => SDL_BlitSurfaceScaled
## SDL_syswm.h ## SDL_syswm.h
This header no longer includes platform specific headers and type definitions, instead allowing you to include the ones appropriate for your use case. You should define one or more of the following to enable the relevant platform-specific support: This header no longer includes platform specific headers and type definitions, instead allowing you to include the ones appropriate for your use case. You should define one or more of the following to enable the relevant platform-specific support:

30
include/SDL3/SDL_oldnames.h
View File

@ -192,6 +192,21 @@
#define SDL_SensorOpen SDL_OpenSensor #define SDL_SensorOpen SDL_OpenSensor
#define SDL_SensorUpdate SDL_UpdateSensors #define SDL_SensorUpdate SDL_UpdateSensors
/* ##SDL_surface.h */
#define SDL_FillRect SDL_FillSurfaceRect
#define SDL_FillRects SDL_FillSurfaceRects
#define SDL_FreeSurface SDL_DestroySurface
#define SDL_GetClipRect SDL_GetSurfaceClipRect
#define SDL_GetColorKey SDL_GetSurfaceColorKey
#define SDL_HasColorKey SDL_SurfaceHasColorKey
#define SDL_HasSurfaceRLE SDL_SurfaceHasRLE
#define SDL_LowerBlit SDL_BlitSurfaceUnchecked
#define SDL_LowerBlitScaled SDL_BlitSurfaceUncheckedScaled
#define SDL_SetClipRect SDL_SetSurfaceClipRect
#define SDL_SetColorKey SDL_SetSurfaceColorKey
#define SDL_UpperBlit SDL_BlitSurface
#define SDL_UpperBlitScaled SDL_BlitSurfaceScaled
#else /* !SDL_ENABLE_OLD_NAMES */ #else /* !SDL_ENABLE_OLD_NAMES */
/* ##SDL_audio.h */ /* ##SDL_audio.h */
@ -347,6 +362,21 @@
#define SDL_SensorOpen SDL_SensorOpen_renamed_SDL_OpenSensor #define SDL_SensorOpen SDL_SensorOpen_renamed_SDL_OpenSensor
#define SDL_SensorUpdate SDL_SensorUpdate_renamed_SDL_UpdateSensors #define SDL_SensorUpdate SDL_SensorUpdate_renamed_SDL_UpdateSensors
/* ##SDL_surface.h */
#define SDL_FillRect SDL_FillRect_renamed_SDL_FillSurfaceRect
#define SDL_FillRects SDL_FillRects_renamed_SDL_FillSurfaceRects
#define SDL_FreeSurface SDL_FreeSurface_renamed_SDL_DestroySurface
#define SDL_GetClipRect SDL_GetClipRect_renamed_SDL_GetSurfaceClipRect
#define SDL_GetColorKey SDL_GetColorKey_renamed_SDL_GetSurfaceColorKey
#define SDL_HasColorKey SDL_HasColorKey_renamed_SDL_SurfaceHasColorKey
#define SDL_HasSurfaceRLE SDL_HasSurfaceRLE_renamed_SDL_SurfaceHasRLE
#define SDL_LowerBlit SDL_LowerBlit_renamed_SDL_BlitSurfaceUnchecked
#define SDL_LowerBlitScaled SDL_LowerBlitScaled_renamed_SDL_BlitSurfaceUncheckedScaled
#define SDL_SetClipRect SDL_SetClipRect_renamed_SDL_SetSurfaceClipRect
#define SDL_SetColorKey SDL_SetColorKey_renamed_SDL_SetSurfaceColorKey
#define SDL_UpperBlit SDL_UpperBlit_renamed_SDL_BlitSurface
#define SDL_UpperBlitScaled SDL_UpperBlitScaled_renamed_SDL_BlitSurfaceScaled
#endif /* SDL_ENABLE_OLD_NAMES */ #endif /* SDL_ENABLE_OLD_NAMES */
#endif /* SDL_oldnames_h_ */ #endif /* SDL_oldnames_h_ */

180
include/SDL3/SDL_surface.h
View File

@ -99,8 +99,8 @@ typedef struct SDL_Surface
/** /**
* \brief The type of function used for surface blitting functions. * \brief The type of function used for surface blitting functions.
*/ */
typedef int (SDLCALL *SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect, typedef int (SDLCALL *SDL_blit) (struct SDL_Surface *src, SDL_Rect *srcrect,
struct SDL_Surface * dst, SDL_Rect * dstrect); struct SDL_Surface *dst, SDL_Rect *dstrect);
/** /**
* \brief The formula used for converting between YUV and RGB * \brief The formula used for converting between YUV and RGB
@ -125,7 +125,7 @@ typedef enum
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_CreateSurfaceFrom * \sa SDL_CreateSurfaceFrom
* \sa SDL_FreeSurface * \sa SDL_DestroySurface
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurface extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurface
(int width, int height, Uint32 format); (int width, int height, Uint32 format);
@ -148,7 +148,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurface
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_CreateSurface * \sa SDL_CreateSurface
* \sa SDL_FreeSurface * \sa SDL_DestroySurface
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurfaceFrom extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurfaceFrom
(void *pixels, int width, int height, int pitch, Uint32 format); (void *pixels, int width, int height, int pitch, Uint32 format);
@ -167,7 +167,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurfaceFrom
* \sa SDL_LoadBMP * \sa SDL_LoadBMP
* \sa SDL_LoadBMP_RW * \sa SDL_LoadBMP_RW
*/ */
extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface); extern DECLSPEC void SDLCALL SDL_DestroySurface(SDL_Surface *surface);
/** /**
* Set the palette used by a surface. * Set the palette used by a surface.
@ -181,8 +181,8 @@ extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
*/ */
extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface *surface,
SDL_Palette * palette); SDL_Palette *palette);
/** /**
* Set up a surface for directly accessing the pixels. * Set up a surface for directly accessing the pixels.
@ -205,7 +205,7 @@ extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
* \sa SDL_MUSTLOCK * \sa SDL_MUSTLOCK
* \sa SDL_UnlockSurface * \sa SDL_UnlockSurface
*/ */
extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface); extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface *surface);
/** /**
* Release a surface after directly accessing the pixels. * Release a surface after directly accessing the pixels.
@ -216,12 +216,12 @@ extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
* *
* \sa SDL_LockSurface * \sa SDL_LockSurface
*/ */
extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface); extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
/** /**
* Load a BMP image from a seekable SDL data stream. * Load a BMP image from a seekable SDL data stream.
* *
* The new surface should be freed with SDL_FreeSurface(). Not doing so will * The new surface should be freed with SDL_DestroySurface(). Not doing so will
* result in a memory leak. * result in a memory leak.
* *
* src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile. * src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile.
@ -235,12 +235,12 @@ extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_FreeSurface * \sa SDL_DestroySurface
* \sa SDL_RWFromFile * \sa SDL_RWFromFile
* \sa SDL_LoadBMP * \sa SDL_LoadBMP
* \sa SDL_SaveBMP_RW * \sa SDL_SaveBMP_RW
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src, extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops *src,
int freesrc); int freesrc);
/** /**
@ -271,7 +271,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
* \sa SDL_SaveBMP * \sa SDL_SaveBMP
*/ */
extern DECLSPEC int SDLCALL SDL_SaveBMP_RW extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
(SDL_Surface * surface, SDL_RWops * dst, int freedst); (SDL_Surface *surface, SDL_RWops *dst, int freedst);
/** /**
* Save a surface to a file. * Save a surface to a file.
@ -298,7 +298,7 @@ extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
* \sa SDL_LockSurface * \sa SDL_LockSurface
* \sa SDL_UnlockSurface * \sa SDL_UnlockSurface
*/ */
extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface *surface,
int flag); int flag);
/** /**
@ -313,7 +313,7 @@ extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
* *
* \sa SDL_SetSurfaceRLE * \sa SDL_SetSurfaceRLE
*/ */
extern DECLSPEC SDL_bool SDLCALL SDL_HasSurfaceRLE(SDL_Surface * surface); extern DECLSPEC SDL_bool SDLCALL SDL_SurfaceHasRLE(SDL_Surface *surface);
/** /**
* Set the color key (transparent pixel) in a surface. * Set the color key (transparent pixel) in a surface.
@ -337,9 +337,9 @@ extern DECLSPEC SDL_bool SDLCALL SDL_HasSurfaceRLE(SDL_Surface * surface);
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_BlitSurface * \sa SDL_BlitSurface
* \sa SDL_GetColorKey * \sa SDL_GetSurfaceColorKey
*/ */
extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_SetSurfaceColorKey(SDL_Surface *surface,
int flag, Uint32 key); int flag, Uint32 key);
/** /**
@ -352,10 +352,10 @@ extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_SetColorKey * \sa SDL_SetSurfaceColorKey
* \sa SDL_GetColorKey * \sa SDL_GetSurfaceColorKey
*/ */
extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface); extern DECLSPEC SDL_bool SDLCALL SDL_SurfaceHasColorKey(SDL_Surface *surface);
/** /**
* Get the color key (transparent pixel) for a surface. * Get the color key (transparent pixel) for a surface.
@ -373,10 +373,10 @@ extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface);
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_BlitSurface * \sa SDL_BlitSurface
* \sa SDL_SetColorKey * \sa SDL_SetSurfaceColorKey
*/ */
extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_GetSurfaceColorKey(SDL_Surface *surface,
Uint32 * key); Uint32 *key);
/** /**
* Set an additional color value multiplied into blit operations. * Set an additional color value multiplied into blit operations.
@ -399,7 +399,7 @@ extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
* \sa SDL_GetSurfaceColorMod * \sa SDL_GetSurfaceColorMod
* \sa SDL_SetSurfaceAlphaMod * \sa SDL_SetSurfaceAlphaMod
*/ */
extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface *surface,
Uint8 r, Uint8 g, Uint8 b); Uint8 r, Uint8 g, Uint8 b);
@ -418,9 +418,9 @@ extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
* \sa SDL_GetSurfaceAlphaMod * \sa SDL_GetSurfaceAlphaMod
* \sa SDL_SetSurfaceColorMod * \sa SDL_SetSurfaceColorMod
*/ */
extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface *surface,
Uint8 * r, Uint8 * g, Uint8 *r, Uint8 *g,
Uint8 * b); Uint8 *b);
/** /**
* Set an additional alpha value used in blit operations. * Set an additional alpha value used in blit operations.
@ -440,7 +440,7 @@ extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
* \sa SDL_GetSurfaceAlphaMod * \sa SDL_GetSurfaceAlphaMod
* \sa SDL_SetSurfaceColorMod * \sa SDL_SetSurfaceColorMod
*/ */
extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface *surface,
Uint8 alpha); Uint8 alpha);
/** /**
@ -456,8 +456,8 @@ extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
* \sa SDL_GetSurfaceColorMod * \sa SDL_GetSurfaceColorMod
* \sa SDL_SetSurfaceAlphaMod * \sa SDL_SetSurfaceAlphaMod
*/ */
extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface *surface,
Uint8 * alpha); Uint8 *alpha);
/** /**
* Set the blend mode used for blit operations. * Set the blend mode used for blit operations.
@ -475,7 +475,7 @@ extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
* *
* \sa SDL_GetSurfaceBlendMode * \sa SDL_GetSurfaceBlendMode
*/ */
extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface *surface,
SDL_BlendMode blendMode); SDL_BlendMode blendMode);
/** /**
@ -490,7 +490,7 @@ extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
* *
* \sa SDL_SetSurfaceBlendMode * \sa SDL_SetSurfaceBlendMode
*/ */
extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface, extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface *surface,
SDL_BlendMode *blendMode); SDL_BlendMode *blendMode);
/** /**
@ -511,10 +511,10 @@ extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_BlitSurface * \sa SDL_BlitSurface
* \sa SDL_GetClipRect * \sa SDL_GetSurfaceClipRect
*/ */
extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface, extern DECLSPEC SDL_bool SDLCALL SDL_SetSurfaceClipRect(SDL_Surface *surface,
const SDL_Rect * rect); const SDL_Rect *rect);
/** /**
* Get the clipping rectangle for a surface. * Get the clipping rectangle for a surface.
@ -530,21 +530,21 @@ extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_BlitSurface * \sa SDL_BlitSurface
* \sa SDL_SetClipRect * \sa SDL_SetSurfaceClipRect
*/ */
extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface, extern DECLSPEC void SDLCALL SDL_GetSurfaceClipRect(SDL_Surface *surface,
SDL_Rect * rect); SDL_Rect *rect);
/* /*
* Creates a new surface identical to the existing surface. * Creates a new surface identical to the existing surface.
* *
* The returned surface should be freed with SDL_FreeSurface(). * The returned surface should be freed with SDL_DestroySurface().
* *
* \param surface the surface to duplicate. * \param surface the surface to duplicate.
* \returns a copy of the surface, or NULL on failure; call SDL_GetError() for * \returns a copy of the surface, or NULL on failure; call SDL_GetError() for
* more information. * more information.
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface); extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface *surface);
/** /**
* Copy an existing surface to a new surface of the specified format. * Copy an existing surface to a new surface of the specified format.
@ -610,9 +610,9 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat(SDL_Surface *surfa
*/ */
extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height, extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
Uint32 src_format, Uint32 src_format,
const void * src, int src_pitch, const void *src, int src_pitch,
Uint32 dst_format, Uint32 dst_format,
void * dst, int dst_pitch); void *dst, int dst_pitch);
/** /**
* Premultiply the alpha on a block of pixels. * Premultiply the alpha on a block of pixels.
@ -636,9 +636,9 @@ extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
*/ */
extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height, extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height,
Uint32 src_format, Uint32 src_format,
const void * src, int src_pitch, const void *src, int src_pitch,
Uint32 dst_format, Uint32 dst_format,
void * dst, int dst_pitch); void *dst, int dst_pitch);
/** /**
* Perform a fast fill of a rectangle with a specific color. * Perform a fast fill of a rectangle with a specific color.
@ -649,7 +649,7 @@ extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height,
* information, no blending takes place. * information, no blending takes place.
* *
* If there is a clip rectangle set on the destination (set via * If there is a clip rectangle set on the destination (set via
* SDL_SetClipRect()), then this function will fill based on the intersection * SDL_SetSurfaceClipRect()), then this function will fill based on the intersection
* of the clip rectangle and `rect`. * of the clip rectangle and `rect`.
* *
* \param dst the SDL_Surface structure that is the drawing target * \param dst the SDL_Surface structure that is the drawing target
@ -661,10 +661,10 @@ extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height,
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_FillRects * \sa SDL_FillSurfaceRects
*/ */
extern DECLSPEC int SDLCALL SDL_FillRect extern DECLSPEC int SDLCALL SDL_FillSurfaceRect
(SDL_Surface * dst, const SDL_Rect * rect, Uint32 color); (SDL_Surface *dst, const SDL_Rect *rect, Uint32 color);
/** /**
* Perform a fast fill of a set of rectangles with a specific color. * Perform a fast fill of a set of rectangles with a specific color.
@ -675,7 +675,7 @@ extern DECLSPEC int SDLCALL SDL_FillRect
* information, no blending takes place. * information, no blending takes place.
* *
* If there is a clip rectangle set on the destination (set via * If there is a clip rectangle set on the destination (set via
* SDL_SetClipRect()), then this function will fill based on the intersection * SDL_SetSurfaceClipRect()), then this function will fill based on the intersection
* of the clip rectangle and `rect`. * of the clip rectangle and `rect`.
* *
* \param dst the SDL_Surface structure that is the drawing target * \param dst the SDL_Surface structure that is the drawing target
@ -687,12 +687,11 @@ extern DECLSPEC int SDLCALL SDL_FillRect
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_FillRect * \sa SDL_FillSurfaceRect
*/ */
extern DECLSPEC int SDLCALL SDL_FillRects extern DECLSPEC int SDLCALL SDL_FillSurfaceRects
(SDL_Surface * dst, const SDL_Rect * rects, int count, Uint32 color); (SDL_Surface *dst, const SDL_Rect *rects, int count, Uint32 color);
/* !!! FIXME: merge this documentation with the wiki */
/** /**
* Performs a fast blit from the source surface to the destination surface. * Performs a fast blit from the source surface to the destination surface.
* *
@ -701,8 +700,6 @@ extern DECLSPEC int SDLCALL SDL_FillRects
* surface (\c src or \c dst) is copied. The final blit rectangles are saved * surface (\c src or \c dst) is copied. The final blit rectangles are saved
* in \c srcrect and \c dstrect after all clipping is performed. * in \c srcrect and \c dstrect after all clipping is performed.
* *
* \returns 0 if the blit is successful, otherwise it returns -1.
*
* The blit function should not be called on a locked surface. * The blit function should not be called on a locked surface.
* *
* The blit semantics for surfaces with and without blending and colorkey * The blit semantics for surfaces with and without blending and colorkey
@ -747,24 +744,22 @@ extern DECLSPEC int SDLCALL SDL_FillRects
source color key. source color key.
\endverbatim \endverbatim
* *
* You should call SDL_BlitSurface() unless you know exactly how SDL * \param src the SDL_Surface structure to be copied from
* blitting works internally and how to use the other blit functions. * \param srcrect the SDL_Rect structure representing the rectangle to be
*/ * copied, or NULL to copy the entire surface
#define SDL_BlitSurface SDL_UpperBlit * \param dst the SDL_Surface structure that is the blit target
* \param dstrect the SDL_Rect structure representing the rectangle that is
/** * copied into
* Perform a fast blit from the source surface to the destination surface. * \returns 0 on success or a negative error code on failure; call
* * SDL_GetError() for more information.
* SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a
* macro for this function with a less confusing name.
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_BlitSurface * \sa SDL_BlitSurface
*/ */
extern DECLSPEC int SDLCALL SDL_UpperBlit extern DECLSPEC int SDLCALL SDL_BlitSurface
(SDL_Surface * src, const SDL_Rect * srcrect, (SDL_Surface *src, const SDL_Rect *srcrect,
SDL_Surface * dst, SDL_Rect * dstrect); SDL_Surface *dst, SDL_Rect *dstrect);
/** /**
* Perform low-level surface blitting only. * Perform low-level surface blitting only.
@ -772,9 +767,6 @@ extern DECLSPEC int SDLCALL SDL_UpperBlit
* This is a semi-private blit function and it performs low-level surface * This is a semi-private blit function and it performs low-level surface
* blitting, assuming the input rectangles have already been clipped. * blitting, assuming the input rectangles have already been clipped.
* *
* Unless you know what you're doing, you should be using SDL_BlitSurface()
* instead.
*
* \param src the SDL_Surface structure to be copied from * \param src the SDL_Surface structure to be copied from
* \param srcrect the SDL_Rect structure representing the rectangle to be * \param srcrect the SDL_Rect structure representing the rectangle to be
* copied, or NULL to copy the entire surface * copied, or NULL to copy the entire surface
@ -788,9 +780,9 @@ extern DECLSPEC int SDLCALL SDL_UpperBlit
* *
* \sa SDL_BlitSurface * \sa SDL_BlitSurface
*/ */
extern DECLSPEC int SDLCALL SDL_LowerBlit extern DECLSPEC int SDLCALL SDL_BlitSurfaceUnchecked
(SDL_Surface * src, SDL_Rect * srcrect, (SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface * dst, SDL_Rect * dstrect); SDL_Surface *dst, SDL_Rect *dstrect);
/** /**
@ -801,37 +793,41 @@ extern DECLSPEC int SDLCALL SDL_LowerBlit
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
*/ */
extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src, extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface *src,
const SDL_Rect * srcrect, const SDL_Rect *srcrect,
SDL_Surface * dst, SDL_Surface *dst,
const SDL_Rect * dstrect); const SDL_Rect *dstrect);
/** /**
* Perform bilinear scaling between two surfaces of the same format, 32BPP. * Perform bilinear scaling between two surfaces of the same format, 32BPP.
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
*/ */
extern DECLSPEC int SDLCALL SDL_SoftStretchLinear(SDL_Surface * src, extern DECLSPEC int SDLCALL SDL_SoftStretchLinear(SDL_Surface *src,
const SDL_Rect * srcrect, const SDL_Rect *srcrect,
SDL_Surface * dst, SDL_Surface *dst,
const SDL_Rect * dstrect); const SDL_Rect *dstrect);
#define SDL_BlitScaled SDL_UpperBlitScaled
/** /**
* Perform a scaled surface copy to a destination surface. * Perform a scaled surface copy to a destination surface.
* *
* SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is * \param src the SDL_Surface structure to be copied from
* merely a macro for this function with a less confusing name. * \param srcrect the SDL_Rect structure representing the rectangle to be
* copied
* \param dst the SDL_Surface structure that is the blit target
* \param dstrect the SDL_Rect structure representing the rectangle that is
* copied into
* \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. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_BlitScaled * \sa SDL_BlitScaled
*/ */
extern DECLSPEC int SDLCALL SDL_UpperBlitScaled extern DECLSPEC int SDLCALL SDL_BlitSurfaceScaled
(SDL_Surface * src, const SDL_Rect * srcrect, (SDL_Surface *src, const SDL_Rect *srcrect,
SDL_Surface * dst, SDL_Rect * dstrect); SDL_Surface *dst, SDL_Rect *dstrect);
/** /**
* Perform low-level surface scaled blitting only. * Perform low-level surface scaled blitting only.
@ -852,9 +848,9 @@ extern DECLSPEC int SDLCALL SDL_UpperBlitScaled
* *
* \sa SDL_BlitScaled * \sa SDL_BlitScaled
*/ */
extern DECLSPEC int SDLCALL SDL_LowerBlitScaled extern DECLSPEC int SDLCALL SDL_BlitSurfaceUncheckedScaled
(SDL_Surface * src, SDL_Rect * srcrect, (SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface * dst, SDL_Rect * dstrect); SDL_Surface *dst, SDL_Rect *dstrect);
/** /**
* Set the YUV conversion mode * Set the YUV conversion mode

2
src/SDL_internal.h
View File

@ -160,7 +160,7 @@
#endif #endif
/* Run-Length-Encoding /* Run-Length-Encoding
- SDL_SetColorKey() called with SDL_RLEACCEL flag */ - SDL_SetSurfaceColorKey() called with SDL_RLEACCEL flag */
#ifndef SDL_HAVE_RLE #ifndef SDL_HAVE_RLE
#define SDL_HAVE_RLE !SDL_LEAN_AND_MEAN #define SDL_HAVE_RLE !SDL_LEAN_AND_MEAN
#endif #endif

26
src/dynapi/SDL_dynapi.sym
View File

@ -360,38 +360,38 @@ SDL3_0.0.0 {
SDL_TLSCleanup; SDL_TLSCleanup;
SDL_CreateSurface; SDL_CreateSurface;
SDL_CreateSurfaceFrom; SDL_CreateSurfaceFrom;
SDL_FreeSurface; SDL_DestroySurface;
SDL_SetSurfacePalette; SDL_SetSurfacePalette;
SDL_LockSurface; SDL_LockSurface;
SDL_UnlockSurface; SDL_UnlockSurface;
SDL_LoadBMP_RW; SDL_LoadBMP_RW;
SDL_SaveBMP_RW; SDL_SaveBMP_RW;
SDL_SetSurfaceRLE; SDL_SetSurfaceRLE;
SDL_HasSurfaceRLE; SDL_SurfaceHasRLE;
SDL_SetColorKey; SDL_SetSurfaceColorKey;
SDL_HasColorKey; SDL_SurfaceHasColorKey;
SDL_GetColorKey; SDL_GetSurfaceColorKey;
SDL_SetSurfaceColorMod; SDL_SetSurfaceColorMod;
SDL_GetSurfaceColorMod; SDL_GetSurfaceColorMod;
SDL_SetSurfaceAlphaMod; SDL_SetSurfaceAlphaMod;
SDL_GetSurfaceAlphaMod; SDL_GetSurfaceAlphaMod;
SDL_SetSurfaceBlendMode; SDL_SetSurfaceBlendMode;
SDL_GetSurfaceBlendMode; SDL_GetSurfaceBlendMode;
SDL_SetClipRect; SDL_SetSurfaceClipRect;
SDL_GetClipRect; SDL_GetSurfaceClipRect;
SDL_DuplicateSurface; SDL_DuplicateSurface;
SDL_ConvertSurface; SDL_ConvertSurface;
SDL_ConvertSurfaceFormat; SDL_ConvertSurfaceFormat;
SDL_ConvertPixels; SDL_ConvertPixels;
SDL_PremultiplyAlpha; SDL_PremultiplyAlpha;
SDL_FillRect; SDL_FillSurfaceRect;
SDL_FillRects; SDL_FillSurfaceRects;
SDL_UpperBlit; SDL_BlitSurface;
SDL_LowerBlit; SDL_BlitSurfaceUnchecked;
SDL_SoftStretch; SDL_SoftStretch;
SDL_SoftStretchLinear; SDL_SoftStretchLinear;
SDL_UpperBlitScaled; SDL_BlitSurfaceScaled;
SDL_LowerBlitScaled; SDL_BlitSurfaceUncheckedScaled;
SDL_SetYUVConversionMode; SDL_SetYUVConversionMode;
SDL_GetYUVConversionMode; SDL_GetYUVConversionMode;
SDL_GetYUVConversionModeForResolution; SDL_GetYUVConversionModeForResolution;

26
src/dynapi/SDL_dynapi_overrides.h
View File

@ -425,33 +425,33 @@
#define SDL_iconv_close SDL_iconv_close_REAL #define SDL_iconv_close SDL_iconv_close_REAL
#define SDL_iconv SDL_iconv_REAL #define SDL_iconv SDL_iconv_REAL
#define SDL_iconv_string SDL_iconv_string_REAL #define SDL_iconv_string SDL_iconv_string_REAL
#define SDL_FreeSurface SDL_FreeSurface_REAL #define SDL_DestroySurface SDL_DestroySurface_REAL
#define SDL_SetSurfacePalette SDL_SetSurfacePalette_REAL #define SDL_SetSurfacePalette SDL_SetSurfacePalette_REAL
#define SDL_LockSurface SDL_LockSurface_REAL #define SDL_LockSurface SDL_LockSurface_REAL
#define SDL_UnlockSurface SDL_UnlockSurface_REAL #define SDL_UnlockSurface SDL_UnlockSurface_REAL
#define SDL_LoadBMP_RW SDL_LoadBMP_RW_REAL #define SDL_LoadBMP_RW SDL_LoadBMP_RW_REAL
#define SDL_SaveBMP_RW SDL_SaveBMP_RW_REAL #define SDL_SaveBMP_RW SDL_SaveBMP_RW_REAL
#define SDL_SetSurfaceRLE SDL_SetSurfaceRLE_REAL #define SDL_SetSurfaceRLE SDL_SetSurfaceRLE_REAL
#define SDL_SetColorKey SDL_SetColorKey_REAL #define SDL_SetSurfaceColorKey SDL_SetSurfaceColorKey_REAL
#define SDL_GetColorKey SDL_GetColorKey_REAL #define SDL_GetSurfaceColorKey SDL_GetSurfaceColorKey_REAL
#define SDL_SetSurfaceColorMod SDL_SetSurfaceColorMod_REAL #define SDL_SetSurfaceColorMod SDL_SetSurfaceColorMod_REAL
#define SDL_GetSurfaceColorMod SDL_GetSurfaceColorMod_REAL #define SDL_GetSurfaceColorMod SDL_GetSurfaceColorMod_REAL
#define SDL_SetSurfaceAlphaMod SDL_SetSurfaceAlphaMod_REAL #define SDL_SetSurfaceAlphaMod SDL_SetSurfaceAlphaMod_REAL
#define SDL_GetSurfaceAlphaMod SDL_GetSurfaceAlphaMod_REAL #define SDL_GetSurfaceAlphaMod SDL_GetSurfaceAlphaMod_REAL
#define SDL_SetSurfaceBlendMode SDL_SetSurfaceBlendMode_REAL #define SDL_SetSurfaceBlendMode SDL_SetSurfaceBlendMode_REAL
#define SDL_GetSurfaceBlendMode SDL_GetSurfaceBlendMode_REAL #define SDL_GetSurfaceBlendMode SDL_GetSurfaceBlendMode_REAL
#define SDL_SetClipRect SDL_SetClipRect_REAL #define SDL_SetSurfaceClipRect SDL_SetSurfaceClipRect_REAL
#define SDL_GetClipRect SDL_GetClipRect_REAL #define SDL_GetSurfaceClipRect SDL_GetSurfaceClipRect_REAL
#define SDL_ConvertSurface SDL_ConvertSurface_REAL #define SDL_ConvertSurface SDL_ConvertSurface_REAL
#define SDL_ConvertSurfaceFormat SDL_ConvertSurfaceFormat_REAL #define SDL_ConvertSurfaceFormat SDL_ConvertSurfaceFormat_REAL
#define SDL_ConvertPixels SDL_ConvertPixels_REAL #define SDL_ConvertPixels SDL_ConvertPixels_REAL
#define SDL_FillRect SDL_FillRect_REAL #define SDL_FillSurfaceRect SDL_FillSurfaceRect_REAL
#define SDL_FillRects SDL_FillRects_REAL #define SDL_FillSurfaceRects SDL_FillSurfaceRects_REAL
#define SDL_UpperBlit SDL_UpperBlit_REAL #define SDL_BlitSurface SDL_BlitSurface_REAL
#define SDL_LowerBlit SDL_LowerBlit_REAL #define SDL_BlitSurfaceUnchecked SDL_BlitSurfaceUnchecked_REAL
#define SDL_SoftStretch SDL_SoftStretch_REAL #define SDL_SoftStretch SDL_SoftStretch_REAL
#define SDL_UpperBlitScaled SDL_UpperBlitScaled_REAL #define SDL_BlitSurfaceScaled SDL_BlitSurfaceScaled_REAL
#define SDL_LowerBlitScaled SDL_LowerBlitScaled_REAL #define SDL_BlitSurfaceUncheckedScaled SDL_BlitSurfaceUncheckedScaled_REAL
#define SDL_GetThreadName SDL_GetThreadName_REAL #define SDL_GetThreadName SDL_GetThreadName_REAL
#define SDL_ThreadID SDL_ThreadID_REAL #define SDL_ThreadID SDL_ThreadID_REAL
#define SDL_GetThreadID SDL_GetThreadID_REAL #define SDL_GetThreadID SDL_GetThreadID_REAL
@ -668,7 +668,7 @@
#define SDL_UpdateSensors SDL_UpdateSensors_REAL #define SDL_UpdateSensors SDL_UpdateSensors_REAL
#define SDL_IsTablet SDL_IsTablet_REAL #define SDL_IsTablet SDL_IsTablet_REAL
#define SDL_GetDisplayOrientation SDL_GetDisplayOrientation_REAL #define SDL_GetDisplayOrientation SDL_GetDisplayOrientation_REAL
#define SDL_HasColorKey SDL_HasColorKey_REAL #define SDL_SurfaceHasColorKey SDL_SurfaceHasColorKey_REAL
#define SDL_CreateThreadWithStackSize SDL_CreateThreadWithStackSize_REAL #define SDL_CreateThreadWithStackSize SDL_CreateThreadWithStackSize_REAL
#define SDL_GetJoystickDevicePlayerIndex SDL_GetJoystickDevicePlayerIndex_REAL #define SDL_GetJoystickDevicePlayerIndex SDL_GetJoystickDevicePlayerIndex_REAL
#define SDL_GetJoystickPlayerIndex SDL_GetJoystickPlayerIndex_REAL #define SDL_GetJoystickPlayerIndex SDL_GetJoystickPlayerIndex_REAL
@ -737,7 +737,7 @@
#define SDL_SIMDRealloc SDL_SIMDRealloc_REAL #define SDL_SIMDRealloc SDL_SIMDRealloc_REAL
#define SDL_AndroidRequestPermission SDL_AndroidRequestPermission_REAL #define SDL_AndroidRequestPermission SDL_AndroidRequestPermission_REAL
#define SDL_OpenURL SDL_OpenURL_REAL #define SDL_OpenURL SDL_OpenURL_REAL
#define SDL_HasSurfaceRLE SDL_HasSurfaceRLE_REAL #define SDL_SurfaceHasRLE SDL_SurfaceHasRLE_REAL
#define SDL_GameControllerHasLED SDL_GameControllerHasLED_REAL #define SDL_GameControllerHasLED SDL_GameControllerHasLED_REAL
#define SDL_GameControllerSetLED SDL_GameControllerSetLED_REAL #define SDL_GameControllerSetLED SDL_GameControllerSetLED_REAL
#define SDL_JoystickHasLED SDL_JoystickHasLED_REAL #define SDL_JoystickHasLED SDL_JoystickHasLED_REAL

26
src/dynapi/SDL_dynapi_procs.h
View File

@ -452,33 +452,33 @@ SDL_DYNAPI_PROC(SDL_iconv_t,SDL_iconv_open,(const char *a, const char *b),(a,b),
SDL_DYNAPI_PROC(int,SDL_iconv_close,(SDL_iconv_t a),(a),return) SDL_DYNAPI_PROC(int,SDL_iconv_close,(SDL_iconv_t a),(a),return)
SDL_DYNAPI_PROC(size_t,SDL_iconv,(SDL_iconv_t a, const char **b, size_t *c, char **d, size_t *e),(a,b,c,d,e),return) SDL_DYNAPI_PROC(size_t,SDL_iconv,(SDL_iconv_t a, const char **b, size_t *c, char **d, size_t *e),(a,b,c,d,e),return)
SDL_DYNAPI_PROC(char*,SDL_iconv_string,(const char *a, const char *b, const char *c, size_t d),(a,b,c,d),return) SDL_DYNAPI_PROC(char*,SDL_iconv_string,(const char *a, const char *b, const char *c, size_t d),(a,b,c,d),return)
SDL_DYNAPI_PROC(void,SDL_FreeSurface,(SDL_Surface *a),(a),) SDL_DYNAPI_PROC(void,SDL_DestroySurface,(SDL_Surface *a),(a),)
SDL_DYNAPI_PROC(int,SDL_SetSurfacePalette,(SDL_Surface *a, SDL_Palette *b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_SetSurfacePalette,(SDL_Surface *a, SDL_Palette *b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_LockSurface,(SDL_Surface *a),(a),return) SDL_DYNAPI_PROC(int,SDL_LockSurface,(SDL_Surface *a),(a),return)
SDL_DYNAPI_PROC(void,SDL_UnlockSurface,(SDL_Surface *a),(a),) SDL_DYNAPI_PROC(void,SDL_UnlockSurface,(SDL_Surface *a),(a),)
SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP_RW,(SDL_RWops *a, int b),(a,b),return) SDL_DYNAPI_PROC(SDL_Surface*,SDL_LoadBMP_RW,(SDL_RWops *a, int b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_SaveBMP_RW,(SDL_Surface *a, SDL_RWops *b, int c),(a,b,c),return) SDL_DYNAPI_PROC(int,SDL_SaveBMP_RW,(SDL_Surface *a, SDL_RWops *b, int c),(a,b,c),return)
SDL_DYNAPI_PROC(int,SDL_SetSurfaceRLE,(SDL_Surface *a, int b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_SetSurfaceRLE,(SDL_Surface *a, int b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_SetColorKey,(SDL_Surface *a, int b, Uint32 c),(a,b,c),return) SDL_DYNAPI_PROC(int,SDL_SetSurfaceColorKey,(SDL_Surface *a, int b, Uint32 c),(a,b,c),return)
SDL_DYNAPI_PROC(int,SDL_GetColorKey,(SDL_Surface *a, Uint32 *b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_GetSurfaceColorKey,(SDL_Surface *a, Uint32 *b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_SetSurfaceColorMod,(SDL_Surface *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_SetSurfaceColorMod,(SDL_Surface *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_GetSurfaceColorMod,(SDL_Surface *a, Uint8 *b, Uint8 *c, Uint8 *d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_GetSurfaceColorMod,(SDL_Surface *a, Uint8 *b, Uint8 *c, Uint8 *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_SetSurfaceAlphaMod,(SDL_Surface *a, Uint8 b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_SetSurfaceAlphaMod,(SDL_Surface *a, Uint8 b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_GetSurfaceAlphaMod,(SDL_Surface *a, Uint8 *b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_GetSurfaceAlphaMod,(SDL_Surface *a, Uint8 *b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_SetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_SetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_GetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode *b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_GetSurfaceBlendMode,(SDL_Surface *a, SDL_BlendMode *b),(a,b),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_SetClipRect,(SDL_Surface *a, const SDL_Rect *b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SetSurfaceClipRect,(SDL_Surface *a, const SDL_Rect *b),(a,b),return)
SDL_DYNAPI_PROC(void,SDL_GetClipRect,(SDL_Surface *a, SDL_Rect *b),(a,b),) SDL_DYNAPI_PROC(void,SDL_GetSurfaceClipRect,(SDL_Surface *a, SDL_Rect *b),(a,b),)
SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurface,(SDL_Surface *a, const SDL_PixelFormat *b),(a,b),return) SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurface,(SDL_Surface *a, const SDL_PixelFormat *b),(a,b),return)
SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurfaceFormat,(SDL_Surface *a, Uint32 b),(a,b),return) SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurfaceFormat,(SDL_Surface *a, Uint32 b),(a,b),return)
SDL_DYNAPI_PROC(int,SDL_ConvertPixels,(int a, int b, Uint32 c, const void *d, int e, Uint32 f, void *g, int h),(a,b,c,d,e,f,g,h),return) SDL_DYNAPI_PROC(int,SDL_ConvertPixels,(int a, int b, Uint32 c, const void *d, int e, Uint32 f, void *g, int h),(a,b,c,d,e,f,g,h),return)
SDL_DYNAPI_PROC(int,SDL_FillRect,(SDL_Surface *a, const SDL_Rect *b, Uint32 c),(a,b,c),return) SDL_DYNAPI_PROC(int,SDL_FillSurfaceRect,(SDL_Surface *a, const SDL_Rect *b, Uint32 c),(a,b,c),return)
SDL_DYNAPI_PROC(int,SDL_FillRects,(SDL_Surface *a, const SDL_Rect *b, int c, Uint32 d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_FillSurfaceRects,(SDL_Surface *a, const SDL_Rect *b, int c, Uint32 d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_UpperBlit,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_BlitSurface,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_LowerBlit,(SDL_Surface *a, SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_BlitSurfaceUnchecked,(SDL_Surface *a, SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_SoftStretch,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_SoftStretch,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_UpperBlitScaled,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_BlitSurfaceScaled,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(int,SDL_LowerBlitScaled,(SDL_Surface *a, SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_BlitSurfaceUncheckedScaled,(SDL_Surface *a, SDL_Rect *b, SDL_Surface *c, SDL_Rect *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(const char*,SDL_GetThreadName,(SDL_Thread *a),(a),return) SDL_DYNAPI_PROC(const char*,SDL_GetThreadName,(SDL_Thread *a),(a),return)
SDL_DYNAPI_PROC(SDL_threadID,SDL_ThreadID,(void),(),return) SDL_DYNAPI_PROC(SDL_threadID,SDL_ThreadID,(void),(),return)
SDL_DYNAPI_PROC(SDL_threadID,SDL_GetThreadID,(SDL_Thread *a),(a),return) SDL_DYNAPI_PROC(SDL_threadID,SDL_GetThreadID,(SDL_Thread *a),(a),return)
@ -709,7 +709,7 @@ SDL_DYNAPI_PROC(void,SDL_CloseSensor,(SDL_Sensor *a),(a),)
SDL_DYNAPI_PROC(void,SDL_UpdateSensors,(void),(),) SDL_DYNAPI_PROC(void,SDL_UpdateSensors,(void),(),)
SDL_DYNAPI_PROC(SDL_bool,SDL_IsTablet,(void),(),return) SDL_DYNAPI_PROC(SDL_bool,SDL_IsTablet,(void),(),return)
SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetDisplayOrientation,(int a),(a),return) SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetDisplayOrientation,(int a),(a),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_HasColorKey,(SDL_Surface *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SurfaceHasColorKey,(SDL_Surface *a),(a),return)
#ifdef SDL_CreateThreadWithStackSize #ifdef SDL_CreateThreadWithStackSize
#undef SDL_CreateThreadWithStackSize #undef SDL_CreateThreadWithStackSize
@ -794,7 +794,7 @@ SDL_DYNAPI_PROC(void*,SDL_SIMDRealloc,(void *a, const size_t b),(a,b),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_AndroidRequestPermission,(const char *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_AndroidRequestPermission,(const char *a),(a),return)
#endif #endif
SDL_DYNAPI_PROC(int,SDL_OpenURL,(const char *a),(a),return) SDL_DYNAPI_PROC(int,SDL_OpenURL,(const char *a),(a),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_HasSurfaceRLE,(SDL_Surface *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SurfaceHasRLE,(SDL_Surface *a),(a),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_GameControllerHasLED,(SDL_GameController *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_GameControllerHasLED,(SDL_GameController *a),(a),return)
SDL_DYNAPI_PROC(int,SDL_GameControllerSetLED,(SDL_GameController *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return) SDL_DYNAPI_PROC(int,SDL_GameControllerSetLED,(SDL_GameController *a, Uint8 b, Uint8 c, Uint8 d),(a,b,c,d),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_JoystickHasLED,(SDL_Joystick *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_JoystickHasLED,(SDL_Joystick *a),(a),return)

4
src/events/SDL_mouse.c
View File

@ -1247,7 +1247,7 @@ SDL_CreateCursor(const Uint8 *data, const Uint8 *mask,
cursor = SDL_CreateColorCursor(surface, hot_x, hot_y); cursor = SDL_CreateColorCursor(surface, hot_x, hot_y);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
return cursor; return cursor;
} }
@ -1290,7 +1290,7 @@ SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y)
mouse->cursors = cursor; mouse->cursors = cursor;
} }
SDL_FreeSurface(temp); SDL_DestroySurface(temp);
return cursor; return cursor;
} }

14
src/render/SDL_render.c
View File

@ -1348,7 +1348,7 @@ SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
/* See what the best texture format is */ /* See what the best texture format is */
fmt = surface->format; fmt = surface->format;
if (fmt->Amask || SDL_HasColorKey(surface)) { if (fmt->Amask || SDL_SurfaceHasColorKey(surface)) {
needAlpha = SDL_TRUE; needAlpha = SDL_TRUE;
} else { } else {
needAlpha = SDL_FALSE; needAlpha = SDL_FALSE;
@ -1365,7 +1365,7 @@ SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
/* Try to have the best pixel format for the texture */ /* Try to have the best pixel format for the texture */
/* No alpha, but a colorkey => promote to alpha */ /* No alpha, but a colorkey => promote to alpha */
if (!fmt->Amask && SDL_HasColorKey(surface)) { if (!fmt->Amask && SDL_SurfaceHasColorKey(surface)) {
if (fmt->format == SDL_PIXELFORMAT_RGB888) { if (fmt->format == SDL_PIXELFORMAT_RGB888) {
for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) { for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
if (renderer->info.texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) { if (renderer->info.texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) {
@ -1410,7 +1410,7 @@ SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
} }
if (format == surface->format->format) { if (format == surface->format->format) {
if (surface->format->Amask && SDL_HasColorKey(surface)) { if (surface->format->Amask && SDL_SurfaceHasColorKey(surface)) {
/* Surface and Renderer formats are identicals. /* Surface and Renderer formats are identicals.
* Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */ * Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */
direct_update = SDL_FALSE; direct_update = SDL_FALSE;
@ -1445,7 +1445,7 @@ SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
SDL_DestroyPixelFormat(dst_fmt); SDL_DestroyPixelFormat(dst_fmt);
if (temp) { if (temp) {
SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch); SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
SDL_FreeSurface(temp); SDL_DestroySurface(temp);
} else { } else {
SDL_DestroyTexture(texture); SDL_DestroyTexture(texture);
return NULL; return NULL;
@ -1462,7 +1462,7 @@ SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
SDL_GetSurfaceAlphaMod(surface, &a); SDL_GetSurfaceAlphaMod(surface, &a);
SDL_SetTextureAlphaMod(texture, a); SDL_SetTextureAlphaMod(texture, a);
if (SDL_HasColorKey(surface)) { if (SDL_SurfaceHasColorKey(surface)) {
/* We converted to a texture with alpha format */ /* We converted to a texture with alpha format */
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
} else { } else {
@ -2136,7 +2136,7 @@ void SDL_UnlockTexture(SDL_Texture *texture)
renderer->UnlockTexture(renderer, texture); renderer->UnlockTexture(renderer, texture);
} }
SDL_FreeSurface(texture->locked_surface); SDL_DestroySurface(texture->locked_surface);
texture->locked_surface = NULL; texture->locked_surface = NULL;
} }
@ -4261,7 +4261,7 @@ void SDL_DestroyTexture(SDL_Texture *texture)
renderer->DestroyTexture(renderer, texture); renderer->DestroyTexture(renderer, texture);
SDL_FreeSurface(texture->locked_surface); SDL_DestroySurface(texture->locked_surface);
texture->locked_surface = NULL; texture->locked_surface = NULL;
SDL_free(texture); SDL_free(texture);

6
src/render/SDL_yuv_sw.c
View File

@ -342,7 +342,7 @@ int SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture *swdata, const SDL_Rect *srcrect,
/* Make sure we're set up to display in the desired format */ /* Make sure we're set up to display in the desired format */
if (target_format != swdata->target_format && swdata->display) { if (target_format != swdata->target_format && swdata->display) {
SDL_FreeSurface(swdata->display); SDL_DestroySurface(swdata->display);
swdata->display = NULL; swdata->display = NULL;
} }
@ -394,8 +394,8 @@ void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture *swdata)
{ {
if (swdata) { if (swdata) {
SDL_SIMDFree(swdata->pixels); SDL_SIMDFree(swdata->pixels);
SDL_FreeSurface(swdata->stretch); SDL_DestroySurface(swdata->stretch);
SDL_FreeSurface(swdata->display); SDL_DestroySurface(swdata->display);
SDL_free(swdata); SDL_free(swdata);
} }
} }

26
src/render/software/SDL_render_sw.c
View File

@ -400,7 +400,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
} else { } else {
SDL_SetSurfaceBlendMode(src_clone, SDL_BLENDMODE_NONE); SDL_SetSurfaceBlendMode(src_clone, SDL_BLENDMODE_NONE);
retval = SDL_PrivateUpperBlitScaled(src_clone, srcrect, src_scaled, &scale_rect, texture->scaleMode); retval = SDL_PrivateUpperBlitScaled(src_clone, srcrect, src_scaled, &scale_rect, texture->scaleMode);
SDL_FreeSurface(src_clone); SDL_DestroySurface(src_clone);
src_clone = src_scaled; src_clone = src_scaled;
src_scaled = NULL; src_scaled = NULL;
} }
@ -488,14 +488,14 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
SDL_SetSurfaceBlendMode(src_rotated_rgb, SDL_BLENDMODE_ADD); SDL_SetSurfaceBlendMode(src_rotated_rgb, SDL_BLENDMODE_ADD);
/* Renderer scaling, if needed */ /* Renderer scaling, if needed */
retval = Blit_to_Screen(src_rotated_rgb, NULL, surface, &tmp_rect, scale_x, scale_y, texture->scaleMode); retval = Blit_to_Screen(src_rotated_rgb, NULL, surface, &tmp_rect, scale_x, scale_y, texture->scaleMode);
SDL_FreeSurface(src_rotated_rgb); SDL_DestroySurface(src_rotated_rgb);
} }
} }
} }
SDL_FreeSurface(mask_rotated); SDL_DestroySurface(mask_rotated);
} }
if (src_rotated != NULL) { if (src_rotated != NULL) {
SDL_FreeSurface(src_rotated); SDL_DestroySurface(src_rotated);
} }
} }
} }
@ -504,10 +504,10 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
SDL_UnlockSurface(src); SDL_UnlockSurface(src);
} }
if (mask != NULL) { if (mask != NULL) {
SDL_FreeSurface(mask); SDL_DestroySurface(mask);
} }
if (src_clone != NULL) { if (src_clone != NULL) {
SDL_FreeSurface(src_clone); SDL_DestroySurface(src_clone);
} }
return retval; return retval;
} }
@ -645,9 +645,9 @@ static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
clip_rect.w = cliprect->w; clip_rect.w = cliprect->w;
clip_rect.h = cliprect->h; clip_rect.h = cliprect->h;
SDL_IntersectRect(viewport, &clip_rect, &clip_rect); SDL_IntersectRect(viewport, &clip_rect, &clip_rect);
SDL_SetClipRect(surface, &clip_rect); SDL_SetSurfaceClipRect(surface, &clip_rect);
} else { } else {
SDL_SetClipRect(surface, drawstate->viewport); SDL_SetSurfaceClipRect(surface, drawstate->viewport);
} }
drawstate->surface_cliprect_dirty = SDL_FALSE; drawstate->surface_cliprect_dirty = SDL_FALSE;
} }
@ -694,8 +694,8 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
const Uint8 b = cmd->data.color.b; const Uint8 b = cmd->data.color.b;
const Uint8 a = cmd->data.color.a; const Uint8 a = cmd->data.color.a;
/* By definition the clear ignores the clip rect */ /* By definition the clear ignores the clip rect */
SDL_SetClipRect(surface, NULL); SDL_SetSurfaceClipRect(surface, NULL);
SDL_FillRect(surface, NULL, SDL_MapRGBA(surface->format, r, g, b, a)); SDL_FillSurfaceRect(surface, NULL, SDL_MapRGBA(surface->format, r, g, b, a));
drawstate.surface_cliprect_dirty = SDL_TRUE; drawstate.surface_cliprect_dirty = SDL_TRUE;
break; break;
} }
@ -777,7 +777,7 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
} }
if (blend == SDL_BLENDMODE_NONE) { if (blend == SDL_BLENDMODE_NONE) {
SDL_FillRects(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a)); SDL_FillSurfaceRects(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
} else { } else {
SDL_BlendFillRects(surface, verts, count, blend, r, g, b, a); SDL_BlendFillRects(surface, verts, count, blend, r, g, b, a);
} }
@ -839,7 +839,7 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
SDL_SetSurfaceBlendMode(tmp, blendmode); SDL_SetSurfaceBlendMode(tmp, blendmode);
SDL_BlitSurface(tmp, NULL, surface, dstrect); SDL_BlitSurface(tmp, NULL, surface, dstrect);
SDL_FreeSurface(tmp); SDL_DestroySurface(tmp);
/* No need to set back r/g/b/a/blendmode to 'src' since it's done in PrepTextureForCopy() */ /* No need to set back r/g/b/a/blendmode to 'src' since it's done in PrepTextureForCopy() */
} }
} else { } else {
@ -980,7 +980,7 @@ static void SW_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
{ {
SDL_Surface *surface = (SDL_Surface *)texture->driverdata; SDL_Surface *surface = (SDL_Surface *)texture->driverdata;
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
static void SW_DestroyRenderer(SDL_Renderer *renderer) static void SW_DestroyRenderer(SDL_Renderer *renderer)

16
src/render/software/SDL_rotate.c
View File

@ -80,8 +80,8 @@ to a situation where the program can segfault.
static Uint32 get_colorkey(SDL_Surface *src) static Uint32 get_colorkey(SDL_Surface *src)
{ {
Uint32 key = 0; Uint32 key = 0;
if (SDL_HasColorKey(src)) { if (SDL_SurfaceHasColorKey(src)) {
SDL_GetColorKey(src, &key); SDL_GetSurfaceColorKey(src, &key);
} }
return key; return key;
} }
@ -504,8 +504,8 @@ SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int
return NULL; return NULL;
} }
if (SDL_HasColorKey(src)) { if (SDL_SurfaceHasColorKey(src)) {
if (SDL_GetColorKey(src, &colorkey) == 0) { if (SDL_GetSurfaceColorKey(src, &colorkey) == 0) {
colorKeyAvailable = SDL_TRUE; colorKeyAvailable = SDL_TRUE;
} }
} }
@ -549,8 +549,8 @@ SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int
if (colorKeyAvailable == SDL_TRUE) { if (colorKeyAvailable == SDL_TRUE) {
/* If available, the colorkey will be used to discard the pixels that are outside of the rotated area. */ /* If available, the colorkey will be used to discard the pixels that are outside of the rotated area. */
SDL_SetColorKey(rz_dst, SDL_TRUE, colorkey); SDL_SetSurfaceColorKey(rz_dst, SDL_TRUE, colorkey);
SDL_FillRect(rz_dst, NULL, colorkey); SDL_FillSurfaceRect(rz_dst, NULL, colorkey);
} else if (blendmode == SDL_BLENDMODE_NONE) { } else if (blendmode == SDL_BLENDMODE_NONE) {
blendmode = SDL_BLENDMODE_BLEND; blendmode = SDL_BLENDMODE_BLEND;
} else if (blendmode == SDL_BLENDMODE_MOD || blendmode == SDL_BLENDMODE_MUL) { } else if (blendmode == SDL_BLENDMODE_MOD || blendmode == SDL_BLENDMODE_MUL) {
@ -558,12 +558,12 @@ SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int
* that the pixels outside the rotated area don't affect the destination surface. * that the pixels outside the rotated area don't affect the destination surface.
*/ */
colorkey = SDL_MapRGBA(rz_dst->format, 255, 255, 255, 0); colorkey = SDL_MapRGBA(rz_dst->format, 255, 255, 255, 0);
SDL_FillRect(rz_dst, NULL, colorkey); SDL_FillSurfaceRect(rz_dst, NULL, colorkey);
/* Setting a white colorkey for the destination surface makes the final blit discard /* Setting a white colorkey for the destination surface makes the final blit discard
* all pixels outside of the rotated area. This doesn't interfere with anything because * all pixels outside of the rotated area. This doesn't interfere with anything because
* white pixels are already a no-op and the MOD blend mode does not interact with alpha. * white pixels are already a no-op and the MOD blend mode does not interact with alpha.
*/ */
SDL_SetColorKey(rz_dst, SDL_TRUE, colorkey); SDL_SetSurfaceColorKey(rz_dst, SDL_TRUE, colorkey);
} }
SDL_SetSurfaceBlendMode(rz_dst, blendmode); SDL_SetSurfaceBlendMode(rz_dst, blendmode);

8
src/render/software/SDL_triangle.c
View File

@ -257,7 +257,7 @@ int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Poin
{ {
/* Clip triangle with surface clip rect */ /* Clip triangle with surface clip rect */
SDL_Rect rect; SDL_Rect rect;
SDL_GetClipRect(dst, &rect); SDL_GetSurfaceClipRect(dst, &rect);
SDL_IntersectRect(&dstrect, &rect, &dstrect); SDL_IntersectRect(&dstrect, &rect, &dstrect);
} }
@ -278,7 +278,7 @@ int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Poin
if (blend == SDL_BLENDMODE_MOD) { if (blend == SDL_BLENDMODE_MOD) {
Uint32 c = SDL_MapRGBA(tmp->format, 255, 255, 255, 255); Uint32 c = SDL_MapRGBA(tmp->format, 255, 255, 255, 255);
SDL_FillRect(tmp, NULL, c); SDL_FillSurfaceRect(tmp, NULL, c);
} }
SDL_SetSurfaceBlendMode(tmp, blend); SDL_SetSurfaceBlendMode(tmp, blend);
@ -417,7 +417,7 @@ int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Poin
if (tmp) { if (tmp) {
SDL_BlitSurface(tmp, NULL, dst, &dstrect); SDL_BlitSurface(tmp, NULL, dst, &dstrect);
SDL_FreeSurface(tmp); SDL_DestroySurface(tmp);
} }
end: end:
@ -553,7 +553,7 @@ int SDL_SW_BlitTriangle(
{ {
/* Clip triangle with surface clip rect */ /* Clip triangle with surface clip rect */
SDL_Rect rect; SDL_Rect rect;
SDL_GetClipRect(dst, &rect); SDL_GetSurfaceClipRect(dst, &rect);
SDL_IntersectRect(&dstrect, &rect, &dstrect); SDL_IntersectRect(&dstrect, &rect, &dstrect);
} }

4
src/test/SDL_test_common.c
View File

@ -997,7 +997,7 @@ static SDL_Surface *SDLTest_LoadIcon(const char *file)
if (icon->format->palette) { if (icon->format->palette) {
/* Set the colorkey */ /* Set the colorkey */
SDL_SetColorKey(icon, 1, *((Uint8 *)icon->pixels)); SDL_SetSurfaceColorKey(icon, 1, *((Uint8 *)icon->pixels));
} }
return icon; return icon;
@ -1297,7 +1297,7 @@ SDLTest_CommonInit(SDLTest_CommonState *state)
SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon); SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
if (icon) { if (icon) {
SDL_SetWindowIcon(state->windows[i], icon); SDL_SetWindowIcon(state->windows[i], icon);
SDL_FreeSurface(icon); SDL_DestroySurface(icon);
} }
} }

2
src/test/SDL_test_font.c
View File

@ -3213,7 +3213,7 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, Uint32 c)
/* Convert temp surface into texture */ /* Convert temp surface into texture */
cache->charTextureCache[ci] = SDL_CreateTextureFromSurface(renderer, character); cache->charTextureCache[ci] = SDL_CreateTextureFromSurface(renderer, character);
SDL_FreeSurface(character); SDL_DestroySurface(character);
/* /*
* Check pointer * Check pointer

2
src/video/SDL_RLEaccel.c
View File

@ -1565,7 +1565,7 @@ void SDL_UnRLESurface(SDL_Surface *surface, int recode)
surface->flags |= SDL_SIMD_ALIGNED; surface->flags |= SDL_SIMD_ALIGNED;
/* fill it with the background color */ /* fill it with the background color */
SDL_FillRect(surface, NULL, surface->map->info.colorkey); SDL_FillSurfaceRect(surface, NULL, surface->map->info.colorkey);
/* now render the encoded surface */ /* now render the encoded surface */
full.x = full.y = 0; full.x = full.y = 0;

4
src/video/SDL_bmp.c
View File

@ -616,7 +616,7 @@ done:
if (src) { if (src) {
SDL_RWseek(src, fp_offset, SDL_RW_SEEK_SET); SDL_RWseek(src, fp_offset, SDL_RW_SEEK_SET);
} }
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = NULL; surface = NULL;
} }
if (freesrc && src) { if (freesrc && src) {
@ -861,7 +861,7 @@ int SDL_SaveBMP_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst)
/* Close it up.. */ /* Close it up.. */
SDL_UnlockSurface(intermediate_surface); SDL_UnlockSurface(intermediate_surface);
if (intermediate_surface != surface) { if (intermediate_surface != surface) {
SDL_FreeSurface(intermediate_surface); SDL_DestroySurface(intermediate_surface);
} }
} }

66
src/video/SDL_fillrect.c
View File

@ -56,7 +56,7 @@
#define SSE_END #define SSE_END
#define DEFINE_SSE_FILLRECT(bpp, type) \ #define DEFINE_SSE_FILLRECT(bpp, type) \
static void SDL_FillRect##bpp##SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h) \ static void SDL_FillSurfaceRect##bpp##SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h) \
{ \ { \
int i, n; \ int i, n; \
Uint8 *p = NULL; \ Uint8 *p = NULL; \
@ -93,7 +93,7 @@ static void SDL_FillRect##bpp##SSE(Uint8 *pixels, int pitch, Uint32 color, int w
SSE_END; \ SSE_END; \
} }
static void SDL_FillRect1SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void SDL_FillSurfaceRect1SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
int i, n; int i, n;
@ -127,7 +127,7 @@ DEFINE_SSE_FILLRECT(4, Uint32)
/* *INDENT-ON* */ /* clang-format on */ /* *INDENT-ON* */ /* clang-format on */
#endif /* __SSE__ */ #endif /* __SSE__ */
static void SDL_FillRect1(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void SDL_FillSurfaceRect1(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
int n; int n;
Uint8 *p = NULL; Uint8 *p = NULL;
@ -169,7 +169,7 @@ static void SDL_FillRect1(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
} }
} }
static void SDL_FillRect2(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void SDL_FillSurfaceRect2(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
int n; int n;
Uint16 *p = NULL; Uint16 *p = NULL;
@ -192,7 +192,7 @@ static void SDL_FillRect2(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
} }
} }
static void SDL_FillRect3(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void SDL_FillSurfaceRect3(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
#if SDL_BYTEORDER == SDL_LIL_ENDIAN #if SDL_BYTEORDER == SDL_LIL_ENDIAN
Uint8 b1 = (Uint8)(color & 0xFF); Uint8 b1 = (Uint8)(color & 0xFF);
@ -219,7 +219,7 @@ static void SDL_FillRect3(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
} }
} }
static void SDL_FillRect4(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void SDL_FillSurfaceRect4(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
while (h--) { while (h--) {
SDL_memset4(pixels, color, w); SDL_memset4(pixels, color, w);
@ -230,10 +230,10 @@ static void SDL_FillRect4(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
/* /*
* This function performs a fast fill of the given rectangle with 'color' * This function performs a fast fill of the given rectangle with 'color'
*/ */
int SDL_FillRect(SDL_Surface *dst, const SDL_Rect *rect, Uint32 color) int SDL_FillSurfaceRect(SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
{ {
if (dst == NULL) { if (dst == NULL) {
return SDL_InvalidParamError("SDL_FillRect(): dst"); return SDL_InvalidParamError("SDL_FillSurfaceRect(): dst");
} }
/* If 'rect' == NULL, then fill the whole surface */ /* If 'rect' == NULL, then fill the whole surface */
@ -245,58 +245,58 @@ int SDL_FillRect(SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
} }
} }
return SDL_FillRects(dst, rect, 1, color); return SDL_FillSurfaceRects(dst, rect, 1, color);
} }
#if SDL_ARM_NEON_BLITTERS #if SDL_ARM_NEON_BLITTERS
void FillRect8ARMNEONAsm(int32_t w, int32_t h, uint8_t *dst, int32_t dst_stride, uint8_t src); void FillSurfaceRect8ARMNEONAsm(int32_t w, int32_t h, uint8_t *dst, int32_t dst_stride, uint8_t src);
void FillRect16ARMNEONAsm(int32_t w, int32_t h, uint16_t *dst, int32_t dst_stride, uint16_t src); void FillSurfaceRect16ARMNEONAsm(int32_t w, int32_t h, uint16_t *dst, int32_t dst_stride, uint16_t src);
void FillRect32ARMNEONAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint32_t src); void FillSurfaceRect32ARMNEONAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint32_t src);
static void fill_8_neon(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void fill_8_neon(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
FillRect8ARMNEONAsm(w, h, (uint8_t *)pixels, pitch >> 0, color); FillSurfaceRect8ARMNEONAsm(w, h, (uint8_t *)pixels, pitch >> 0, color);
return; return;
} }
static void fill_16_neon(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void fill_16_neon(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
FillRect16ARMNEONAsm(w, h, (uint16_t *)pixels, pitch >> 1, color); FillSurfaceRect16ARMNEONAsm(w, h, (uint16_t *)pixels, pitch >> 1, color);
return; return;
} }
static void fill_32_neon(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void fill_32_neon(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
FillRect32ARMNEONAsm(w, h, (uint32_t *)pixels, pitch >> 2, color); FillSurfaceRect32ARMNEONAsm(w, h, (uint32_t *)pixels, pitch >> 2, color);
return; return;
} }
#endif #endif
#if SDL_ARM_SIMD_BLITTERS #if SDL_ARM_SIMD_BLITTERS
void FillRect8ARMSIMDAsm(int32_t w, int32_t h, uint8_t *dst, int32_t dst_stride, uint8_t src); void FillSurfaceRect8ARMSIMDAsm(int32_t w, int32_t h, uint8_t *dst, int32_t dst_stride, uint8_t src);
void FillRect16ARMSIMDAsm(int32_t w, int32_t h, uint16_t *dst, int32_t dst_stride, uint16_t src); void FillSurfaceRect16ARMSIMDAsm(int32_t w, int32_t h, uint16_t *dst, int32_t dst_stride, uint16_t src);
void FillRect32ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint32_t src); void FillSurfaceRect32ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint32_t src);
static void fill_8_simd(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void fill_8_simd(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
FillRect8ARMSIMDAsm(w, h, (uint8_t *)pixels, pitch >> 0, color); FillSurfaceRect8ARMSIMDAsm(w, h, (uint8_t *)pixels, pitch >> 0, color);
return; return;
} }
static void fill_16_simd(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void fill_16_simd(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
FillRect16ARMSIMDAsm(w, h, (uint16_t *)pixels, pitch >> 1, color); FillSurfaceRect16ARMSIMDAsm(w, h, (uint16_t *)pixels, pitch >> 1, color);
return; return;
} }
static void fill_32_simd(Uint8 *pixels, int pitch, Uint32 color, int w, int h) static void fill_32_simd(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
{ {
FillRect32ARMSIMDAsm(w, h, (uint32_t *)pixels, pitch >> 2, color); FillSurfaceRect32ARMSIMDAsm(w, h, (uint32_t *)pixels, pitch >> 2, color);
return; return;
} }
#endif #endif
int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count, int SDL_FillSurfaceRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
Uint32 color) Uint32 color)
{ {
SDL_Rect clipped; SDL_Rect clipped;
@ -306,7 +306,7 @@ int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
int i; int i;
if (dst == NULL) { if (dst == NULL) {
return SDL_InvalidParamError("SDL_FillRects(): dst"); return SDL_InvalidParamError("SDL_FillSurfaceRects(): dst");
} }
/* Nothing to do */ /* Nothing to do */
@ -316,11 +316,11 @@ int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
/* Perform software fill */ /* Perform software fill */
if (!dst->pixels) { if (!dst->pixels) {
return SDL_SetError("SDL_FillRects(): You must lock the surface"); return SDL_SetError("SDL_FillSurfaceRects(): You must lock the surface");
} }
if (rects == NULL) { if (rects == NULL) {
return SDL_InvalidParamError("SDL_FillRects(): rects"); return SDL_InvalidParamError("SDL_FillSurfaceRects(): rects");
} }
/* This function doesn't usually work on surfaces < 8 bpp /* This function doesn't usually work on surfaces < 8 bpp
@ -337,7 +337,7 @@ int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
} }
} }
} }
return SDL_SetError("SDL_FillRects(): Unsupported surface format"); return SDL_SetError("SDL_FillSurfaceRects(): Unsupported surface format");
} }
#if SDL_ARM_NEON_BLITTERS #if SDL_ARM_NEON_BLITTERS
@ -379,11 +379,11 @@ int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
color |= (color << 16); color |= (color << 16);
#ifdef __SSE__ #ifdef __SSE__
if (SDL_HasSSE()) { if (SDL_HasSSE()) {
fill_function = SDL_FillRect1SSE; fill_function = SDL_FillSurfaceRect1SSE;
break; break;
} }
#endif #endif
fill_function = SDL_FillRect1; fill_function = SDL_FillSurfaceRect1;
break; break;
} }
@ -392,18 +392,18 @@ int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
color |= (color << 16); color |= (color << 16);
#ifdef __SSE__ #ifdef __SSE__
if (SDL_HasSSE()) { if (SDL_HasSSE()) {
fill_function = SDL_FillRect2SSE; fill_function = SDL_FillSurfaceRect2SSE;
break; break;
} }
#endif #endif
fill_function = SDL_FillRect2; fill_function = SDL_FillSurfaceRect2;
break; break;
} }
case 3: case 3:
/* 24-bit RGB is a slow path, at least for now. */ /* 24-bit RGB is a slow path, at least for now. */
{ {
fill_function = SDL_FillRect3; fill_function = SDL_FillSurfaceRect3;
break; break;
} }
@ -411,11 +411,11 @@ int SDL_FillRects(SDL_Surface *dst, const SDL_Rect *rects, int count,
{ {
#ifdef __SSE__ #ifdef __SSE__
if (SDL_HasSSE()) { if (SDL_HasSSE()) {
fill_function = SDL_FillRect4SSE; fill_function = SDL_FillSurfaceRect4SSE;
break; break;
} }
#endif #endif
fill_function = SDL_FillRect4; fill_function = SDL_FillSurfaceRect4;
break; break;
} }

82
src/video/SDL_surface.c
View File

@ -116,19 +116,19 @@ SDL_CreateSurface(int width, int height, Uint32 format)
surface->format = SDL_CreatePixelFormat(format); surface->format = SDL_CreatePixelFormat(format);
if (!surface->format) { if (!surface->format) {
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
return NULL; return NULL;
} }
surface->w = width; surface->w = width;
surface->h = height; surface->h = height;
surface->pitch = (int)pitch; surface->pitch = (int)pitch;
SDL_SetClipRect(surface, NULL); SDL_SetSurfaceClipRect(surface, NULL);
if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) { if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
SDL_Palette *palette = SDL_Palette *palette =
SDL_CreatePalette((1 << surface->format->BitsPerPixel)); SDL_CreatePalette((1 << surface->format->BitsPerPixel));
if (palette == NULL) { if (palette == NULL) {
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
return NULL; return NULL;
} }
if (palette->ncolors == 2) { if (palette->ncolors == 2) {
@ -151,7 +151,7 @@ SDL_CreateSurface(int width, int height, Uint32 format)
/* Get correct size and pitch for YUV formats */ /* Get correct size and pitch for YUV formats */
if (SDL_CalculateYUVSize(surface->format->format, surface->w, surface->h, &size, &surface->pitch) < 0) { if (SDL_CalculateYUVSize(surface->format->format, surface->w, surface->h, &size, &surface->pitch) < 0) {
/* Overflow... */ /* Overflow... */
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
SDL_OutOfMemory(); SDL_OutOfMemory();
return NULL; return NULL;
} }
@ -159,7 +159,7 @@ SDL_CreateSurface(int width, int height, Uint32 format)
/* Assumptions checked in surface_size_assumptions assert above */ /* Assumptions checked in surface_size_assumptions assert above */
if (SDL_size_mul_overflow(surface->h, surface->pitch, &size)) { if (SDL_size_mul_overflow(surface->h, surface->pitch, &size)) {
/* Overflow... */ /* Overflow... */
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
SDL_OutOfMemory(); SDL_OutOfMemory();
return NULL; return NULL;
} }
@ -167,7 +167,7 @@ SDL_CreateSurface(int width, int height, Uint32 format)
surface->pixels = SDL_SIMDAlloc(size); surface->pixels = SDL_SIMDAlloc(size);
if (!surface->pixels) { if (!surface->pixels) {
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
SDL_OutOfMemory(); SDL_OutOfMemory();
return NULL; return NULL;
} }
@ -179,7 +179,7 @@ SDL_CreateSurface(int width, int height, Uint32 format)
/* Allocate an empty mapping */ /* Allocate an empty mapping */
surface->map = SDL_AllocBlitMap(); surface->map = SDL_AllocBlitMap();
if (!surface->map) { if (!surface->map) {
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
return NULL; return NULL;
} }
@ -238,7 +238,7 @@ SDL_CreateSurfaceFrom(void *pixels,
surface->w = width; surface->w = width;
surface->h = height; surface->h = height;
surface->pitch = pitch; surface->pitch = pitch;
SDL_SetClipRect(surface, NULL); SDL_SetSurfaceClipRect(surface, NULL);
} }
return surface; return surface;
} }
@ -277,7 +277,7 @@ int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag)
} }
SDL_bool SDL_bool
SDL_HasSurfaceRLE(SDL_Surface *surface) SDL_SurfaceHasRLE(SDL_Surface *surface)
{ {
if (surface == NULL) { if (surface == NULL) {
return SDL_FALSE; return SDL_FALSE;
@ -290,7 +290,7 @@ SDL_HasSurfaceRLE(SDL_Surface *surface)
return SDL_TRUE; return SDL_TRUE;
} }
int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key) int SDL_SetSurfaceColorKey(SDL_Surface *surface, int flag, Uint32 key)
{ {
int flags; int flags;
@ -321,7 +321,7 @@ int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key)
} }
SDL_bool SDL_bool
SDL_HasColorKey(SDL_Surface *surface) SDL_SurfaceHasColorKey(SDL_Surface *surface)
{ {
if (surface == NULL) { if (surface == NULL) {
return SDL_FALSE; return SDL_FALSE;
@ -334,7 +334,7 @@ SDL_HasColorKey(SDL_Surface *surface)
return SDL_TRUE; return SDL_TRUE;
} }
int SDL_GetColorKey(SDL_Surface *surface, Uint32 *key) int SDL_GetSurfaceColorKey(SDL_Surface *surface, Uint32 *key)
{ {
if (surface == NULL) { if (surface == NULL) {
return SDL_InvalidParamError("surface"); return SDL_InvalidParamError("surface");
@ -437,7 +437,7 @@ static void SDL_ConvertColorkeyToAlpha(SDL_Surface *surface, SDL_bool ignore_alp
SDL_UnlockSurface(surface); SDL_UnlockSurface(surface);
SDL_SetColorKey(surface, 0, 0); SDL_SetSurfaceColorKey(surface, 0, 0);
SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND); SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
} }
@ -587,7 +587,7 @@ int SDL_GetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode *blendMode)
} }
SDL_bool SDL_bool
SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect) SDL_SetSurfaceClipRect(SDL_Surface *surface, const SDL_Rect *rect)
{ {
SDL_Rect full_rect; SDL_Rect full_rect;
@ -610,7 +610,7 @@ SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect); return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
} }
void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect) void SDL_GetSurfaceClipRect(SDL_Surface *surface, SDL_Rect *rect)
{ {
if (surface && rect) { if (surface && rect) {
*rect = surface->clip_rect; *rect = surface->clip_rect;
@ -619,7 +619,7 @@ void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect)
/* /*
* Set up a blit between two surfaces -- split into three parts: * Set up a blit between two surfaces -- split into three parts:
* The upper part, SDL_UpperBlit(), performs clipping and rectangle * The upper part, SDL_BlitSurface(), performs clipping and rectangle
* verification. The lower part is a pointer to a low level * verification. The lower part is a pointer to a low level
* accelerated blitting function. * accelerated blitting function.
* *
@ -628,7 +628,7 @@ void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect)
* you know exactly what you are doing, you can optimize your code * you know exactly what you are doing, you can optimize your code
* by calling the one(s) you need. * by calling the one(s) you need.
*/ */
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, int SDL_BlitSurfaceUnchecked(SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect) SDL_Surface *dst, SDL_Rect *dstrect)
{ {
/* Check to make sure the blit mapping is valid */ /* Check to make sure the blit mapping is valid */
@ -649,7 +649,7 @@ int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect,
return src->map->blit(src, srcrect, dst, dstrect); return src->map->blit(src, srcrect, dst, dstrect);
} }
int SDL_UpperBlit(SDL_Surface *src, const SDL_Rect *srcrect, int SDL_BlitSurface(SDL_Surface *src, const SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect) SDL_Surface *dst, SDL_Rect *dstrect)
{ {
SDL_Rect fulldst; SDL_Rect fulldst;
@ -657,7 +657,7 @@ int SDL_UpperBlit(SDL_Surface *src, const SDL_Rect *srcrect,
/* Make sure the surfaces aren't locked */ /* Make sure the surfaces aren't locked */
if (src == NULL || dst == NULL) { if (src == NULL || dst == NULL) {
return SDL_InvalidParamError("SDL_UpperBlit(): src/dst"); return SDL_InvalidParamError("SDL_BlitSurface(): src/dst");
} }
if (src->locked || dst->locked) { if (src->locked || dst->locked) {
return SDL_SetError("Surfaces must not be locked during blit"); return SDL_SetError("Surfaces must not be locked during blit");
@ -745,13 +745,13 @@ int SDL_UpperBlit(SDL_Surface *src, const SDL_Rect *srcrect,
sr.y = srcy; sr.y = srcy;
sr.w = dstrect->w = w; sr.w = dstrect->w = w;
sr.h = dstrect->h = h; sr.h = dstrect->h = h;
return SDL_LowerBlit(src, &sr, dst, dstrect); return SDL_BlitSurfaceUnchecked(src, &sr, dst, dstrect);
} }
dstrect->w = dstrect->h = 0; dstrect->w = dstrect->h = 0;
return 0; return 0;
} }
int SDL_UpperBlitScaled(SDL_Surface *src, const SDL_Rect *srcrect, int SDL_BlitSurfaceScaled(SDL_Surface *src, const SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect) SDL_Surface *dst, SDL_Rect *dstrect)
{ {
return SDL_PrivateUpperBlitScaled(src, srcrect, dst, dstrect, SDL_ScaleModeNearest); return SDL_PrivateUpperBlitScaled(src, srcrect, dst, dstrect, SDL_ScaleModeNearest);
@ -769,7 +769,7 @@ int SDL_PrivateUpperBlitScaled(SDL_Surface *src, const SDL_Rect *srcrect,
/* Make sure the surfaces aren't locked */ /* Make sure the surfaces aren't locked */
if (src == NULL || dst == NULL) { if (src == NULL || dst == NULL) {
return SDL_InvalidParamError("SDL_UpperBlitScaled(): src/dst"); return SDL_InvalidParamError("SDL_BlitSurfaceScaled(): src/dst");
} }
if (src->locked || dst->locked) { if (src->locked || dst->locked) {
return SDL_SetError("Surfaces must not be locked during blit"); return SDL_SetError("Surfaces must not be locked during blit");
@ -919,7 +919,7 @@ int SDL_PrivateUpperBlitScaled(SDL_Surface *src, const SDL_Rect *srcrect,
* This is a semi-private blit function and it performs low-level surface * This is a semi-private blit function and it performs low-level surface
* scaled blitting only. * scaled blitting only.
*/ */
int SDL_LowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect, int SDL_BlitSurfaceUncheckedScaled(SDL_Surface *src, SDL_Rect *srcrect,
SDL_Surface *dst, SDL_Rect *dstrect) SDL_Surface *dst, SDL_Rect *dstrect)
{ {
return SDL_PrivateLowerBlitScaled(src, srcrect, dst, dstrect, SDL_ScaleModeNearest); return SDL_PrivateLowerBlitScaled(src, srcrect, dst, dstrect, SDL_ScaleModeNearest);
@ -948,7 +948,7 @@ int SDL_PrivateLowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect,
!SDL_ISPIXELFORMAT_INDEXED(src->format->format)) { !SDL_ISPIXELFORMAT_INDEXED(src->format->format)) {
return SDL_SoftStretch(src, srcrect, dst, dstrect); return SDL_SoftStretch(src, srcrect, dst, dstrect);
} else { } else {
return SDL_LowerBlit(src, srcrect, dst, dstrect); return SDL_BlitSurfaceUnchecked(src, srcrect, dst, dstrect);
} }
} else { } else {
if (!(src->map->info.flags & complex_copy_flags) && if (!(src->map->info.flags & complex_copy_flags) &&
@ -992,7 +992,7 @@ int SDL_PrivateLowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect,
fmt = SDL_PIXELFORMAT_ARGB8888; fmt = SDL_PIXELFORMAT_ARGB8888;
} }
tmp1 = SDL_CreateSurface(src->w, src->h, fmt); tmp1 = SDL_CreateSurface(src->w, src->h, fmt);
SDL_LowerBlit(src, srcrect, tmp1, &tmprect); SDL_BlitSurfaceUnchecked(src, srcrect, tmp1, &tmprect);
srcrect2.x = 0; srcrect2.x = 0;
srcrect2.y = 0; srcrect2.y = 0;
@ -1017,13 +1017,13 @@ int SDL_PrivateLowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect,
tmprect.y = 0; tmprect.y = 0;
tmprect.w = dstrect->w; tmprect.w = dstrect->w;
tmprect.h = dstrect->h; tmprect.h = dstrect->h;
ret = SDL_LowerBlit(tmp2, &tmprect, dst, dstrect); ret = SDL_BlitSurfaceUnchecked(tmp2, &tmprect, dst, dstrect);
SDL_FreeSurface(tmp2); SDL_DestroySurface(tmp2);
} else { } else {
ret = SDL_SoftStretchLinear(src, &srcrect2, dst, dstrect); ret = SDL_SoftStretchLinear(src, &srcrect2, dst, dstrect);
} }
SDL_FreeSurface(tmp1); SDL_DestroySurface(tmp1);
return ret; return ret;
} }
} }
@ -1132,7 +1132,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
convert->format->format, convert->pixels, convert->pitch); convert->format->format, convert->pixels, convert->pitch);
if (ret < 0) { if (ret < 0) {
SDL_FreeSurface(convert); SDL_DestroySurface(convert);
return NULL; return NULL;
} }
@ -1208,7 +1208,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
} }
} }
ret = SDL_LowerBlit(surface, &bounds, convert, &bounds); ret = SDL_BlitSurfaceUnchecked(surface, &bounds, convert, &bounds);
/* Restore colorkey alpha value */ /* Restore colorkey alpha value */
if (palette_ck_transform) { if (palette_ck_transform) {
@ -1240,9 +1240,9 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
surface->map->info.flags = copy_flags; surface->map->info.flags = copy_flags;
SDL_InvalidateMap(surface->map); SDL_InvalidateMap(surface->map);
/* SDL_LowerBlit failed, and so the conversion */ /* SDL_BlitSurfaceUnchecked failed, and so the conversion */
if (ret < 0) { if (ret < 0) {
SDL_FreeSurface(convert); SDL_DestroySurface(convert);
return NULL; return NULL;
} }
@ -1256,7 +1256,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
(SDL_memcmp(surface->format->palette->colors, format->palette->colors, (SDL_memcmp(surface->format->palette->colors, format->palette->colors,
surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) { surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) {
/* The palette is identical, just set the same colorkey */ /* The palette is identical, just set the same colorkey */
SDL_SetColorKey(convert, 1, surface->map->info.colorkey); SDL_SetSurfaceColorKey(convert, 1, surface->map->info.colorkey);
} else if (!format->palette) { } else if (!format->palette) {
if (format->Amask) { if (format->Amask) {
/* No need to add the colorkey, transparency is in the alpha channel*/ /* No need to add the colorkey, transparency is in the alpha channel*/
@ -1285,7 +1285,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
SDL_SetSurfacePalette(tmp, surface->format->palette); SDL_SetSurfacePalette(tmp, surface->format->palette);
} }
SDL_FillRect(tmp, NULL, surface->map->info.colorkey); SDL_FillSurfaceRect(tmp, NULL, surface->map->info.colorkey);
tmp->map->info.flags &= ~SDL_COPY_COLORKEY; tmp->map->info.flags &= ~SDL_COPY_COLORKEY;
@ -1295,11 +1295,11 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
/* Get the converted colorkey */ /* Get the converted colorkey */
SDL_memcpy(&converted_colorkey, tmp2->pixels, tmp2->format->BytesPerPixel); SDL_memcpy(&converted_colorkey, tmp2->pixels, tmp2->format->BytesPerPixel);
SDL_FreeSurface(tmp); SDL_DestroySurface(tmp);
SDL_FreeSurface(tmp2); SDL_DestroySurface(tmp2);
/* Set the converted colorkey on the new surface */ /* Set the converted colorkey on the new surface */
SDL_SetColorKey(convert, 1, converted_colorkey); SDL_SetSurfaceColorKey(convert, 1, converted_colorkey);
/* This is needed when converting for 3D texture upload */ /* This is needed when converting for 3D texture upload */
if (convert_colorkey) { if (convert_colorkey) {
@ -1310,7 +1310,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
end: end:
SDL_SetClipRect(convert, &surface->clip_rect); SDL_SetSurfaceClipRect(convert, &surface->clip_rect);
/* Enable alpha blending by default if the new surface has an /* Enable alpha blending by default if the new surface has an
* alpha channel or alpha modulation */ * alpha channel or alpha modulation */
@ -1364,7 +1364,7 @@ static SDL_INLINE SDL_bool SDL_CreateSurfaceOnStack(int width, int height, Uint3
surface->h = height; surface->h = height;
surface->pitch = pitch; surface->pitch = pitch;
/* We don't actually need to set up the clip rect for our purposes */ /* We don't actually need to set up the clip rect for our purposes */
/* SDL_SetClipRect(surface, NULL); */ /* SDL_SetSurfaceClipRect(surface, NULL); */
/* Allocate an empty mapping */ /* Allocate an empty mapping */
SDL_zerop(blitmap); SDL_zerop(blitmap);
@ -1448,7 +1448,7 @@ int SDL_ConvertPixels(int width, int height,
rect.y = 0; rect.y = 0;
rect.w = width; rect.w = width;
rect.h = height; rect.h = height;
ret = SDL_LowerBlit(&src_surface, &rect, &dst_surface, &rect); ret = SDL_BlitSurfaceUnchecked(&src_surface, &rect, &dst_surface, &rect);
/* Free blitmap reference, after blitting between stack'ed surfaces */ /* Free blitmap reference, after blitting between stack'ed surfaces */
SDL_InvalidateMap(src_surface.map); SDL_InvalidateMap(src_surface.map);
@ -1521,7 +1521,7 @@ int SDL_PremultiplyAlpha(int width, int height,
/* /*
* Free a surface created by the above function. * Free a surface created by the above function.
*/ */
void SDL_FreeSurface(SDL_Surface *surface) void SDL_DestroySurface(SDL_Surface *surface)
{ {
if (surface == NULL) { if (surface == NULL) {
return; return;

10
src/video/SDL_video.c
View File

@ -1872,7 +1872,7 @@ int SDL_RecreateWindow(SDL_Window *window, Uint32 flags)
/* Tear down the old native window */ /* Tear down the old native window */
if (window->surface) { if (window->surface) {
window->surface->flags &= ~SDL_DONTFREE; window->surface->flags &= ~SDL_DONTFREE;
SDL_FreeSurface(window->surface); SDL_DestroySurface(window->surface);
window->surface = NULL; window->surface = NULL;
window->surface_valid = SDL_FALSE; window->surface_valid = SDL_FALSE;
} }
@ -2041,7 +2041,7 @@ void SDL_SetWindowIcon(SDL_Window *window, SDL_Surface *icon)
return; return;
} }
SDL_FreeSurface(window->icon); SDL_DestroySurface(window->icon);
/* Convert the icon into ARGB8888 */ /* Convert the icon into ARGB8888 */
window->icon = SDL_ConvertSurfaceFormat(icon, SDL_PIXELFORMAT_ARGB8888); window->icon = SDL_ConvertSurfaceFormat(icon, SDL_PIXELFORMAT_ARGB8888);
@ -2666,7 +2666,7 @@ SDL_GetWindowSurface(SDL_Window *window)
if (!window->surface_valid) { if (!window->surface_valid) {
if (window->surface) { if (window->surface) {
window->surface->flags &= ~SDL_DONTFREE; window->surface->flags &= ~SDL_DONTFREE;
SDL_FreeSurface(window->surface); SDL_DestroySurface(window->surface);
window->surface = NULL; window->surface = NULL;
} }
window->surface = SDL_CreateWindowFramebuffer(window); window->surface = SDL_CreateWindowFramebuffer(window);
@ -3088,7 +3088,7 @@ void SDL_DestroyWindow(SDL_Window *window)
if (window->surface) { if (window->surface) {
window->surface->flags &= ~SDL_DONTFREE; window->surface->flags &= ~SDL_DONTFREE;
SDL_FreeSurface(window->surface); SDL_DestroySurface(window->surface);
window->surface = NULL; window->surface = NULL;
window->surface_valid = SDL_FALSE; window->surface_valid = SDL_FALSE;
} }
@ -3126,7 +3126,7 @@ void SDL_DestroyWindow(SDL_Window *window)
/* Free memory associated with the window */ /* Free memory associated with the window */
SDL_free(window->title); SDL_free(window->title);
SDL_FreeSurface(window->icon); SDL_DestroySurface(window->icon);
while (window->data) { while (window->data) {
SDL_WindowUserData *data = window->data; SDL_WindowUserData *data = window->data;

4
src/video/android/SDL_androidmouse.c
View File

@ -92,7 +92,7 @@ static SDL_Cursor *Android_CreateCursor(SDL_Surface *surface, int hot_x, int hot
return NULL; return NULL;
} }
custom_cursor = Android_JNI_CreateCustomCursor(converted, hot_x, hot_y); custom_cursor = Android_JNI_CreateCustomCursor(converted, hot_x, hot_y);
SDL_FreeSurface(converted); SDL_DestroySurface(converted);
if (!custom_cursor) { if (!custom_cursor) {
SDL_Unsupported(); SDL_Unsupported();
return NULL; return NULL;
@ -122,7 +122,7 @@ static SDL_Cursor *Android_CreateEmptyCursor()
if (empty_surface) { if (empty_surface) {
SDL_memset(empty_surface->pixels, 0, (size_t)empty_surface->h * empty_surface->pitch); SDL_memset(empty_surface->pixels, 0, (size_t)empty_surface->h * empty_surface->pitch);
empty_cursor = Android_CreateCursor(empty_surface, 0, 0); empty_cursor = Android_CreateCursor(empty_surface, 0, 0);
SDL_FreeSurface(empty_surface); SDL_DestroySurface(empty_surface);
} }
} }
return empty_cursor; return empty_cursor;

4
src/video/cocoa/SDL_cocoavideo.m
View File

@ -251,14 +251,14 @@ Cocoa_CreateImage(SDL_Surface *surface)
bytesPerRow:converted->pitch bytesPerRow:converted->pitch
bitsPerPixel:converted->format->BitsPerPixel]; bitsPerPixel:converted->format->BitsPerPixel];
if (imgrep == nil) { if (imgrep == nil) {
SDL_FreeSurface(converted); SDL_DestroySurface(converted);
return nil; return nil;
} }
/* Copy the pixels */ /* Copy the pixels */
pixels = [imgrep bitmapData]; pixels = [imgrep bitmapData];
SDL_memcpy(pixels, converted->pixels, converted->h * converted->pitch); SDL_memcpy(pixels, converted->pixels, converted->h * converted->pitch);
SDL_FreeSurface(converted); SDL_DestroySurface(converted);
/* Premultiply the alpha channel */ /* Premultiply the alpha channel */
for (i = (surface->h * surface->w); i--;) { for (i = (surface->h * surface->w); i--;) {

2
src/video/dummy/SDL_nullframebuffer.c
View File

@ -76,7 +76,7 @@ void SDL_DUMMY_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
SDL_Surface *surface; SDL_Surface *surface;
surface = (SDL_Surface *)SDL_SetWindowData(window, DUMMY_SURFACE, NULL); surface = (SDL_Surface *)SDL_SetWindowData(window, DUMMY_SURFACE, NULL);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
#endif /* SDL_VIDEO_DRIVER_DUMMY */ #endif /* SDL_VIDEO_DRIVER_DUMMY */

4
src/video/emscripten/SDL_emscriptenframebuffer.c
View File

@ -36,7 +36,7 @@ int Emscripten_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format
/* Free the old framebuffer surface */ /* Free the old framebuffer surface */
SDL_WindowData *data = (SDL_WindowData *)window->driverdata; SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
surface = data->surface; surface = data->surface;
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
/* Create a new one */ /* Create a new one */
SDL_GetWindowSize(window, &w, &h); SDL_GetWindowSize(window, &w, &h);
@ -154,7 +154,7 @@ void Emscripten_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
{ {
SDL_WindowData *data = (SDL_WindowData *)window->driverdata; SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
SDL_FreeSurface(data->surface); SDL_DestroySurface(data->surface);
data->surface = NULL; data->surface = NULL;
} }

2
src/video/emscripten/SDL_emscriptenmouse.c
View File

@ -104,7 +104,7 @@ static SDL_Cursor *Emscripten_CreateCursor(SDL_Surface *surface, int hot_x, int
}, surface->w, surface->h, hot_x, hot_y, conv_surf->pixels); }, surface->w, surface->h, hot_x, hot_y, conv_surf->pixels);
/* *INDENT-ON* */ /* clang-format on */ /* *INDENT-ON* */ /* clang-format on */
SDL_FreeSurface(conv_surf); SDL_DestroySurface(conv_surf);
return Emscripten_CreateCursorFromString(cursor_url, SDL_TRUE); return Emscripten_CreateCursorFromString(cursor_url, SDL_TRUE);
} }

2
src/video/haiku/SDL_bvideo.cc
View File

@ -197,7 +197,7 @@ static SDL_Cursor * HAIKU_CreateCursor(SDL_Surface * surface, int hot_x, int hot
BBitmap *cursorBitmap = new BBitmap(BRect(0, 0, surface->w - 1, surface->h - 1), B_RGBA32); BBitmap *cursorBitmap = new BBitmap(BRect(0, 0, surface->w - 1, surface->h - 1), B_RGBA32);
cursorBitmap->SetBits(converted->pixels, converted->h * converted->pitch, 0, B_RGBA32); cursorBitmap->SetBits(converted->pixels, converted->h * converted->pitch, 0, B_RGBA32);
SDL_FreeSurface(converted); SDL_DestroySurface(converted);
cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor)); cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
if (cursor) { if (cursor) {

4
src/video/n3ds/SDL_n3dsframebuffer.c
View File

@ -62,7 +62,7 @@ SDL_FORCE_INLINE void
FreePreviousWindowFramebuffer(SDL_Window *window) FreePreviousWindowFramebuffer(SDL_Window *window)
{ {
SDL_Surface *surface = (SDL_Surface *)SDL_GetWindowData(window, N3DS_SURFACE); SDL_Surface *surface = (SDL_Surface *)SDL_GetWindowData(window, N3DS_SURFACE);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
SDL_FORCE_INLINE SDL_Surface * SDL_FORCE_INLINE SDL_Surface *
@ -135,7 +135,7 @@ void SDL_N3DS_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
{ {
SDL_Surface *surface; SDL_Surface *surface;
surface = (SDL_Surface *)SDL_SetWindowData(window, N3DS_SURFACE, NULL); surface = (SDL_Surface *)SDL_SetWindowData(window, N3DS_SURFACE, NULL);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
#endif /* SDL_VIDEO_DRIVER_N3DS */ #endif /* SDL_VIDEO_DRIVER_N3DS */

2
src/video/ngage/SDL_ngageframebuffer.cpp
View File

@ -171,7 +171,7 @@ void SDL_NGAGE_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
SDL_Surface *surface; SDL_Surface *surface;
surface = (SDL_Surface *)SDL_SetWindowData(window, NGAGE_SURFACE, NULL); surface = (SDL_Surface *)SDL_SetWindowData(window, NGAGE_SURFACE, NULL);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
/*****************************************************************************/ /*****************************************************************************/

2
src/video/offscreen/SDL_offscreenframebuffer.c
View File

@ -76,7 +76,7 @@ void SDL_OFFSCREEN_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
SDL_Surface *surface; SDL_Surface *surface;
surface = (SDL_Surface *)SDL_SetWindowData(window, OFFSCREEN_SURFACE, NULL); surface = (SDL_Surface *)SDL_SetWindowData(window, OFFSCREEN_SURFACE, NULL);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
#endif /* SDL_VIDEO_DRIVER_OFFSCREEN */ #endif /* SDL_VIDEO_DRIVER_OFFSCREEN */

2
src/video/windows/SDL_windowsmouse.c
View File

@ -173,7 +173,7 @@ static SDL_Cursor *WIN_CreateBlankCursor()
SDL_Surface *surface = SDL_CreateSurface(32, 32, SDL_PIXELFORMAT_ARGB8888); SDL_Surface *surface = SDL_CreateSurface(32, 32, SDL_PIXELFORMAT_ARGB8888);
if (surface) { if (surface) {
cursor = WIN_CreateCursor(surface, 0, 0); cursor = WIN_CreateCursor(surface, 0, 0);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
return cursor; return cursor;
} }

4
test/testautomation_mouse.c
View File

@ -232,7 +232,7 @@ int mouse_createFreeColorCursor(void *arg)
SDLTest_AssertPass("Call to SDL_CreateColorCursor()"); SDLTest_AssertPass("Call to SDL_CreateColorCursor()");
SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateColorCursor() is not NULL"); SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateColorCursor() is not NULL");
if (cursor == NULL) { if (cursor == NULL) {
SDL_FreeSurface(face); SDL_DestroySurface(face);
return TEST_ABORTED; return TEST_ABORTED;
} }
@ -241,7 +241,7 @@ int mouse_createFreeColorCursor(void *arg)
SDLTest_AssertPass("Call to SDL_FreeCursor()"); SDLTest_AssertPass("Call to SDL_FreeCursor()");
/* Clean up */ /* Clean up */
SDL_FreeSurface(face); SDL_DestroySurface(face);
return TEST_COMPLETED; return TEST_COMPLETED;
} }

26
test/testautomation_render.c
View File

@ -191,7 +191,7 @@ int render_testPrimitives(void *arg)
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -355,7 +355,7 @@ int render_testPrimitivesBlend(void *arg)
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -424,7 +424,7 @@ int render_testBlit(void *arg)
/* Clean up. */ /* Clean up. */
SDL_DestroyTexture(tface); SDL_DestroyTexture(tface);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -500,7 +500,7 @@ int render_testBlitColor(void *arg)
/* Clean up. */ /* Clean up. */
SDL_DestroyTexture(tface); SDL_DestroyTexture(tface);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -579,7 +579,7 @@ int render_testBlitAlpha(void *arg)
/* Clean up. */ /* Clean up. */
SDL_DestroyTexture(tface); SDL_DestroyTexture(tface);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -695,7 +695,7 @@ int render_testBlitBlend(void *arg)
_compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE); _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
/* Test Blend. */ /* Test Blend. */
@ -706,7 +706,7 @@ int render_testBlitBlend(void *arg)
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED); _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
/* Test Add. */ /* Test Add. */
@ -717,7 +717,7 @@ int render_testBlitBlend(void *arg)
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED); _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
/* Test Mod. */ /* Test Mod. */
@ -728,7 +728,7 @@ int render_testBlitBlend(void *arg)
_compare(referenceSurface, ALLOWABLE_ERROR_BLENDED); _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
/* Clear surface. */ /* Clear surface. */
@ -794,7 +794,7 @@ int render_testBlitBlend(void *arg)
/* Make current */ /* Make current */
SDL_RenderPresent(renderer); SDL_RenderPresent(renderer);
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -941,7 +941,7 @@ _loadTestFace(void)
SDLTest_LogError("SDL_CreateTextureFromSurface() failed with error: %s", SDL_GetError()); SDLTest_LogError("SDL_CreateTextureFromSurface() failed with error: %s", SDL_GetError());
} }
SDL_FreeSurface(face); SDL_DestroySurface(face);
return tface; return tface;
} }
@ -1042,7 +1042,7 @@ _hasTexAlpha(void)
* \sa * \sa
* http://wiki.libsdl.org/SDL_RenderReadPixels * http://wiki.libsdl.org/SDL_RenderReadPixels
* http://wiki.libsdl.org/SDL_CreateSurfaceFrom * http://wiki.libsdl.org/SDL_CreateSurfaceFrom
* http://wiki.libsdl.org/SDL_FreeSurface * http://wiki.libsdl.org/SDL_DestroySurface
*/ */
static void static void
_compare(SDL_Surface *referenceSurface, int allowable_error) _compare(SDL_Surface *referenceSurface, int allowable_error)
@ -1077,7 +1077,7 @@ _compare(SDL_Surface *referenceSurface, int allowable_error)
/* Clean up. */ /* Clean up. */
SDL_free(pixels); SDL_free(pixels);
SDL_FreeSurface(testSurface); SDL_DestroySurface(testSurface);
} }
/** /**

86
test/testautomation_surface.c
View File

@ -56,9 +56,9 @@ void _surfaceSetUp(void *arg)
void _surfaceTearDown(void *arg) void _surfaceTearDown(void *arg)
{ {
SDL_FreeSurface(referenceSurface); SDL_DestroySurface(referenceSurface);
referenceSurface = NULL; referenceSurface = NULL;
SDL_FreeSurface(testSurface); SDL_DestroySurface(testSurface);
testSurface = NULL; testSurface = NULL;
} }
@ -73,9 +73,9 @@ void _clearTestSurface()
/* Clear surface. */ /* Clear surface. */
color = SDL_MapRGBA(testSurface->format, 0, 0, 0, 0); color = SDL_MapRGBA(testSurface->format, 0, 0, 0, 0);
SDLTest_AssertPass("Call to SDL_MapRGBA()"); SDLTest_AssertPass("Call to SDL_MapRGBA()");
ret = SDL_FillRect(testSurface, NULL, color); ret = SDL_FillSurfaceRect(testSurface, NULL, color);
SDLTest_AssertPass("Call to SDL_FillRect()"); SDLTest_AssertPass("Call to SDL_FillSurfaceRect()");
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_FillRect, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Verify result from SDL_FillSurfaceRect, expected: 0, got: %i", ret);
} }
/** /**
@ -118,9 +118,9 @@ void _testBlitBlendMode(int mode)
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorMod(), expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorMod(), expected: 0, got: %i", ret);
/* Reset color key */ /* Reset color key */
ret = SDL_SetColorKey(face, SDL_FALSE, 0); ret = SDL_SetSurfaceColorKey(face, SDL_FALSE, 0);
SDLTest_AssertPass("Call to SDL_SetColorKey()"); SDLTest_AssertPass("Call to SDL_SetSurfaceColorKey()");
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey(), expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorKey(), expected: 0, got: %i", ret);
/* Clear the test surface */ /* Clear the test surface */
_clearTestSurface(); _clearTestSurface();
@ -196,7 +196,7 @@ void _testBlitBlendMode(int mode)
SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_SetSurfaceBlendMode, expected: 0, got: %i", checkFailCount4); SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_SetSurfaceBlendMode, expected: 0, got: %i", checkFailCount4);
/* Clean up */ /* Clean up */
SDL_FreeSurface(face); SDL_DestroySurface(face);
face = NULL; face = NULL;
} }
@ -250,9 +250,9 @@ int surface_testSaveLoadBitmap(void *arg)
unlink(sampleFilename); unlink(sampleFilename);
/* Clean up */ /* Clean up */
SDL_FreeSurface(face); SDL_DestroySurface(face);
face = NULL; face = NULL;
SDL_FreeSurface(rface); SDL_DestroySurface(rface);
rface = NULL; rface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -275,9 +275,9 @@ int surface_testSurfaceConversion(void *arg)
/* Set transparent pixel as the pixel at (0,0) */ /* Set transparent pixel as the pixel at (0,0) */
if (face->format->palette) { if (face->format->palette) {
ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *)face->pixels); ret = SDL_SetSurfaceColorKey(face, SDL_RLEACCEL, *(Uint8 *)face->pixels);
SDLTest_AssertPass("Call to SDL_SetColorKey()"); SDLTest_AssertPass("Call to SDL_SetSurfaceColorKey()");
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorKey, expected: 0, got: %i", ret);
} }
/* Convert to 32 bit to compare. */ /* Convert to 32 bit to compare. */
@ -290,9 +290,9 @@ int surface_testSurfaceConversion(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(face); SDL_DestroySurface(face);
face = NULL; face = NULL;
SDL_FreeSurface(rface); SDL_DestroySurface(rface);
rface = NULL; rface = NULL;
return TEST_COMPLETED; return TEST_COMPLETED;
@ -345,9 +345,9 @@ int surface_testCompleteSurfaceConversion(void *arg)
/* Set transparent pixel as the pixel at (0,0) */ /* Set transparent pixel as the pixel at (0,0) */
if (face->format->palette) { if (face->format->palette) {
ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *)face->pixels); ret = SDL_SetSurfaceColorKey(face, SDL_RLEACCEL, *(Uint8 *)face->pixels);
SDLTest_AssertPass("Call to SDL_SetColorKey()"); SDLTest_AssertPass("Call to SDL_SetSurfaceColorKey()");
SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorKey, expected: 0, got: %i", ret);
} }
for (i = 0; i < SDL_arraysize(pixel_formats); ++i) { for (i = 0; i < SDL_arraysize(pixel_formats); ++i) {
@ -372,18 +372,18 @@ int surface_testCompleteSurfaceConversion(void *arg)
/* Compare surface. */ /* Compare surface. */
ret = SDLTest_CompareSurfaces(face, final, 0); ret = SDLTest_CompareSurfaces(face, final, 0);
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
SDL_FreeSurface(final); SDL_DestroySurface(final);
} }
SDL_FreeSurface(cvt1); SDL_DestroySurface(cvt1);
SDL_DestroyPixelFormat(fmt1); SDL_DestroyPixelFormat(fmt1);
SDL_FreeSurface(cvt2); SDL_DestroySurface(cvt2);
SDL_DestroyPixelFormat(fmt2); SDL_DestroyPixelFormat(fmt2);
} }
} }
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(face); SDL_DestroySurface(face);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -416,7 +416,7 @@ int surface_testBlit(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -438,7 +438,7 @@ int surface_testBlitColorMod(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -460,7 +460,7 @@ int surface_testBlitAlphaMod(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -482,7 +482,7 @@ int surface_testBlitBlendNone(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -504,7 +504,7 @@ int surface_testBlitBlendBlend(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -526,7 +526,7 @@ int surface_testBlitBlendAdd(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -548,7 +548,7 @@ int surface_testBlitBlendMod(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -571,7 +571,7 @@ int surface_testBlitBlendLoop(void *arg)
SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret); SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Clean up. */ /* Clean up. */
SDL_FreeSurface(compareSurface); SDL_DestroySurface(compareSurface);
return TEST_COMPLETED; return TEST_COMPLETED;
} }
@ -628,11 +628,11 @@ int surface_testOverflow(void *arg)
surface = SDL_CreateSurfaceFrom(buf, 6, 1, 3, SDL_PIXELFORMAT_INDEX4LSB); surface = SDL_CreateSurfaceFrom(buf, 6, 1, 3, SDL_PIXELFORMAT_INDEX4LSB);
SDLTest_AssertCheck(surface != NULL, "6px * 4 bits per px fits in 3 bytes: %s", SDLTest_AssertCheck(surface != NULL, "6px * 4 bits per px fits in 3 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 6, 1, 3, SDL_PIXELFORMAT_INDEX4LSB); surface = SDL_CreateSurfaceFrom(buf, 6, 1, 3, SDL_PIXELFORMAT_INDEX4LSB);
SDLTest_AssertCheck(surface != NULL, "6px * 4 bits per px fits in 3 bytes: %s", SDLTest_AssertCheck(surface != NULL, "6px * 4 bits per px fits in 3 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 7, 1, 3, SDL_PIXELFORMAT_INDEX4LSB); surface = SDL_CreateSurfaceFrom(buf, 7, 1, 3, SDL_PIXELFORMAT_INDEX4LSB);
SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp"); SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp");
@ -646,21 +646,21 @@ int surface_testOverflow(void *arg)
surface = SDL_CreateSurfaceFrom(buf, 7, 1, 4, SDL_PIXELFORMAT_INDEX4LSB); surface = SDL_CreateSurfaceFrom(buf, 7, 1, 4, SDL_PIXELFORMAT_INDEX4LSB);
SDLTest_AssertCheck(surface != NULL, "7px * 4 bits per px fits in 4 bytes: %s", SDLTest_AssertCheck(surface != NULL, "7px * 4 bits per px fits in 4 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 7, 1, 4, SDL_PIXELFORMAT_INDEX4LSB); surface = SDL_CreateSurfaceFrom(buf, 7, 1, 4, SDL_PIXELFORMAT_INDEX4LSB);
SDLTest_AssertCheck(surface != NULL, "7px * 4 bits per px fits in 4 bytes: %s", SDLTest_AssertCheck(surface != NULL, "7px * 4 bits per px fits in 4 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
/* SDL_PIXELFORMAT_INDEX1* needs 1 byte per 8 pixels. */ /* SDL_PIXELFORMAT_INDEX1* needs 1 byte per 8 pixels. */
surface = SDL_CreateSurfaceFrom(buf, 16, 1, 2, SDL_PIXELFORMAT_INDEX1LSB); surface = SDL_CreateSurfaceFrom(buf, 16, 1, 2, SDL_PIXELFORMAT_INDEX1LSB);
SDLTest_AssertCheck(surface != NULL, "16px * 1 bit per px fits in 2 bytes: %s", SDLTest_AssertCheck(surface != NULL, "16px * 1 bit per px fits in 2 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 16, 1, 2, SDL_PIXELFORMAT_INDEX1LSB); surface = SDL_CreateSurfaceFrom(buf, 16, 1, 2, SDL_PIXELFORMAT_INDEX1LSB);
SDLTest_AssertCheck(surface != NULL, "16px * 1 bit per px fits in 2 bytes: %s", SDLTest_AssertCheck(surface != NULL, "16px * 1 bit per px fits in 2 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 17, 1, 2, SDL_PIXELFORMAT_INDEX1LSB); surface = SDL_CreateSurfaceFrom(buf, 17, 1, 2, SDL_PIXELFORMAT_INDEX1LSB);
SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp"); SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp");
@ -674,21 +674,21 @@ int surface_testOverflow(void *arg)
surface = SDL_CreateSurfaceFrom(buf, 17, 1, 3, SDL_PIXELFORMAT_INDEX1LSB); surface = SDL_CreateSurfaceFrom(buf, 17, 1, 3, SDL_PIXELFORMAT_INDEX1LSB);
SDLTest_AssertCheck(surface != NULL, "17px * 1 bit per px fits in 3 bytes: %s", SDLTest_AssertCheck(surface != NULL, "17px * 1 bit per px fits in 3 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 17, 1, 3, SDL_PIXELFORMAT_INDEX1LSB); surface = SDL_CreateSurfaceFrom(buf, 17, 1, 3, SDL_PIXELFORMAT_INDEX1LSB);
SDLTest_AssertCheck(surface != NULL, "17px * 1 bit per px fits in 3 bytes: %s", SDLTest_AssertCheck(surface != NULL, "17px * 1 bit per px fits in 3 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
/* SDL_PIXELFORMAT_INDEX8 and SDL_PIXELFORMAT_RGB332 require 1 byte per pixel. */ /* SDL_PIXELFORMAT_INDEX8 and SDL_PIXELFORMAT_RGB332 require 1 byte per pixel. */
surface = SDL_CreateSurfaceFrom(buf, 5, 1, 5, SDL_PIXELFORMAT_RGB332); surface = SDL_CreateSurfaceFrom(buf, 5, 1, 5, SDL_PIXELFORMAT_RGB332);
SDLTest_AssertCheck(surface != NULL, "5px * 8 bits per px fits in 5 bytes: %s", SDLTest_AssertCheck(surface != NULL, "5px * 8 bits per px fits in 5 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 5, 1, 5, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurfaceFrom(buf, 5, 1, 5, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface != NULL, "5px * 8 bits per px fits in 5 bytes: %s", SDLTest_AssertCheck(surface != NULL, "5px * 8 bits per px fits in 5 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 6, 1, 5, SDL_PIXELFORMAT_RGB332); surface = SDL_CreateSurfaceFrom(buf, 6, 1, 5, SDL_PIXELFORMAT_RGB332);
SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp"); SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp");
@ -705,11 +705,11 @@ int surface_testOverflow(void *arg)
surface = SDL_CreateSurfaceFrom(buf, 3, 1, 6, SDL_PIXELFORMAT_RGB555); surface = SDL_CreateSurfaceFrom(buf, 3, 1, 6, SDL_PIXELFORMAT_RGB555);
SDLTest_AssertCheck(surface != NULL, "3px * 15 (really 16) bits per px fits in 6 bytes: %s", SDLTest_AssertCheck(surface != NULL, "3px * 15 (really 16) bits per px fits in 6 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 3, 1, 6, SDL_PIXELFORMAT_RGB555); surface = SDL_CreateSurfaceFrom(buf, 3, 1, 6, SDL_PIXELFORMAT_RGB555);
SDLTest_AssertCheck(surface != NULL, "5px * 15 (really 16) bits per px fits in 6 bytes: %s", SDLTest_AssertCheck(surface != NULL, "5px * 15 (really 16) bits per px fits in 6 bytes: %s",
surface != NULL ? "(success)" : SDL_GetError()); surface != NULL ? "(success)" : SDL_GetError());
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
surface = SDL_CreateSurfaceFrom(buf, 4, 1, 6, SDL_PIXELFORMAT_RGB555); surface = SDL_CreateSurfaceFrom(buf, 4, 1, 6, SDL_PIXELFORMAT_RGB555);
SDLTest_AssertCheck(surface == NULL, "4px * 15 (really 16) bits per px doesn't fit in 6 bytes"); SDLTest_AssertCheck(surface == NULL, "4px * 15 (really 16) bits per px doesn't fit in 6 bytes");

12
test/testcustomcursor.c
View File

@ -72,25 +72,25 @@ init_color_cursor(const char *file)
SDL_Surface *surface = SDL_LoadBMP(file); SDL_Surface *surface = SDL_LoadBMP(file);
if (surface) { if (surface) {
if (surface->format->palette) { if (surface->format->palette) {
SDL_SetColorKey(surface, 1, *(Uint8 *)surface->pixels); SDL_SetSurfaceColorKey(surface, 1, *(Uint8 *)surface->pixels);
} else { } else {
switch (surface->format->BitsPerPixel) { switch (surface->format->BitsPerPixel) {
case 15: case 15:
SDL_SetColorKey(surface, 1, (*(Uint16 *)surface->pixels) & 0x00007FFF); SDL_SetSurfaceColorKey(surface, 1, (*(Uint16 *)surface->pixels) & 0x00007FFF);
break; break;
case 16: case 16:
SDL_SetColorKey(surface, 1, *(Uint16 *)surface->pixels); SDL_SetSurfaceColorKey(surface, 1, *(Uint16 *)surface->pixels);
break; break;
case 24: case 24:
SDL_SetColorKey(surface, 1, (*(Uint32 *)surface->pixels) & 0x00FFFFFF); SDL_SetSurfaceColorKey(surface, 1, (*(Uint32 *)surface->pixels) & 0x00FFFFFF);
break; break;
case 32: case 32:
SDL_SetColorKey(surface, 1, *(Uint32 *)surface->pixels); SDL_SetSurfaceColorKey(surface, 1, *(Uint32 *)surface->pixels);
break; break;
} }
} }
cursor = SDL_CreateColorCursor(surface, 0, 0); cursor = SDL_CreateColorCursor(surface, 0, 0);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
return cursor; return cursor;
} }

4
test/testime.c
View File

@ -496,7 +496,7 @@ static void _Redraw(int rendererID)
drawnTextRect.h = textSur->h; drawnTextRect.h = textSur->h;
texture = SDL_CreateTextureFromSurface(renderer, textSur); texture = SDL_CreateTextureFromSurface(renderer, textSur);
SDL_FreeSurface(textSur); SDL_DestroySurface(textSur);
SDL_RenderTexture(renderer, texture, NULL, &drawnTextRect); SDL_RenderTexture(renderer, texture, NULL, &drawnTextRect);
SDL_DestroyTexture(texture); SDL_DestroyTexture(texture);
@ -567,7 +567,7 @@ static void _Redraw(int rendererID)
drawnTextRect.h = textSur->h; drawnTextRect.h = textSur->h;
texture = SDL_CreateTextureFromSurface(renderer, textSur); texture = SDL_CreateTextureFromSurface(renderer, textSur);
SDL_FreeSurface(textSur); SDL_DestroySurface(textSur);
SDL_RenderTexture(renderer, texture, NULL, &drawnTextRect); SDL_RenderTexture(renderer, texture, NULL, &drawnTextRect);
SDL_DestroyTexture(texture); SDL_DestroyTexture(texture);

2
test/testoffscreen.c
View File

@ -65,7 +65,7 @@ void save_surface_to_bmp()
SDL_GetWindowID(window), ++frame_number); SDL_GetWindowID(window), ++frame_number);
SDL_SaveBMP(surface, file); SDL_SaveBMP(surface, file);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
} }
void loop() void loop()

4
test/testoverlay2.c
View File

@ -171,7 +171,7 @@ quit(int rc)
SDL_free(RawMooseData); SDL_free(RawMooseData);
for (i = 0; i < MOOSEFRAMES_COUNT; i++) { for (i = 0; i < MOOSEFRAMES_COUNT; i++) {
SDL_FreeSurface(MooseYUVSurfaces[i]); SDL_DestroySurface(MooseYUVSurfaces[i]);
} }
SDLTest_CommonQuit(state); SDLTest_CommonQuit(state);
@ -472,7 +472,7 @@ int main(int argc, char **argv)
quit(7); quit(7);
} }
SDL_FreeSurface(mooseRGBSurface); SDL_DestroySurface(mooseRGBSurface);
} }
SDL_free(RawMooseData); SDL_free(RawMooseData);

4
test/testshader.c
View File

@ -350,7 +350,7 @@ SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
glTexImage2D(GL_TEXTURE_2D, glTexImage2D(GL_TEXTURE_2D,
0, 0,
GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels); GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
SDL_FreeSurface(image); /* No longer needed */ SDL_DestroySurface(image); /* No longer needed */
return texture; return texture;
} }
@ -476,7 +476,7 @@ int main(int argc, char **argv)
exit(3); exit(3);
} }
texture = SDL_GL_LoadTexture(surface, texcoords); texture = SDL_GL_LoadTexture(surface, texcoords);
SDL_FreeSurface(surface); SDL_DestroySurface(surface);
/* Loop, drawing and checking events */ /* Loop, drawing and checking events */
InitGL(640, 480); InitGL(640, 480);

10
test/testshape.c
View File

@ -82,7 +82,7 @@ int main(int argc, char **argv)
pictures[i].name = argv[i + 1]; pictures[i].name = argv[i + 1];
if (pictures[i].surface == NULL) { if (pictures[i].surface == NULL) {
for (j = 0; j < num_pictures; j++) { for (j = 0; j < num_pictures; j++) {
SDL_FreeSurface(pictures[j].surface); SDL_DestroySurface(pictures[j].surface);
} }
SDL_free(pictures); SDL_free(pictures);
SDL_Quit(); SDL_Quit();
@ -107,7 +107,7 @@ int main(int argc, char **argv)
SDL_SetWindowPosition(window, SHAPED_WINDOW_X, SHAPED_WINDOW_Y); SDL_SetWindowPosition(window, SHAPED_WINDOW_X, SHAPED_WINDOW_Y);
if (window == NULL) { if (window == NULL) {
for (i = 0; i < num_pictures; i++) { for (i = 0; i < num_pictures; i++) {
SDL_FreeSurface(pictures[i].surface); SDL_DestroySurface(pictures[i].surface);
} }
SDL_free(pictures); SDL_free(pictures);
SDL_Quit(); SDL_Quit();
@ -118,7 +118,7 @@ int main(int argc, char **argv)
if (renderer == NULL) { if (renderer == NULL) {
SDL_DestroyWindow(window); SDL_DestroyWindow(window);
for (i = 0; i < num_pictures; i++) { for (i = 0; i < num_pictures; i++) {
SDL_FreeSurface(pictures[i].surface); SDL_DestroySurface(pictures[i].surface);
} }
SDL_free(pictures); SDL_free(pictures);
SDL_Quit(); SDL_Quit();
@ -138,7 +138,7 @@ int main(int argc, char **argv)
} }
} }
for (i = 0; i < num_pictures; i++) { for (i = 0; i < num_pictures; i++) {
SDL_FreeSurface(pictures[i].surface); SDL_DestroySurface(pictures[i].surface);
} }
SDL_free(pictures); SDL_free(pictures);
SDL_DestroyRenderer(renderer); SDL_DestroyRenderer(renderer);
@ -198,7 +198,7 @@ int main(int argc, char **argv)
SDL_DestroyWindow(window); SDL_DestroyWindow(window);
/* Free the original surfaces backing the textures. */ /* Free the original surfaces backing the textures. */
for (i = 0; i < num_pictures; i++) { for (i = 0; i < num_pictures; i++) {
SDL_FreeSurface(pictures[i].surface); SDL_DestroySurface(pictures[i].surface);
} }
SDL_free(pictures); SDL_free(pictures);
/* Call SDL_Quit() before quitting. */ /* Call SDL_Quit() before quitting. */

12
test/testutils.c
View File

@ -109,22 +109,22 @@ LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent,
/* Set transparent pixel as the pixel at (0,0) */ /* Set transparent pixel as the pixel at (0,0) */
if (transparent) { if (transparent) {
if (temp->format->palette) { if (temp->format->palette) {
SDL_SetColorKey(temp, SDL_TRUE, *(Uint8 *)temp->pixels); SDL_SetSurfaceColorKey(temp, SDL_TRUE, *(Uint8 *)temp->pixels);
} else { } else {
switch (temp->format->BitsPerPixel) { switch (temp->format->BitsPerPixel) {
case 15: case 15:
SDL_SetColorKey(temp, SDL_TRUE, SDL_SetSurfaceColorKey(temp, SDL_TRUE,
(*(Uint16 *)temp->pixels) & 0x00007FFF); (*(Uint16 *)temp->pixels) & 0x00007FFF);
break; break;
case 16: case 16:
SDL_SetColorKey(temp, SDL_TRUE, *(Uint16 *)temp->pixels); SDL_SetSurfaceColorKey(temp, SDL_TRUE, *(Uint16 *)temp->pixels);
break; break;
case 24: case 24:
SDL_SetColorKey(temp, SDL_TRUE, SDL_SetSurfaceColorKey(temp, SDL_TRUE,
(*(Uint32 *)temp->pixels) & 0x00FFFFFF); (*(Uint32 *)temp->pixels) & 0x00FFFFFF);
break; break;
case 32: case 32:
SDL_SetColorKey(temp, SDL_TRUE, *(Uint32 *)temp->pixels); SDL_SetSurfaceColorKey(temp, SDL_TRUE, *(Uint32 *)temp->pixels);
break; break;
} }
} }
@ -143,7 +143,7 @@ LoadTexture(SDL_Renderer *renderer, const char *file, SDL_bool transparent,
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create texture: %s\n", SDL_GetError());
} }
} }
SDL_FreeSurface(temp); SDL_DestroySurface(temp);
if (path) { if (path) {
SDL_free(path); SDL_free(path);
} }

2
test/testyuv.c
View File

@ -204,7 +204,7 @@ static int run_automated_tests(int pattern_size, int extra_pitch)
done: done:
SDL_free(yuv1); SDL_free(yuv1);
SDL_free(yuv2); SDL_free(yuv2);
SDL_FreeSurface(pattern); SDL_DestroySurface(pattern);
return result; return result;
} }