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

Remove mask versions of SDL_CreateRGBSurface* #6701 (#6711) 

* Rename SDL_CreateRGBSurface{,From} to SDL_CreateSurface{,From}, which now takes a format parameter
main
Sylvain Becker 2022-12-01 17:04:02 +01:00 committed by GitHub
parent 778b8926b4
commit 932f61348d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
36 changed files with 212 additions and 558 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
WhatsNew.txt
View File

@ -19,13 +19,19 @@ General:
* SDL_RWFromFP() * SDL_RWFromFP()
* SDL_SetWindowBrightness() * SDL_SetWindowBrightness()
* SDL_SetWindowGammaRamp() * SDL_SetWindowGammaRamp()
* SDL_CreateRGBSurface()
* SDL_CreateRGBSurfaceWithFormat()
* SDL_CreateRGBSurfaceFrom()
* SDL_CreateRGBSurfaceWithFormatFrom()
* Removed the following hints from the API, see docs/README-migration.md for details: * Removed the following hints from the API, see docs/README-migration.md for details:
* SDL_HINT_IDLE_TIMER_DISABLED * SDL_HINT_IDLE_TIMER_DISABLED
* SDL_HINT_VIDEO_X11_FORCE_EGL * SDL_HINT_VIDEO_X11_FORCE_EGL
* SDL_HINT_VIDEO_X11_XINERAMA * SDL_HINT_VIDEO_X11_XINERAMA
* SDL_HINT_VIDEO_X11_XVIDMODE * SDL_HINT_VIDEO_X11_XVIDMODE
* SDL_stdinc.h no longer includes stdio.h, stdlib.h, etc., it only provides the SDL C runtime functionality * SDL_stdinc.h no longer includes stdio.h, stdlib.h, etc., it only provides the SDL C runtime functionality
* Removed unused 'depth' parameter from SDL_CreateRGBSurfaceWithFormat and SDL_CreateRGBSurfaceWithFormatFrom
* Removed unused 'flags' parameter from SDL_CreateRGBSurface and SDL_CreateRGBSurfaceWithFormat
* Removed unused 'flags' parameter from SDL_ConvertSurface and SDL_ConvertSurfaceFormat * Removed unused 'flags' parameter from SDL_ConvertSurface and SDL_ConvertSurfaceFormat
* Added SDL_CreateSurface() and SDL_CreateSurfaceFrom() which take a format. SDL_CreateRGBSurface*() are removed.

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

@ -327,8 +327,6 @@ void
initializeTexture() initializeTexture()
{ {
int bpp; /* texture bits per pixel */
Uint32 Rmask, Gmask, Bmask, Amask; /* masks for pixel format passed into OpenGL */
SDL_Surface *bmp_surface; /* the bmp is loaded here */ SDL_Surface *bmp_surface; /* the bmp is loaded here */
SDL_Surface *bmp_surface_rgba8888; /* this serves as a destination to convert the BMP SDL_Surface *bmp_surface_rgba8888; /* this serves as a destination to convert the BMP
to format passed into OpenGL */ to format passed into OpenGL */
@ -338,13 +336,9 @@ initializeTexture()
fatalError("could not load stroke.bmp"); fatalError("could not load stroke.bmp");
} }
/* Grab info about format that will be passed into OpenGL */
SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_ABGR8888, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
/* Create surface that will hold pixels passed into OpenGL */ /* Create surface that will hold pixels passed into OpenGL */
bmp_surface_rgba8888 = bmp_surface_rgba8888 = SDL_CreateSurface(bmp_surface->w, bmp_surface->h, SDL_PIXELFORMAT_ABGR8888);
SDL_CreateRGBSurface(bmp_surface->w, bmp_surface->h, bpp, Rmask,
Gmask, Bmask, Amask);
/* Blit to this surface, effectively converting the format */ /* Blit to this surface, effectively converting the format */
SDL_BlitSurface(bmp_surface, NULL, bmp_surface_rgba8888, NULL); SDL_BlitSurface(bmp_surface, NULL, bmp_surface_rgba8888, NULL);

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

@ -173,13 +173,9 @@ loadFont(void)
SDL_SetColorKey(surface, 1, SDL_MapRGB(surface->format, 238, 0, 252)); SDL_SetColorKey(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 */
Uint32 Rmask, Gmask, Bmask, Amask; /* masks for desired format */
int bpp; /* bits per pixel for desired format */ SDL_Surface *converted = SDL_CreateSurface(surface->w, surface->h, format);
SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask,
&Amask);
SDL_Surface *converted =
SDL_CreateRGBSurface(surface->w, surface->h, bpp, Rmask, Gmask,
Bmask, Amask);
SDL_BlitSurface(surface, NULL, converted, NULL); SDL_BlitSurface(surface, NULL, converted, NULL);
/* create our texture */ /* create our texture */
texture = SDL_CreateTextureFromSurface(renderer, converted); texture = SDL_CreateTextureFromSurface(renderer, converted);

35
docs/README-migration.md
View File

@ -162,9 +162,38 @@ M_PI is no longer defined in SDL_stdinc.h, you can use the new symbols SDL_PI_D
## SDL_surface.h ## SDL_surface.h
Removed unused 'depth' parameter from SDL_CreateRGBSurfaceWithFormat() and SDL_CreateRGBSurfaceWithFormatFrom() Removed unused 'flags' parameter from SDL_ConvertSurface and SDL_ConvertSurfaceFormat.
Removed unused 'flags' parameter from SDL_CreateRGBSurface() and SDL_CreateRGBSurfaceWithFormat()
Removed unused 'flags' parameter from SDL_ConvertSurface and SDL_ConvertSurfaceFormat
Added SDL_CreateSurface() and SDL_CreateSurfaceFrom() which take a format.
SDL_CreateRGBSurface(), SDL_CreateRGBSurfaceFrom(), SDL_CreateRGBSurfaceWithFormat() and SDL_CreateRGBSurfaceWithFormatFrom() are removed.
This code:
```c
SDL_Surface *surface = SDL_CreateRGBSurface(0, width, height, 0, Rmask, Gmask, Bmask, Amask);
```
can be replaced with this:
```c
Uint32 format = SDL_MasksToPixelFormatEnum(0, Rmask, Gmask, Bmask, Amask);
SDL_Surface *surface = SDL_CreateSurface(width, height, format);
```
but in general, you probably have a format that you know you're using, possibly one of these:
```c
// Various mask (R, G, B, A) in little endian and their corresponding format:
0xFF000000 0x00FF0000 0x0000FF00 0x000000FF => SDL_PIXELFORMAT_RGBA8888
0x000000FF 0x0000FF00 0x00FF0000 0xFF000000 => SDL_PIXELFORMAT_ABGR8888
0x00FF0000 0x0000FF00 0x000000FF 0xFF000000 => SDL_PIXELFORMAT_ARGB8888
0x00FF0000 0x0000FF00 0x000000FF 0x00000000 => SDL_PIXELFORMAT_BGR24
0x000000FF 0x0000FF00 0x000000FF 0x00000000 => SDL_PIXELFORMAT_RGB24
0x00007C00 00000x03E0 00000x001F 0x00000000 => SDL_PIXELFORMAT_RGB555
0x00007C00 00000x03E0 00000x001F 0x00008000 => SDL_PIXELFORMAT_ARGB1555
```
## SDL_syswm.h ## SDL_syswm.h

2
include/SDL3/SDL_pixels.h
View File

@ -468,7 +468,7 @@ extern DECLSPEC int SDLCALL SDL_SetPixelFormatPalette(SDL_PixelFormat * format,
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_AllocPalette * \sa SDL_AllocPalette
* \sa SDL_CreateRGBSurface * \sa SDL_CreateSurface
*/ */
extern DECLSPEC int SDLCALL SDL_SetPaletteColors(SDL_Palette * palette, extern DECLSPEC int SDLCALL SDL_SetPaletteColors(SDL_Palette * palette,
const SDL_Color * colors, const SDL_Color * colors,

112
include/SDL3/SDL_surface.h
View File

@ -113,61 +113,9 @@ typedef enum
SDL_YUV_CONVERSION_AUTOMATIC /**< BT.601 for SD content, BT.709 for HD content */ SDL_YUV_CONVERSION_AUTOMATIC /**< BT.601 for SD content, BT.709 for HD content */
} SDL_YUV_CONVERSION_MODE; } SDL_YUV_CONVERSION_MODE;
/**
* Allocate a new RGB surface.
*
* If `depth` is 4 or 8 bits, an empty palette is allocated for the surface.
* If `depth` is greater than 8 bits, the pixel format is set using the
* [RGBA]mask parameters.
*
* The [RGBA]mask parameters are the bitmasks used to extract that color from
* a pixel. For instance, `Rmask` being 0xFF000000 means the red data is
* stored in the most significant byte. Using zeros for the RGB masks sets a
* default value, based on the depth. For example:
*
* ```c++
* SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);
* ```
*
* However, using zero for the Amask results in an Amask of 0.
*
* By default surfaces with an alpha mask are set up for blending as with:
*
* ```c++
* SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)
* ```
*
* You can change this by calling SDL_SetSurfaceBlendMode() and selecting a
* different `blendMode`.
*
* \param width the width of the surface
* \param height the height of the surface
* \param depth the depth of the surface in bits
* \param Rmask the red mask for the pixels
* \param Gmask the green mask for the pixels
* \param Bmask the blue mask for the pixels
* \param Amask the alpha mask for the pixels
* \returns the new SDL_Surface structure that is created or NULL if it fails;
* call SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_CreateRGBSurfaceFrom
* \sa SDL_CreateRGBSurfaceWithFormat
* \sa SDL_FreeSurface
*/
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
(int width, int height, int depth,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
/** /**
* Allocate a new RGB surface with a specific pixel format. * Allocate a new RGB surface with a specific pixel format.
* *
* This function operates mostly like SDL_CreateRGBSurface(), except instead
* of providing pixel color masks, you provide it with a predefined format
* from SDL_PixelFormatEnum.
*
* \param width the width of the surface * \param width the width of the surface
* \param height the height of the surface * \param height the height of the surface
* \param format the SDL_PixelFormatEnum for the new surface's pixel format. * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
@ -176,59 +124,16 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_CreateRGBSurface * \sa SDL_CreateSurfaceFrom
* \sa SDL_CreateRGBSurfaceFrom
* \sa SDL_FreeSurface * \sa SDL_FreeSurface
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormat extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateSurface
(int width, int height, Uint32 format); (int width, int height, Uint32 format);
/**
* Allocate a new RGB surface with existing pixel data.
*
* This function operates mostly like SDL_CreateRGBSurface(), except it does
* not allocate memory for the pixel data, instead the caller provides an
* existing buffer of data for the surface to use.
*
* No copy is made of the pixel data. Pixel data is not managed automatically;
* you must free the surface before you free the pixel data.
*
* \param pixels a pointer to existing pixel data
* \param width the width of the surface
* \param height the height of the surface
* \param depth the depth of the surface in bits
* \param pitch the pitch of the surface in bytes
* \param Rmask the red mask for the pixels
* \param Gmask the green mask for the pixels
* \param Bmask the blue mask for the pixels
* \param Amask the alpha mask for the pixels
* \returns the new SDL_Surface structure that is created or NULL if it fails;
* call SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_CreateRGBSurface
* \sa SDL_CreateRGBSurfaceWithFormat
* \sa SDL_FreeSurface
*/
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
int width,
int height,
int depth,
int pitch,
Uint32 Rmask,
Uint32 Gmask,
Uint32 Bmask,
Uint32 Amask);
/** /**
* Allocate a new RGB surface with with a specific pixel format and existing * Allocate a new RGB surface with with a specific pixel format and existing
* pixel data. * pixel data.
* *
* This function operates mostly like SDL_CreateRGBSurfaceFrom(), except
* instead of providing pixel color masks, you provide it with a predefined
* format from SDL_PixelFormatEnum.
*
* No copy is made of the pixel data. Pixel data is not managed automatically; * No copy is made of the pixel data. Pixel data is not managed automatically;
* you must free the surface before you free the pixel data. * you must free the surface before you free the pixel data.
* *
@ -242,11 +147,10 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_CreateRGBSurfaceFrom * \sa SDL_CreateSurface
* \sa SDL_CreateRGBSurfaceWithFormat
* \sa SDL_FreeSurface * \sa SDL_FreeSurface
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom 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);
/** /**
@ -258,8 +162,8 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom
* *
* \since This function is available since SDL 3.0.0. * \since This function is available since SDL 3.0.0.
* *
* \sa SDL_CreateRGBSurface * \sa SDL_CreateSurface
* \sa SDL_CreateRGBSurfaceFrom * \sa SDL_CreateSurfaceFrom
* \sa SDL_LoadBMP * \sa SDL_LoadBMP
* \sa SDL_LoadBMP_RW * \sa SDL_LoadBMP_RW
*/ */
@ -660,7 +564,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface)
* *
* \sa SDL_AllocFormat * \sa SDL_AllocFormat
* \sa SDL_ConvertSurfaceFormat * \sa SDL_ConvertSurfaceFormat
* \sa SDL_CreateRGBSurface * \sa SDL_CreateSurface
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
(SDL_Surface * src, const SDL_PixelFormat * fmt); (SDL_Surface * src, const SDL_PixelFormat * fmt);
@ -683,7 +587,7 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
* *
* \sa SDL_AllocFormat * \sa SDL_AllocFormat
* \sa SDL_ConvertSurface * \sa SDL_ConvertSurface
* \sa SDL_CreateRGBSurface * \sa SDL_CreateSurface
*/ */
extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat
(SDL_Surface * src, Uint32 pixel_format); (SDL_Surface * src, Uint32 pixel_format);

6
src/dynapi/SDL_dynapi_overrides.h
View File

@ -437,8 +437,6 @@
#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_CreateRGBSurface SDL_CreateRGBSurface_REAL
#define SDL_CreateRGBSurfaceFrom SDL_CreateRGBSurfaceFrom_REAL
#define SDL_FreeSurface SDL_FreeSurface_REAL #define SDL_FreeSurface SDL_FreeSurface_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
@ -592,8 +590,8 @@
#define SDL_RenderGetIntegerScale SDL_RenderGetIntegerScale_REAL #define SDL_RenderGetIntegerScale SDL_RenderGetIntegerScale_REAL
#define SDL_DequeueAudio SDL_DequeueAudio_REAL #define SDL_DequeueAudio SDL_DequeueAudio_REAL
#define SDL_SetWindowResizable SDL_SetWindowResizable_REAL #define SDL_SetWindowResizable SDL_SetWindowResizable_REAL
#define SDL_CreateRGBSurfaceWithFormat SDL_CreateRGBSurfaceWithFormat_REAL #define SDL_CreateSurface SDL_CreateSurface_REAL
#define SDL_CreateRGBSurfaceWithFormatFrom SDL_CreateRGBSurfaceWithFormatFrom_REAL #define SDL_CreateSurfaceFrom SDL_CreateSurfaceFrom_REAL
#define SDL_GetHintBoolean SDL_GetHintBoolean_REAL #define SDL_GetHintBoolean SDL_GetHintBoolean_REAL
#define SDL_JoystickGetDeviceVendor SDL_JoystickGetDeviceVendor_REAL #define SDL_JoystickGetDeviceVendor SDL_JoystickGetDeviceVendor_REAL
#define SDL_JoystickGetDeviceProduct SDL_JoystickGetDeviceProduct_REAL #define SDL_JoystickGetDeviceProduct SDL_JoystickGetDeviceProduct_REAL

6
src/dynapi/SDL_dynapi_procs.h
View File

@ -464,8 +464,6 @@ 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(SDL_Surface*,SDL_CreateRGBSurface,(int a, int b, int c, Uint32 d, Uint32 e, Uint32 f, Uint32 g),(a,b,c,d,e,f,g),return)
SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateRGBSurfaceFrom,(void *a, int b, int c, int d, int e, Uint32 f, Uint32 g, Uint32 h, Uint32 i),(a,b,c,d,e,f,g,h,i),return)
SDL_DYNAPI_PROC(void,SDL_FreeSurface,(SDL_Surface *a),(a),) SDL_DYNAPI_PROC(void,SDL_FreeSurface,(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)
@ -625,8 +623,8 @@ SDL_DYNAPI_PROC(int,SDL_RenderSetIntegerScale,(SDL_Renderer *a, SDL_bool b),(a,b
SDL_DYNAPI_PROC(SDL_bool,SDL_RenderGetIntegerScale,(SDL_Renderer *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_RenderGetIntegerScale,(SDL_Renderer *a),(a),return)
SDL_DYNAPI_PROC(Uint32,SDL_DequeueAudio,(SDL_AudioDeviceID a, void *b, Uint32 c),(a,b,c),return) SDL_DYNAPI_PROC(Uint32,SDL_DequeueAudio,(SDL_AudioDeviceID a, void *b, Uint32 c),(a,b,c),return)
SDL_DYNAPI_PROC(void,SDL_SetWindowResizable,(SDL_Window *a, SDL_bool b),(a,b),) SDL_DYNAPI_PROC(void,SDL_SetWindowResizable,(SDL_Window *a, SDL_bool b),(a,b),)
SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateRGBSurfaceWithFormat,(int a, int b, Uint32 c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateSurface,(int a, int b, Uint32 c),(a,b,c),return)
SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateRGBSurfaceWithFormatFrom,(void *a, int b, int c, int d, Uint32 e),(a,b,c,d,e),return) SDL_DYNAPI_PROC(SDL_Surface*,SDL_CreateSurfaceFrom,(void *a, int b, int c, int d, Uint32 e),(a,b,c,d,e),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_GetHintBoolean,(const char *a, SDL_bool b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_GetHintBoolean,(const char *a, SDL_bool b),(a,b),return)
SDL_DYNAPI_PROC(Uint16,SDL_JoystickGetDeviceVendor,(int a),(a),return) SDL_DYNAPI_PROC(Uint16,SDL_JoystickGetDeviceVendor,(int a),(a),return)
SDL_DYNAPI_PROC(Uint16,SDL_JoystickGetDeviceProduct,(int a),(a),return) SDL_DYNAPI_PROC(Uint16,SDL_JoystickGetDeviceProduct,(int a),(a),return)

6
src/events/SDL_mouse.c
View File

@ -1221,11 +1221,7 @@ SDL_CreateCursor(const Uint8 *data, const Uint8 *mask,
w = ((w + 7) & ~7); w = ((w + 7) & ~7);
/* Create the surface from a bitmap */ /* Create the surface from a bitmap */
surface = SDL_CreateRGBSurface(w, h, 32, surface = SDL_CreateSurface(w, h, SDL_PIXELFORMAT_ARGB8888);
0x00FF0000,
0x0000FF00,
0x000000FF,
0xFF000000);
if (surface == NULL) { if (surface == NULL) {
return NULL; return NULL;
} }

2
src/render/SDL_render.c
View File

@ -2077,7 +2077,7 @@ int SDL_LockTextureToSurface(SDL_Texture *texture, const SDL_Rect *rect,
return ret; return ret;
} }
texture->locked_surface = SDL_CreateRGBSurfaceWithFormatFrom(pixels, real_rect.w, real_rect.h, pitch, texture->format); texture->locked_surface = SDL_CreateSurfaceFrom(pixels, real_rect.w, real_rect.h, pitch, texture->format);
if (texture->locked_surface == NULL) { if (texture->locked_surface == NULL) {
SDL_UnlockTexture(texture); SDL_UnlockTexture(texture);
return -1; return -1;

17
src/render/SDL_yuv_sw.c
View File

@ -377,32 +377,19 @@ int SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture *swdata, const SDL_Rect *srcrect,
stretch = 1; stretch = 1;
} }
if (stretch) { if (stretch) {
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
if (swdata->display) { if (swdata->display) {
swdata->display->w = w; swdata->display->w = w;
swdata->display->h = h; swdata->display->h = h;
swdata->display->pixels = pixels; swdata->display->pixels = pixels;
swdata->display->pitch = pitch; swdata->display->pitch = pitch;
} else { } else {
/* This must have succeeded in SDL_SW_SetupYUVDisplay() earlier */ swdata->display = SDL_CreateSurfaceFrom(pixels, w, h, pitch, target_format);
SDL_PixelFormatEnumToMasks(target_format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
swdata->display =
SDL_CreateRGBSurfaceFrom(pixels, w, h, bpp, pitch, Rmask,
Gmask, Bmask, Amask);
if (!swdata->display) { if (!swdata->display) {
return -1; return -1;
} }
} }
if (!swdata->stretch) { if (!swdata->stretch) {
/* This must have succeeded in SDL_SW_SetupYUVDisplay() earlier */ swdata->stretch = SDL_CreateSurface(swdata->w, swdata->h, target_format);
SDL_PixelFormatEnumToMasks(target_format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
swdata->stretch =
SDL_CreateRGBSurface(swdata->w, swdata->h, bpp, Rmask,
Gmask, Bmask, Amask);
if (!swdata->stretch) { if (!swdata->stretch) {
return -1; return -1;
} }

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

@ -99,16 +99,12 @@ static int SW_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
static int SW_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture) static int SW_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
{ {
int bpp; SDL_Surface *surface = SDL_CreateSurface(texture->w, texture->h, texture->format);
Uint32 Rmask, Gmask, Bmask, Amask;
if (!SDL_PixelFormatEnumToMasks(texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { if (surface == NULL) {
return SDL_SetError("Unknown texture format"); return SDL_SetError("Cannot create surface");
} }
texture->driverdata = surface;
texture->driverdata =
SDL_CreateRGBSurface(texture->w, texture->h, bpp, Rmask, Gmask,
Bmask, Amask);
SDL_SetSurfaceColorMod(texture->driverdata, texture->color.r, texture->color.g, texture->color.b); SDL_SetSurfaceColorMod(texture->driverdata, texture->color.r, texture->color.g, texture->color.b);
SDL_SetSurfaceAlphaMod(texture->driverdata, texture->color.a); SDL_SetSurfaceAlphaMod(texture->driverdata, texture->color.a);
SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode); SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode);
@ -116,7 +112,7 @@ static int SW_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
/* Only RLE encode textures without an alpha channel since the RLE coder /* Only RLE encode textures without an alpha channel since the RLE coder
* discards the color values of pixels with an alpha value of zero. * discards the color values of pixels with an alpha value of zero.
*/ */
if (texture->access == SDL_TEXTUREACCESS_STATIC && !Amask) { if (texture->access == SDL_TEXTUREACCESS_STATIC && !surface->format->Amask) {
SDL_SetSurfaceRLE(texture->driverdata, 1); SDL_SetSurfaceRLE(texture->driverdata, 1);
} }
@ -342,9 +338,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
/* Clone the source surface but use its pixel buffer directly. /* Clone the source surface but use its pixel buffer directly.
* The original source surface must be treated as read-only. * The original source surface must be treated as read-only.
*/ */
src_clone = SDL_CreateRGBSurfaceFrom(src->pixels, src->w, src->h, src->format->BitsPerPixel, src->pitch, src_clone = SDL_CreateSurfaceFrom(src->pixels, src->w, src->h, src->pitch, src->format->format);
src->format->Rmask, src->format->Gmask,
src->format->Bmask, src->format->Amask);
if (src_clone == NULL) { if (src_clone == NULL) {
if (SDL_MUSTLOCK(src)) { if (SDL_MUSTLOCK(src)) {
SDL_UnlockSurface(src); SDL_UnlockSurface(src);
@ -387,8 +381,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
* to clear the pixels in the destination surface. The other steps are explained below. * to clear the pixels in the destination surface. The other steps are explained below.
*/ */
if (blendmode == SDL_BLENDMODE_NONE && !isOpaque) { if (blendmode == SDL_BLENDMODE_NONE && !isOpaque) {
mask = SDL_CreateRGBSurface(final_rect->w, final_rect->h, 32, mask = SDL_CreateSurface(final_rect->w, final_rect->h, SDL_PIXELFORMAT_ARGB8888);
0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
if (mask == NULL) { if (mask == NULL) {
retval = -1; retval = -1;
} else { } else {
@ -401,8 +394,7 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
*/ */
if (!retval && (blitRequired || applyModulation)) { if (!retval && (blitRequired || applyModulation)) {
SDL_Rect scale_rect = tmp_rect; SDL_Rect scale_rect = tmp_rect;
src_scaled = SDL_CreateRGBSurface(final_rect->w, final_rect->h, 32, src_scaled = SDL_CreateSurface(final_rect->w, final_rect->h, SDL_PIXELFORMAT_ARGB8888);
0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
if (src_scaled == NULL) { if (src_scaled == NULL) {
retval = -1; retval = -1;
} else { } else {
@ -482,10 +474,14 @@ static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Tex
* to be created. This makes all source pixels opaque and the colors get copied correctly. * to be created. This makes all source pixels opaque and the colors get copied correctly.
*/ */
SDL_Surface *src_rotated_rgb; SDL_Surface *src_rotated_rgb;
src_rotated_rgb = SDL_CreateRGBSurfaceFrom(src_rotated->pixels, src_rotated->w, src_rotated->h, int f = SDL_MasksToPixelFormatEnum(src_rotated->format->BitsPerPixel,
src_rotated->format->BitsPerPixel, src_rotated->pitch, src_rotated->format->Rmask,
src_rotated->format->Rmask, src_rotated->format->Gmask, src_rotated->format->Gmask,
src_rotated->format->Bmask, 0); src_rotated->format->Bmask,
0);
src_rotated_rgb = SDL_CreateSurfaceFrom(src_rotated->pixels, src_rotated->w, src_rotated->h,
src_rotated->pitch, f);
if (src_rotated_rgb == NULL) { if (src_rotated_rgb == NULL) {
retval = -1; retval = -1;
} else { } else {
@ -816,7 +812,7 @@ static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, vo
/* Prevent to do scaling + clipping on viewport boundaries as it may lose proportion */ /* Prevent to do scaling + clipping on viewport boundaries as it may lose proportion */
if (dstrect->x < 0 || dstrect->y < 0 || dstrect->x + dstrect->w > surface->w || dstrect->y + dstrect->h > surface->h) { if (dstrect->x < 0 || dstrect->y < 0 || dstrect->x + dstrect->w > surface->w || dstrect->y + dstrect->h > surface->h) {
SDL_Surface *tmp = SDL_CreateRGBSurfaceWithFormat(dstrect->w, dstrect->h, src->format->format); SDL_Surface *tmp = SDL_CreateSurface(dstrect->w, dstrect->h, src->format->format);
/* Scale to an intermediate surface, then blit */ /* Scale to an intermediate surface, then blit */
if (tmp) { if (tmp) {
SDL_Rect r; SDL_Rect r;

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

@ -523,7 +523,7 @@ SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int
rz_dst = NULL; rz_dst = NULL;
if (is8bit) { if (is8bit) {
/* Target surface is 8 bit */ /* Target surface is 8 bit */
rz_dst = SDL_CreateRGBSurfaceWithFormat(rect_dest->w, rect_dest->h + GUARD_ROWS, src->format->format); rz_dst = SDL_CreateSurface(rect_dest->w, rect_dest->h + GUARD_ROWS, src->format->format);
if (rz_dst != NULL) { if (rz_dst != NULL) {
if (src->format->palette) { if (src->format->palette) {
for (i = 0; i < src->format->palette->ncolors; i++) { for (i = 0; i < src->format->palette->ncolors; i++) {
@ -534,9 +534,7 @@ SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int
} }
} else { } else {
/* Target surface is 32 bit with source RGBA ordering */ /* Target surface is 32 bit with source RGBA ordering */
rz_dst = SDL_CreateRGBSurface(rect_dest->w, rect_dest->h + GUARD_ROWS, 32, rz_dst = SDL_CreateSurface(rect_dest->w, rect_dest->h + GUARD_ROWS, src->format->format);
src->format->Rmask, src->format->Gmask,
src->format->Bmask, src->format->Amask);
} }
/* Check target */ /* Check target */

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

@ -270,7 +270,7 @@ int SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Poin
} }
/* Use an intermediate surface */ /* Use an intermediate surface */
tmp = SDL_CreateRGBSurfaceWithFormat(dstrect.w, dstrect.h, format); tmp = SDL_CreateSurface(dstrect.w, dstrect.h, format);
if (tmp == NULL) { if (tmp == NULL) {
ret = -1; ret = -1;
goto end; goto end;

10
src/test/SDL_test_common.c
View File

@ -1749,13 +1749,9 @@ static void SDLTest_ScreenShot(SDL_Renderer *renderer)
} }
SDL_RenderGetViewport(renderer, &viewport); SDL_RenderGetViewport(renderer, &viewport);
surface = SDL_CreateRGBSurface(viewport.w, viewport.h, 24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN surface = SDL_CreateSurface(viewport.w, viewport.h, SDL_PIXELFORMAT_BGR24);
0x00FF0000, 0x0000FF00, 0x000000FF,
#else
0x000000FF, 0x0000FF00, 0x00FF0000,
#endif
0x00000000);
if (surface == NULL) { if (surface == NULL) {
SDL_Log("Couldn't create surface: %s\n", SDL_GetError()); SDL_Log("Couldn't create surface: %s\n", SDL_GetError());
return; return;

3
src/test/SDL_test_font.c
View File

@ -3185,8 +3185,7 @@ int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, Uint32 c)
/* /*
* Redraw character into surface * Redraw character into surface
*/ */
character = SDL_CreateRGBSurface(charWidth, charHeight, 32, character = SDL_CreateSurface(charWidth, charHeight, SDL_PIXELFORMAT_RGBA8888);
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
if (character == NULL) { if (character == NULL) {
return -1; return -1;
} }

51
src/test/SDL_test_imageBlit.c
View File

@ -540,24 +540,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlit = {
*/ */
SDL_Surface *SDLTest_ImageBlit() SDL_Surface *SDLTest_ImageBlit()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlit.pixel_data, (void *)SDLTest_imageBlit.pixel_data,
SDLTest_imageBlit.width, SDLTest_imageBlit.width,
SDLTest_imageBlit.height, SDLTest_imageBlit.height,
SDLTest_imageBlit.bytes_per_pixel * 8, SDLTest_imageBlit.width * SDLTest_imageBlit.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlit.width * SDLTest_imageBlit.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }
@ -1025,24 +1012,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitColor = {
*/ */
SDL_Surface *SDLTest_ImageBlitColor() SDL_Surface *SDLTest_ImageBlitColor()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitColor.pixel_data, (void *)SDLTest_imageBlitColor.pixel_data,
SDLTest_imageBlitColor.width, SDLTest_imageBlitColor.width,
SDLTest_imageBlitColor.height, SDLTest_imageBlitColor.height,
SDLTest_imageBlitColor.bytes_per_pixel * 8, SDLTest_imageBlitColor.width * SDLTest_imageBlitColor.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitColor.width * SDLTest_imageBlitColor.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }
@ -1673,24 +1647,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitAlpha = {
*/ */
SDL_Surface *SDLTest_ImageBlitAlpha() SDL_Surface *SDLTest_ImageBlitAlpha()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitAlpha.pixel_data, (void *)SDLTest_imageBlitAlpha.pixel_data,
SDLTest_imageBlitAlpha.width, SDLTest_imageBlitAlpha.width,
SDLTest_imageBlitAlpha.height, SDLTest_imageBlitAlpha.height,
SDLTest_imageBlitAlpha.bytes_per_pixel * 8, SDLTest_imageBlitAlpha.width * SDLTest_imageBlitAlpha.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitAlpha.width * SDLTest_imageBlitAlpha.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }

85
src/test/SDL_test_imageBlitBlend.c
View File

@ -580,24 +580,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitBlendAdd = {
*/ */
SDL_Surface *SDLTest_ImageBlitBlendAdd() SDL_Surface *SDLTest_ImageBlitBlendAdd()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitBlendAdd.pixel_data, (void *)SDLTest_imageBlitBlendAdd.pixel_data,
SDLTest_imageBlitBlendAdd.width, SDLTest_imageBlitBlendAdd.width,
SDLTest_imageBlitBlendAdd.height, SDLTest_imageBlitBlendAdd.height,
SDLTest_imageBlitBlendAdd.bytes_per_pixel * 8, SDLTest_imageBlitBlendAdd.width * SDLTest_imageBlitBlendAdd.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitBlendAdd.width * SDLTest_imageBlitBlendAdd.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }
@ -1182,24 +1169,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitBlend = {
*/ */
SDL_Surface *SDLTest_ImageBlitBlend() SDL_Surface *SDLTest_ImageBlitBlend()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitBlend.pixel_data, (void *)SDLTest_imageBlitBlend.pixel_data,
SDLTest_imageBlitBlend.width, SDLTest_imageBlitBlend.width,
SDLTest_imageBlitBlend.height, SDLTest_imageBlitBlend.height,
SDLTest_imageBlitBlend.bytes_per_pixel * 8, SDLTest_imageBlitBlend.width * SDLTest_imageBlitBlend.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitBlend.width * SDLTest_imageBlitBlend.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }
@ -1614,24 +1588,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitBlendMod = {
*/ */
SDL_Surface *SDLTest_ImageBlitBlendMod() SDL_Surface *SDLTest_ImageBlitBlendMod()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitBlendMod.pixel_data, (void *)SDLTest_imageBlitBlendMod.pixel_data,
SDLTest_imageBlitBlendMod.width, SDLTest_imageBlitBlendMod.width,
SDLTest_imageBlitBlendMod.height, SDLTest_imageBlitBlendMod.height,
SDLTest_imageBlitBlendMod.bytes_per_pixel * 8, SDLTest_imageBlitBlendMod.width * SDLTest_imageBlitBlendMod.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitBlendMod.width * SDLTest_imageBlitBlendMod.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }
@ -2429,24 +2390,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitBlendNone = {
*/ */
SDL_Surface *SDLTest_ImageBlitBlendNone() SDL_Surface *SDLTest_ImageBlitBlendNone()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitBlendNone.pixel_data, (void *)SDLTest_imageBlitBlendNone.pixel_data,
SDLTest_imageBlitBlendNone.width, SDLTest_imageBlitBlendNone.width,
SDLTest_imageBlitBlendNone.height, SDLTest_imageBlitBlendNone.height,
SDLTest_imageBlitBlendNone.bytes_per_pixel * 8, SDLTest_imageBlitBlendNone.width * SDLTest_imageBlitBlendNone.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitBlendNone.width * SDLTest_imageBlitBlendNone.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }
@ -2976,24 +2924,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imageBlitBlendAll = {
*/ */
SDL_Surface *SDLTest_ImageBlitBlendAll() SDL_Surface *SDLTest_ImageBlitBlendAll()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageBlitBlendAll.pixel_data, (void *)SDLTest_imageBlitBlendAll.pixel_data,
SDLTest_imageBlitBlendAll.width, SDLTest_imageBlitBlendAll.width,
SDLTest_imageBlitBlendAll.height, SDLTest_imageBlitBlendAll.height,
SDLTest_imageBlitBlendAll.bytes_per_pixel * 8, SDLTest_imageBlitBlendAll.width * SDLTest_imageBlitBlendAll.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imageBlitBlendAll.width * SDLTest_imageBlitBlendAll.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }

16
src/test/SDL_test_imageFace.c
View File

@ -223,24 +223,12 @@ static const SDLTest_SurfaceImage_t SDLTest_imageFace = {
*/ */
SDL_Surface *SDLTest_ImageFace() SDL_Surface *SDLTest_ImageFace()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imageFace.pixel_data, (void *)SDLTest_imageFace.pixel_data,
SDLTest_imageFace.width, SDLTest_imageFace.width,
SDLTest_imageFace.height, SDLTest_imageFace.height,
SDLTest_imageFace.bytes_per_pixel * 8,
SDLTest_imageFace.width * SDLTest_imageFace.bytes_per_pixel, SDLTest_imageFace.width * SDLTest_imageFace.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN) SDL_PIXELFORMAT_RGBA32);
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }

17
src/test/SDL_test_imagePrimitives.c
View File

@ -504,24 +504,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imagePrimitives = {
*/ */
SDL_Surface *SDLTest_ImagePrimitives() SDL_Surface *SDLTest_ImagePrimitives()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imagePrimitives.pixel_data, (void *)SDLTest_imagePrimitives.pixel_data,
SDLTest_imagePrimitives.width, SDLTest_imagePrimitives.width,
SDLTest_imagePrimitives.height, SDLTest_imagePrimitives.height,
SDLTest_imagePrimitives.bytes_per_pixel * 8, SDLTest_imagePrimitives.width * SDLTest_imagePrimitives.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imagePrimitives.width * SDLTest_imagePrimitives.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }

17
src/test/SDL_test_imagePrimitivesBlend.c
View File

@ -677,24 +677,11 @@ static const SDLTest_SurfaceImage_t SDLTest_imagePrimitivesBlend = {
*/ */
SDL_Surface *SDLTest_ImagePrimitivesBlend() SDL_Surface *SDLTest_ImagePrimitivesBlend()
{ {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom( SDL_Surface *surface = SDL_CreateSurfaceFrom(
(void *)SDLTest_imagePrimitivesBlend.pixel_data, (void *)SDLTest_imagePrimitivesBlend.pixel_data,
SDLTest_imagePrimitivesBlend.width, SDLTest_imagePrimitivesBlend.width,
SDLTest_imagePrimitivesBlend.height, SDLTest_imagePrimitivesBlend.height,
SDLTest_imagePrimitivesBlend.bytes_per_pixel * 8, SDLTest_imagePrimitivesBlend.width * SDLTest_imagePrimitivesBlend.bytes_per_pixel, SDL_PIXELFORMAT_RGB24);
SDLTest_imagePrimitivesBlend.width * SDLTest_imagePrimitivesBlend.bytes_per_pixel,
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
0xff000000, /* Red bit mask. */
0x00ff0000, /* Green bit mask. */
0x0000ff00, /* Blue bit mask. */
0x000000ff /* Alpha bit mask. */
#else
0x000000ff, /* Red bit mask. */
0x0000ff00, /* Green bit mask. */
0x00ff0000, /* Blue bit mask. */
0xff000000 /* Alpha bit mask. */
#endif
);
return surface; return surface;
} }

21
src/video/SDL_bmp.c
View File

@ -383,16 +383,19 @@ SDL_LoadBMP_RW(SDL_RWops *src, int freesrc)
switch (biBitCount) { switch (biBitCount) {
case 15: case 15:
case 16: case 16:
/* SDL_PIXELFORMAT_RGB555 or SDL_PIXELFORMAT_ARGB1555 if Amask */
Rmask = 0x7C00; Rmask = 0x7C00;
Gmask = 0x03E0; Gmask = 0x03E0;
Bmask = 0x001F; Bmask = 0x001F;
break; break;
case 24: case 24:
#if SDL_BYTEORDER == SDL_BIG_ENDIAN #if SDL_BYTEORDER == SDL_BIG_ENDIAN
/* SDL_PIXELFORMAT_RGB24 */
Rmask = 0x000000FF; Rmask = 0x000000FF;
Gmask = 0x0000FF00; Gmask = 0x0000FF00;
Bmask = 0x00FF0000; Bmask = 0x00FF0000;
#else #else
/* SDL_PIXELFORMAT_BGR24 */
Rmask = 0x00FF0000; Rmask = 0x00FF0000;
Gmask = 0x0000FF00; Gmask = 0x0000FF00;
Bmask = 0x000000FF; Bmask = 0x000000FF;
@ -401,6 +404,7 @@ SDL_LoadBMP_RW(SDL_RWops *src, int freesrc)
case 32: case 32:
/* We don't know if this has alpha channel or not */ /* We don't know if this has alpha channel or not */
correctAlpha = SDL_TRUE; correctAlpha = SDL_TRUE;
/* SDL_PIXELFORMAT_RGBA8888 */
Amask = 0xFF000000; Amask = 0xFF000000;
Rmask = 0x00FF0000; Rmask = 0x00FF0000;
Gmask = 0x0000FF00; Gmask = 0x0000FF00;
@ -419,12 +423,17 @@ SDL_LoadBMP_RW(SDL_RWops *src, int freesrc)
} }
/* Create a compatible surface, note that the colors are RGB ordered */ /* Create a compatible surface, note that the colors are RGB ordered */
surface = {
SDL_CreateRGBSurface(biWidth, biHeight, biBitCount, Rmask, Gmask, Uint32 format;
Bmask, Amask);
if (surface == NULL) { /* Get the pixel format */
was_error = SDL_TRUE; format = SDL_MasksToPixelFormatEnum(biBitCount, Rmask, Gmask, Bmask, Amask);
goto done; surface = SDL_CreateSurface(biWidth, biHeight, format);
if (surface == NULL) {
was_error = SDL_TRUE;
goto done;
}
} }
/* Load the palette, if any */ /* Load the palette, if any */

92
src/video/SDL_surface.c
View File

@ -72,7 +72,7 @@ SDL_CalculatePitch(Uint32 format, size_t width, SDL_bool minimal)
* enum SDL_PIXELFORMAT_* format * enum SDL_PIXELFORMAT_* format
*/ */
SDL_Surface * SDL_Surface *
SDL_CreateRGBSurfaceWithFormat(int width, int height, Uint32 format) SDL_CreateSurface(int width, int height, Uint32 format)
{ {
size_t pitch; size_t pitch;
SDL_Surface *surface; SDL_Surface *surface;
@ -170,82 +170,14 @@ SDL_CreateRGBSurfaceWithFormat(int width, int height, Uint32 format)
return surface; return surface;
} }
/*
* Create an empty RGB surface of the appropriate depth
*/
SDL_Surface *
SDL_CreateRGBSurface(int width, int height, int depth,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
{
Uint32 format;
/* Get the pixel format */
format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
if (format == SDL_PIXELFORMAT_UNKNOWN) {
SDL_SetError("Unknown pixel format");
return NULL;
}
return SDL_CreateRGBSurfaceWithFormat(width, height, format);
}
/*
* Create an RGB surface from an existing memory buffer
*/
SDL_Surface *
SDL_CreateRGBSurfaceFrom(void *pixels,
int width, int height, int depth, int pitch,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask,
Uint32 Amask)
{
SDL_Surface *surface;
Uint32 format;
size_t minimalPitch;
if (width < 0) {
SDL_InvalidParamError("width");
return NULL;
}
if (height < 0) {
SDL_InvalidParamError("height");
return NULL;
}
format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
if (format == SDL_PIXELFORMAT_UNKNOWN) {
SDL_SetError("Unknown pixel format");
return NULL;
}
minimalPitch = SDL_CalculatePitch(format, width, SDL_TRUE);
if (pitch < 0 || (pitch > 0 && ((size_t)pitch) < minimalPitch)) {
SDL_InvalidParamError("pitch");
return NULL;
}
surface = SDL_CreateRGBSurfaceWithFormat(0, 0, format);
if (surface != NULL) {
surface->flags |= SDL_PREALLOC;
surface->pixels = pixels;
surface->w = width;
surface->h = height;
surface->pitch = pitch;
SDL_SetClipRect(surface, NULL);
}
return surface;
}
/* /*
* Create an RGB surface from an existing memory buffer using the given given * Create an RGB surface from an existing memory buffer using the given given
* enum SDL_PIXELFORMAT_* format * enum SDL_PIXELFORMAT_* format
*/ */
SDL_Surface * SDL_Surface *
SDL_CreateRGBSurfaceWithFormatFrom(void *pixels, SDL_CreateSurfaceFrom(void *pixels,
int width, int height, int pitch, int width, int height, int pitch,
Uint32 format) Uint32 format)
{ {
SDL_Surface *surface; SDL_Surface *surface;
size_t minimalPitch; size_t minimalPitch;
@ -267,7 +199,7 @@ SDL_CreateRGBSurfaceWithFormatFrom(void *pixels,
return NULL; return NULL;
} }
surface = SDL_CreateRGBSurfaceWithFormat(0, 0, format); surface = SDL_CreateSurface(0, 0, format);
if (surface != NULL) { if (surface != NULL) {
surface->flags |= SDL_PREALLOC; surface->flags |= SDL_PREALLOC;
surface->pixels = pixels; surface->pixels = pixels;
@ -1027,7 +959,7 @@ int SDL_PrivateLowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect,
} else { } else {
fmt = SDL_PIXELFORMAT_ARGB8888; fmt = SDL_PIXELFORMAT_ARGB8888;
} }
tmp1 = SDL_CreateRGBSurfaceWithFormat(src->w, src->h, fmt); tmp1 = SDL_CreateSurface(src->w, src->h, fmt);
SDL_LowerBlit(src, srcrect, tmp1, &tmprect); SDL_LowerBlit(src, srcrect, tmp1, &tmprect);
srcrect2.x = 0; srcrect2.x = 0;
@ -1042,7 +974,7 @@ int SDL_PrivateLowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect,
/* Intermediate scaling */ /* Intermediate scaling */
if (is_complex_copy_flags || src->format->format != dst->format->format) { if (is_complex_copy_flags || src->format->format != dst->format->format) {
SDL_Rect tmprect; SDL_Rect tmprect;
SDL_Surface *tmp2 = SDL_CreateRGBSurfaceWithFormat(dstrect->w, dstrect->h, src->format->format); SDL_Surface *tmp2 = SDL_CreateSurface(dstrect->w, dstrect->h, src->format->format);
SDL_SoftStretchLinear(src, &srcrect2, tmp2, NULL); SDL_SoftStretchLinear(src, &srcrect2, tmp2, NULL);
SDL_SetSurfaceColorMod(tmp2, r, g, b); SDL_SetSurfaceColorMod(tmp2, r, g, b);
@ -1156,10 +1088,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
} }
/* Create a new surface with the desired format */ /* Create a new surface with the desired format */
convert = SDL_CreateRGBSurface(surface->w, surface->h, convert = SDL_CreateSurface(surface->w, surface->h, format->format);
format->BitsPerPixel, format->Rmask,
format->Gmask, format->Bmask,
format->Amask);
if (convert == NULL) { if (convert == NULL) {
return NULL; return NULL;
} }
@ -1300,10 +1229,7 @@ SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format)
int converted_colorkey = 0; int converted_colorkey = 0;
/* Create a dummy surface to get the colorkey converted */ /* Create a dummy surface to get the colorkey converted */
tmp = SDL_CreateRGBSurface(1, 1, tmp = SDL_CreateSurface(1, 1, surface->format->format);
surface->format->BitsPerPixel, surface->format->Rmask,
surface->format->Gmask, surface->format->Bmask,
surface->format->Amask);
/* Share the palette, if any */ /* Share the palette, if any */
if (surface->format->palette) { if (surface->format->palette) {

8
src/video/SDL_video.c
View File

@ -2556,8 +2556,6 @@ static SDL_Surface *SDL_CreateWindowFramebuffer(SDL_Window *window)
Uint32 format = 0; Uint32 format = 0;
void *pixels = NULL; void *pixels = NULL;
int pitch = 0; int pitch = 0;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
SDL_bool created_framebuffer = SDL_FALSE; SDL_bool created_framebuffer = SDL_FALSE;
/* This will switch the video backend from using a software surface to /* This will switch the video backend from using a software surface to
@ -2633,11 +2631,7 @@ static SDL_Surface *SDL_CreateWindowFramebuffer(SDL_Window *window)
return window->surface; return window->surface;
} }
if (!SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { return SDL_CreateSurfaceFrom(pixels, window->w, window->h, pitch, format);
return NULL;
}
return SDL_CreateRGBSurfaceFrom(pixels, window->w, window->h, bpp, pitch, Rmask, Gmask, Bmask, Amask);
} }
SDL_Surface * SDL_Surface *

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

@ -118,7 +118,7 @@ static void Android_FreeCursor(SDL_Cursor *cursor)
static SDL_Cursor *Android_CreateEmptyCursor() static SDL_Cursor *Android_CreateEmptyCursor()
{ {
if (empty_cursor == NULL) { if (empty_cursor == NULL) {
SDL_Surface *empty_surface = SDL_CreateRGBSurfaceWithFormat(1, 1, SDL_PIXELFORMAT_ARGB8888); SDL_Surface *empty_surface = SDL_CreateSurface(1, 1, SDL_PIXELFORMAT_ARGB8888);
if (empty_surface) { if (empty_surface) {
SDL_memset(empty_surface->pixels, 0, empty_surface->h * empty_surface->pitch); SDL_memset(empty_surface->pixels, 0, empty_surface->h * empty_surface->pitch);
empty_cursor = Android_CreateCursor(empty_surface, 0, 0); empty_cursor = Android_CreateCursor(empty_surface, 0, 0);

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

@ -38,7 +38,7 @@ int SDL_DUMMY_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format,
/* Create a new one */ /* Create a new one */
SDL_GetWindowSize(window, &w, &h); SDL_GetWindowSize(window, &w, &h);
surface = SDL_CreateRGBSurfaceWithFormat(w, h, surface_format); surface = SDL_CreateSurface(w, h, surface_format);
if (surface == NULL) { if (surface == NULL) {
return -1; return -1;
} }

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

@ -32,8 +32,6 @@ int Emscripten_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format
SDL_Surface *surface; SDL_Surface *surface;
const Uint32 surface_format = SDL_PIXELFORMAT_BGR888; const Uint32 surface_format = SDL_PIXELFORMAT_BGR888;
int w, h; int w, h;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
/* Free the old framebuffer surface */ /* Free the old framebuffer surface */
SDL_WindowData *data = (SDL_WindowData *)window->driverdata; SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
@ -41,10 +39,9 @@ int Emscripten_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format
SDL_FreeSurface(surface); SDL_FreeSurface(surface);
/* Create a new one */ /* Create a new one */
SDL_PixelFormatEnumToMasks(surface_format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
SDL_GetWindowSize(window, &w, &h); SDL_GetWindowSize(window, &w, &h);
surface = SDL_CreateRGBSurface(w, h, bpp, Rmask, Gmask, Bmask, Amask); surface = SDL_CreateSurface(w, h, surface_format);
if (surface == NULL) { if (surface == NULL) {
return -1; return -1;
} }

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

@ -68,11 +68,9 @@ FreePreviousWindowFramebuffer(SDL_Window *window)
SDL_FORCE_INLINE SDL_Surface * SDL_FORCE_INLINE SDL_Surface *
CreateNewWindowFramebuffer(SDL_Window *window) CreateNewWindowFramebuffer(SDL_Window *window)
{ {
int w, h, bpp; int w, h;
Uint32 Rmask, Gmask, Bmask, Amask;
SDL_PixelFormatEnumToMasks(FRAMEBUFFER_FORMAT, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
SDL_GetWindowSize(window, &w, &h); SDL_GetWindowSize(window, &w, &h);
return SDL_CreateRGBSurface(w, h, bpp, Rmask, Gmask, Bmask, Amask); return SDL_CreateSurface(w, h, FRAMEBUFFER_FORMAT);
} }
int SDL_N3DS_UpdateWindowFramebuffer(_THIS, SDL_Window *window, const SDL_Rect *rects, int numrects) int SDL_N3DS_UpdateWindowFramebuffer(_THIS, SDL_Window *window, const SDL_Rect *rects, int numrects)

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

@ -56,7 +56,7 @@ int SDL_NGAGE_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format,
/* Create a new one */ /* Create a new one */
SDL_GetWindowSize(window, &w, &h); SDL_GetWindowSize(window, &w, &h);
surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 0, surface_format); surface = SDL_CreateSurface(w, h, surface_format);
if (surface == NULL) { if (surface == NULL) {
return -1; return -1;
} }

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

@ -38,7 +38,7 @@ int SDL_OFFSCREEN_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *for
/* Create a new one */ /* Create a new one */
SDL_GetWindowSize(window, &w, &h); SDL_GetWindowSize(window, &w, &h);
surface = SDL_CreateRGBSurfaceWithFormat(w, h, surface_format); surface = SDL_CreateSurface(w, h, surface_format);
if (surface == NULL) { if (surface == NULL) {
return -1; return -1;
} }

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

@ -170,7 +170,7 @@ static SDL_Cursor *WIN_CreateCursor(SDL_Surface *surface, int hot_x, int hot_y)
static SDL_Cursor *WIN_CreateBlankCursor() static SDL_Cursor *WIN_CreateBlankCursor()
{ {
SDL_Cursor *cursor = NULL; SDL_Cursor *cursor = NULL;
SDL_Surface *surface = SDL_CreateRGBSurfaceWithFormat(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_FreeSurface(surface);

60
test/testautomation_render.c
View File

@ -10,11 +10,8 @@
#define TESTRENDER_SCREEN_W 80 #define TESTRENDER_SCREEN_W 80
#define TESTRENDER_SCREEN_H 60 #define TESTRENDER_SCREEN_H 60
#define RENDER_COMPARE_FORMAT SDL_PIXELFORMAT_ARGB8888 #define RENDER_COMPARE_FORMAT SDL_PIXELFORMAT_ARGB8888
#define RENDER_COMPARE_AMASK 0xff000000 /**< Alpha bit mask. */
#define RENDER_COMPARE_RMASK 0x00ff0000 /**< Red bit mask. */
#define RENDER_COMPARE_GMASK 0x0000ff00 /**< Green bit mask. */
#define RENDER_COMPARE_BMASK 0x000000ff /**< Blue bit mask. */
#define ALLOWABLE_ERROR_OPAQUE 0 #define ALLOWABLE_ERROR_OPAQUE 0
#define ALLOWABLE_ERROR_BLENDED 64 #define ALLOWABLE_ERROR_BLENDED 64
@ -1044,44 +1041,43 @@ _hasTexAlpha(void)
* *
* \sa * \sa
* http://wiki.libsdl.org/SDL_RenderReadPixels * http://wiki.libsdl.org/SDL_RenderReadPixels
* http://wiki.libsdl.org/SDL_CreateRGBSurfaceFrom * http://wiki.libsdl.org/SDL_CreateSurfaceFrom
* http://wiki.libsdl.org/SDL_FreeSurface * http://wiki.libsdl.org/SDL_FreeSurface
*/ */
static void static void
_compare(SDL_Surface *referenceSurface, int allowable_error) _compare(SDL_Surface *referenceSurface, int allowable_error)
{ {
int result; int result;
SDL_Rect rect; SDL_Rect rect;
Uint8 *pixels; Uint8 *pixels;
SDL_Surface *testSurface; SDL_Surface *testSurface;
/* Read pixels. */ /* Read pixels. */
pixels = (Uint8 *)SDL_malloc(4 * TESTRENDER_SCREEN_W * TESTRENDER_SCREEN_H); pixels = (Uint8 *)SDL_malloc(4*TESTRENDER_SCREEN_W*TESTRENDER_SCREEN_H);
SDLTest_AssertCheck(pixels != NULL, "Validate allocated temp pixel buffer"); SDLTest_AssertCheck(pixels != NULL, "Validate allocated temp pixel buffer");
if (pixels == NULL) { if (pixels == NULL) {
return; return;
} }
/* Explicitly specify the rect in case the window isn't the expected size... */ /* Explicitly specify the rect in case the window isn't the expected size... */
rect.x = 0; rect.x = 0;
rect.y = 0; rect.y = 0;
rect.w = TESTRENDER_SCREEN_W; rect.w = TESTRENDER_SCREEN_W;
rect.h = TESTRENDER_SCREEN_H; rect.h = TESTRENDER_SCREEN_H;
result = SDL_RenderReadPixels(renderer, &rect, RENDER_COMPARE_FORMAT, pixels, 80 * 4); result = SDL_RenderReadPixels(renderer, &rect, RENDER_COMPARE_FORMAT, pixels, 80*4 );
SDLTest_AssertCheck(result == 0, "Validate result from SDL_RenderReadPixels, expected: 0, got: %i", result); SDLTest_AssertCheck(result == 0, "Validate result from SDL_RenderReadPixels, expected: 0, got: %i", result);
/* Create surface. */ /* Create surface. */
testSurface = SDL_CreateRGBSurfaceFrom(pixels, TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, 32, TESTRENDER_SCREEN_W * 4, testSurface = SDL_CreateSurfaceFrom(pixels, TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, TESTRENDER_SCREEN_W*4, RENDER_COMPARE_FORMAT);
RENDER_COMPARE_RMASK, RENDER_COMPARE_GMASK, RENDER_COMPARE_BMASK, RENDER_COMPARE_AMASK); SDLTest_AssertCheck(testSurface != NULL, "Verify result from SDL_CreateSurfaceFrom is not NULL");
SDLTest_AssertCheck(testSurface != NULL, "Verify result from SDL_CreateRGBSurfaceFrom is not NULL");
/* Compare surface. */ /* Compare surface. */
result = SDLTest_CompareSurfaces(testSurface, referenceSurface, allowable_error); result = SDLTest_CompareSurfaces( testSurface, referenceSurface, allowable_error );
SDLTest_AssertCheck(result == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", result); SDLTest_AssertCheck(result == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", result);
/* Clean up. */ /* Clean up. */
SDL_free(pixels); SDL_free(pixels);
SDL_FreeSurface(testSurface); SDL_FreeSurface(testSurface);
} }
/** /**

82
test/testautomation_surface.c
View File

@ -40,21 +40,9 @@ void _surfaceSetUp(void *arg)
int result; int result;
SDL_BlendMode blendMode = SDL_BLENDMODE_NONE; SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
SDL_BlendMode currentBlendMode; SDL_BlendMode currentBlendMode;
Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
referenceSurface = SDLTest_ImageBlit(); /* For size info */ referenceSurface = SDLTest_ImageBlit(); /* For size info */
testSurface = SDL_CreateRGBSurface(referenceSurface->w, referenceSurface->h, 32, rmask, gmask, bmask, amask); testSurface = SDL_CreateSurface(referenceSurface->w, referenceSurface->h, SDL_PIXELFORMAT_RGBA32);
SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL"); SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL");
if (testSurface != NULL) { if (testSurface != NULL) {
/* Disable blend mode for target surface */ /* Disable blend mode for target surface */
@ -597,116 +585,116 @@ int surface_testOverflow(void *arg)
SDL_memset(buf, '\0', sizeof(buf)); SDL_memset(buf, '\0', sizeof(buf));
expectedError = "Parameter 'width' is invalid"; expectedError = "Parameter 'width' is invalid";
surface = SDL_CreateRGBSurfaceWithFormat(-3, 100, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurface(-3, 100, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect negative width"); SDLTest_AssertCheck(surface == NULL, "Should detect negative width");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormatFrom(buf, -1, 1, 4, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurfaceFrom(buf, -1, 1, 4, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect negative width"); SDLTest_AssertCheck(surface == NULL, "Should detect negative width");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, -1, 1, 32, 4, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF); surface = SDL_CreateSurfaceFrom(buf, -1, 1, 4, SDL_PIXELFORMAT_RGBA8888);
SDLTest_AssertCheck(surface == NULL, "Should detect negative width"); SDLTest_AssertCheck(surface == NULL, "Should detect negative width");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
expectedError = "Parameter 'height' is invalid"; expectedError = "Parameter 'height' is invalid";
surface = SDL_CreateRGBSurfaceWithFormat(100, -3, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurface(100, -3, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect negative height"); SDLTest_AssertCheck(surface == NULL, "Should detect negative height");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormatFrom(buf, 1, -1, 4, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurfaceFrom(buf, 1, -1, 4, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect negative height"); SDLTest_AssertCheck(surface == NULL, "Should detect negative height");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, 1, -1, 32, 4, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF); surface = SDL_CreateSurfaceFrom(buf, 1, -1, 4, SDL_PIXELFORMAT_RGBA8888);
SDLTest_AssertCheck(surface == NULL, "Should detect negative height"); SDLTest_AssertCheck(surface == NULL, "Should detect negative height");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
expectedError = "Parameter 'pitch' is invalid"; expectedError = "Parameter 'pitch' is invalid";
surface = SDL_CreateRGBSurfaceWithFormatFrom(buf, 4, 1, -1, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurfaceFrom(buf, 4, 1, -1, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect negative pitch"); SDLTest_AssertCheck(surface == NULL, "Should detect negative pitch");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, 1, 1, 32, -1, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF); surface = SDL_CreateSurfaceFrom(buf, 1, 1, -1, SDL_PIXELFORMAT_RGBA8888);
SDLTest_AssertCheck(surface == NULL, "Should detect negative pitch"); SDLTest_AssertCheck(surface == NULL, "Should detect negative pitch");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
/* Less than 1 byte per pixel: the pitch can legitimately be less than /* Less than 1 byte per pixel: the pitch can legitimately be less than
* the width, but it must be enough to hold the appropriate number of * the width, but it must be enough to hold the appropriate number of
* bits per pixel. SDL_PIXELFORMAT_INDEX4* needs 1 byte per 2 pixels. */ * bits per pixel. SDL_PIXELFORMAT_INDEX4LSB* needs 1 byte per 2 pixels. */
surface = SDL_CreateRGBSurfaceWithFormatFrom(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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceFrom(buf, 6, 1, 4, 3, 0, 0, 0, 0); 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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceWithFormatFrom(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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, 7, 1, 4, 3, 0, 0, 0, 0); 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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormatFrom(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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceFrom(buf, 7, 1, 4, 4, 0, 0, 0, 0); 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_FreeSurface(surface);
/* SDL_PIXELFORMAT_INDEX1* needs 1 byte per 8 pixels. */ /* SDL_PIXELFORMAT_INDEX1* needs 1 byte per 8 pixels. */
surface = SDL_CreateRGBSurfaceWithFormatFrom(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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceFrom(buf, 16, 1, 1, 2, 0, 0, 0, 0); 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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceWithFormatFrom(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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, 17, 1, 1, 2, 0, 0, 0, 0); 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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormatFrom(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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceFrom(buf, 17, 1, 1, 3, 0, 0, 0, 0); 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_FreeSurface(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_CreateRGBSurfaceWithFormatFrom(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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceFrom(buf, 5, 1, 8, 5, 0, 0, 0, 0); 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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceWithFormatFrom(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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, 6, 1, 8, 5, 0, 0, 0, 0); surface = SDL_CreateSurfaceFrom(buf, 6, 1, 5, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp"); SDLTest_AssertCheck(surface == NULL, "Should detect pitch < width * bpp");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
@ -714,39 +702,39 @@ int surface_testOverflow(void *arg)
/* Everything else requires more than 1 byte per pixel, and rounds up /* Everything else requires more than 1 byte per pixel, and rounds up
* each pixel to an integer number of bytes (e.g. RGB555 is really * each pixel to an integer number of bytes (e.g. RGB555 is really
* XRGB1555, with 1 bit per pixel wasted). */ * XRGB1555, with 1 bit per pixel wasted). */
surface = SDL_CreateRGBSurfaceWithFormatFrom(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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceFrom(buf, 3, 1, 15, 6, 0, 0, 0, 0); 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_FreeSurface(surface);
surface = SDL_CreateRGBSurfaceWithFormatFrom(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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceFrom(buf, 4, 1, 15, 6, 0, 0, 0, 0); surface = SDL_CreateSurfaceFrom(buf, 4, 1, 6, SDL_PIXELFORMAT_XRGB1555);
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");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
if (sizeof(size_t) == 4 && sizeof(int) >= 4) { if (sizeof(size_t) == 4 && sizeof(int) >= 4) {
expectedError = "Out of memory"; expectedError = "Out of memory";
surface = SDL_CreateRGBSurfaceWithFormat(SDL_MAX_SINT32, 1, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurface(SDL_MAX_SINT32, 1, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width + alignment"); SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width + alignment");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormat(SDL_MAX_SINT32 / 2, 1, SDL_PIXELFORMAT_ARGB8888); surface = SDL_CreateSurface(SDL_MAX_SINT32 / 2, 1, SDL_PIXELFORMAT_ARGB8888);
SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width * bytes per pixel"); SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width * bytes per pixel");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormat((1 << 29) - 1, (1 << 29) - 1, SDL_PIXELFORMAT_INDEX8); surface = SDL_CreateSurface((1 << 29) - 1, (1 << 29) - 1, SDL_PIXELFORMAT_INDEX8);
SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width * height"); SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width * height");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());
surface = SDL_CreateRGBSurfaceWithFormat((1 << 15) + 1, (1 << 15) + 1, SDL_PIXELFORMAT_ARGB8888); surface = SDL_CreateSurface((1 << 15) + 1, (1 << 15) + 1, SDL_PIXELFORMAT_ARGB8888);
SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width * height * bytes per pixel"); SDLTest_AssertCheck(surface == NULL, "Should detect overflow in width * height * bytes per pixel");
SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0, SDLTest_AssertCheck(SDL_strcmp(SDL_GetError(), expectedError) == 0,
"Expected \"%s\", got \"%s\"", expectedError, SDL_GetError()); "Expected \"%s\", got \"%s\"", expectedError, SDL_GetError());

11
test/testoffscreen.c
View File

@ -50,17 +50,16 @@ void draw()
void save_surface_to_bmp() void save_surface_to_bmp()
{ {
SDL_Surface *surface; SDL_Surface* surface;
Uint32 r_mask, g_mask, b_mask, a_mask;
Uint32 pixel_format; Uint32 pixel_format;
char file[128]; char file[128];
int bbp;
pixel_format = SDL_GetWindowPixelFormat(window); pixel_format = SDL_GetWindowPixelFormat(window);
SDL_PixelFormatEnumToMasks(pixel_format, &bbp, &r_mask, &g_mask, &b_mask, &a_mask);
surface = SDL_CreateRGBSurface(width, height, bbp, r_mask, g_mask, b_mask, a_mask); surface = SDL_CreateSurface(width, height, pixel_format);
SDL_RenderReadPixels(renderer, NULL, pixel_format, (void *)surface->pixels, surface->pitch);
SDL_RenderReadPixels(renderer, NULL, pixel_format, (void*)surface->pixels, surface->pitch);
SDL_snprintf(file, sizeof(file), "SDL_window%" SDL_PRIs32 "-%8.8d.bmp", SDL_snprintf(file, sizeof(file), "SDL_window%" SDL_PRIs32 "-%8.8d.bmp",
SDL_GetWindowID(window), ++frame_number); SDL_GetWindowID(window), ++frame_number);

10
test/testshader.c
View File

@ -322,15 +322,7 @@ SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
texcoord[2] = (GLfloat)surface->w / w; /* Max X */ texcoord[2] = (GLfloat)surface->w / w; /* Max X */
texcoord[3] = (GLfloat)surface->h / h; /* Max Y */ texcoord[3] = (GLfloat)surface->h / h; /* Max Y */
image = SDL_CreateRGBSurface(w, h, 32, image = SDL_CreateSurface(w, h, SDL_PIXELFORMAT_RGBA32);
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
0x000000FF,
0x0000FF00, 0x00FF0000, 0xFF000000
#else
0xFF000000,
0x00FF0000, 0x0000FF00, 0x000000FF
#endif
);
if (image == NULL) { if (image == NULL) {
return 0; return 0;
} }

4
test/testyuv.c
View File

@ -25,7 +25,7 @@ static SDL_bool is_packed_yuv_format(Uint32 format)
/* Create a surface with a good pattern for verifying YUV conversion */ /* Create a surface with a good pattern for verifying YUV conversion */
static SDL_Surface *generate_test_pattern(int pattern_size) static SDL_Surface *generate_test_pattern(int pattern_size)
{ {
SDL_Surface *pattern = SDL_CreateRGBSurfaceWithFormat(pattern_size, pattern_size, SDL_PIXELFORMAT_RGB24); SDL_Surface *pattern = SDL_CreateSurface(pattern_size, pattern_size, SDL_PIXELFORMAT_RGB24);
if (pattern) { if (pattern) {
int i, x, y; int i, x, y;
@ -334,7 +334,7 @@ int main(int argc, char **argv)
0, 100); 0, 100);
pitch = CalculateYUVPitch(yuv_format, original->w); pitch = CalculateYUVPitch(yuv_format, original->w);
converted = SDL_CreateRGBSurfaceWithFormat(original->w, original->h, rgb_format); converted = SDL_CreateSurface(original->w, original->h, rgb_format);
if (converted == NULL) { if (converted == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create converted surface: %s\n", SDL_GetError()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create converted surface: %s\n", SDL_GetError());
return 3; return 3;