SDL  2.0
SDL_surface.h File Reference
#include "SDL_stdinc.h"
#include "SDL_pixels.h"
#include "SDL_rect.h"
#include "SDL_blendmode.h"
#include "SDL_rwops.h"
#include "begin_code.h"
#include "close_code.h"
+ Include dependency graph for SDL_surface.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SDL_Surface
 A collection of pixels used in software blitting. More...
 

Macros

#define SDL_MUSTLOCK(S)   (((S)->flags & SDL_RLEACCEL) != 0)
 
#define SDL_LoadBMP(file)   SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
 
#define SDL_SaveBMP(surface, file)   SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
 
#define SDL_BlitSurface   SDL_UpperBlit
 
#define SDL_BlitScaled   SDL_UpperBlitScaled
 
Surface flags

These are the currently supported flags for the SDL_Surface.

Used internally (read-only).

#define SDL_SWSURFACE   0
 
#define SDL_PREALLOC   0x00000001
 
#define SDL_RLEACCEL   0x00000002
 
#define SDL_DONTFREE   0x00000004
 

Typedefs

typedef int(* SDL_blit )(struct SDL_Surface *src, SDL_Rect *srcrect, struct SDL_Surface *dst, SDL_Rect *dstrect)
 The type of function used for surface blitting functions. More...
 

Functions

SDL_SurfaceSDL_CreateRGBSurface (Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
 
SDL_SurfaceSDL_CreateRGBSurfaceWithFormat (Uint32 flags, int width, int height, int depth, Uint32 format)
 
SDL_SurfaceSDL_CreateRGBSurfaceFrom (void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
 
SDL_SurfaceSDL_CreateRGBSurfaceWithFormatFrom (void *pixels, int width, int height, int depth, int pitch, Uint32 format)
 
void SDL_FreeSurface (SDL_Surface *surface)
 
int SDL_SetSurfacePalette (SDL_Surface *surface, SDL_Palette *palette)
 Set the palette used by a surface. More...
 
int SDL_LockSurface (SDL_Surface *surface)
 Sets up a surface for directly accessing the pixels. More...
 
void SDL_UnlockSurface (SDL_Surface *surface)
 
SDL_SurfaceSDL_LoadBMP_RW (SDL_RWops *src, int freesrc)
 
int SDL_SaveBMP_RW (SDL_Surface *surface, SDL_RWops *dst, int freedst)
 
int SDL_SetSurfaceRLE (SDL_Surface *surface, int flag)
 Sets the RLE acceleration hint for a surface. More...
 
int SDL_SetColorKey (SDL_Surface *surface, int flag, Uint32 key)
 Sets the color key (transparent pixel) in a blittable surface. More...
 
int SDL_GetColorKey (SDL_Surface *surface, Uint32 *key)
 Gets the color key (transparent pixel) in a blittable surface. More...
 
int SDL_SetSurfaceColorMod (SDL_Surface *surface, Uint8 r, Uint8 g, Uint8 b)
 Set an additional color value used in blit operations. More...
 
int SDL_GetSurfaceColorMod (SDL_Surface *surface, Uint8 *r, Uint8 *g, Uint8 *b)
 Get the additional color value used in blit operations. More...
 
int SDL_SetSurfaceAlphaMod (SDL_Surface *surface, Uint8 alpha)
 Set an additional alpha value used in blit operations. More...
 
int SDL_GetSurfaceAlphaMod (SDL_Surface *surface, Uint8 *alpha)
 Get the additional alpha value used in blit operations. More...
 
int SDL_SetSurfaceBlendMode (SDL_Surface *surface, SDL_BlendMode blendMode)
 Set the blend mode used for blit operations. More...
 
int SDL_GetSurfaceBlendMode (SDL_Surface *surface, SDL_BlendMode *blendMode)
 Get the blend mode used for blit operations. More...
 
SDL_bool SDL_SetClipRect (SDL_Surface *surface, const SDL_Rect *rect)
 
void SDL_GetClipRect (SDL_Surface *surface, SDL_Rect *rect)
 
SDL_SurfaceSDL_DuplicateSurface (SDL_Surface *surface)
 
SDL_SurfaceSDL_ConvertSurface (SDL_Surface *src, const SDL_PixelFormat *fmt, Uint32 flags)
 
SDL_SurfaceSDL_ConvertSurfaceFormat (SDL_Surface *src, Uint32 pixel_format, Uint32 flags)
 
int SDL_ConvertPixels (int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
 Copy a block of pixels of one format to another format. More...
 
int SDL_FillRect (SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
 
int SDL_FillRects (SDL_Surface *dst, const SDL_Rect *rects, int count, Uint32 color)
 
int SDL_UpperBlit (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
 
int SDL_LowerBlit (SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
 
int SDL_SoftStretch (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, const SDL_Rect *dstrect)
 Perform a fast, low quality, stretch blit between two surfaces of the same pixel format. More...
 
int SDL_UpperBlitScaled (SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
 
int SDL_LowerBlitScaled (SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
 

Detailed Description

Header file for SDL_Surface definition and management functions.

Definition in file SDL_surface.h.

Macro Definition Documentation

#define SDL_BlitScaled   SDL_UpperBlitScaled

Definition at line 494 of file SDL_surface.h.

Referenced by SW_RenderCopy(), and SW_RenderCopyEx().

#define SDL_BlitSurface   SDL_UpperBlit

Performs a fast blit from the source surface to the destination surface.

This assumes that the source and destination rectangles are the same size. If either srcrect or dstrect are NULL, the entire surface (src or dst) is copied. The final blit rectangles are saved in srcrect and dstrect after all clipping is performed.

Returns
If the blit is successful, it returns 0, otherwise it returns -1.

The blit function should not be called on a locked surface.

The blit semantics for surfaces with and without blending and colorkey are defined as follows:

RGBA->RGB:
  Source surface blend mode set to SDL_BLENDMODE_BLEND:
    alpha-blend (using the source alpha-channel and per-surface alpha)
    SDL_SRCCOLORKEY ignored.
  Source surface blend mode set to SDL_BLENDMODE_NONE:
    copy RGB.
    if SDL_SRCCOLORKEY set, only copy the pixels matching the
    RGB values of the source color key, ignoring alpha in the
    comparison.

RGB->RGBA:
  Source surface blend mode set to SDL_BLENDMODE_BLEND:
    alpha-blend (using the source per-surface alpha)
  Source surface blend mode set to SDL_BLENDMODE_NONE:
    copy RGB, set destination alpha to source per-surface alpha value.
  both:
    if SDL_SRCCOLORKEY set, only copy the pixels matching the
    source color key.

RGBA->RGBA:
  Source surface blend mode set to SDL_BLENDMODE_BLEND:
    alpha-blend (using the source alpha-channel and per-surface alpha)
    SDL_SRCCOLORKEY ignored.
  Source surface blend mode set to SDL_BLENDMODE_NONE:
    copy all of RGBA to the destination.
    if SDL_SRCCOLORKEY set, only copy the pixels matching the
    RGB values of the source color key, ignoring alpha in the
    comparison.

RGB->RGB:
  Source surface blend mode set to SDL_BLENDMODE_BLEND:
    alpha-blend (using the source per-surface alpha)
  Source surface blend mode set to SDL_BLENDMODE_NONE:
    copy RGB.
  both:
    if SDL_SRCCOLORKEY set, only copy the pixels matching the
    source color key.

You should call SDL_BlitSurface() unless you know exactly how SDL blitting works internally and how to use the other blit functions.

Definition at line 465 of file SDL_surface.h.

Referenced by _testBlitBlendMode(), SDL_UpperBlitScaled(), SW_RenderCopy(), and SW_RenderCopyEx().

#define SDL_DONTFREE   0x00000004

Surface is referenced internally

Definition at line 55 of file SDL_surface.h.

Referenced by SDL_DestroyWindow(), SDL_FreeSurface(), SDL_GetWindowSurface(), and SDL_RecreateWindow().

#define SDL_LoadBMP (   file)    SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)

Load a surface from a file.

Convenience macro.

Definition at line 189 of file SDL_surface.h.

Referenced by init_color_cursor(), LoadSprite(), LoadTexture(), main(), SDLTest_LoadIcon(), surface_testLoadFailure(), and surface_testSaveLoadBitmap().

#define SDL_MUSTLOCK (   S)    (((S)->flags & SDL_RLEACCEL) != 0)
#define SDL_PREALLOC   0x00000001
#define SDL_SaveBMP (   surface,
  file 
)    SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)

Save a surface to a file.

Convenience macro.

Definition at line 212 of file SDL_surface.h.

Referenced by SDLTest_CompareSurfaces(), SDLTest_ScreenShot(), and surface_testSaveLoadBitmap().

#define SDL_SWSURFACE   0

Just here for compatibility

Definition at line 52 of file SDL_surface.h.

Referenced by _surfaceSetUp(), and SDLTest_DrawCharacter().

Typedef Documentation

typedef int( * SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect, struct SDL_Surface *dst, SDL_Rect *dstrect)

The type of function used for surface blitting functions.

Definition at line 97 of file SDL_surface.h.

Function Documentation

int SDL_ConvertPixels ( int  width,
int  height,
Uint32  src_format,
const void src,
int  src_pitch,
Uint32  dst_format,
void dst,
int  dst_pitch 
)

Copy a block of pixels of one format to another format.

Returns
0 on success, or -1 if there was an error

Definition at line 1112 of file SDL_surface.c.

References SDL_Rect::h, i, rect, SDL_BYTESPERPIXEL, SDL_CreateSurfaceOnStack(), SDL_InvalidParamError, SDL_ISPIXELFORMAT_FOURCC, SDL_LowerBlit(), SDL_memcpy, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_NV12, SDL_PIXELFORMAT_NV21, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_YV12, SDL_PIXELFORMAT_YVYU, SDL_SetError, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

1115 {
1116  SDL_Surface src_surface, dst_surface;
1117  SDL_PixelFormat src_fmt, dst_fmt;
1118  SDL_BlitMap src_blitmap, dst_blitmap;
1119  SDL_Rect rect;
1120  void *nonconst_src = (void *) src;
1121 
1122  /* Check to make sure we are blitting somewhere, so we don't crash */
1123  if (!dst) {
1124  return SDL_InvalidParamError("dst");
1125  }
1126  if (!dst_pitch) {
1127  return SDL_InvalidParamError("dst_pitch");
1128  }
1129 
1130  /* Fast path for same format copy */
1131  if (src_format == dst_format) {
1132  int bpp, i;
1133 
1134  if (SDL_ISPIXELFORMAT_FOURCC(src_format)) {
1135  switch (src_format) {
1136  case SDL_PIXELFORMAT_YUY2:
1137  case SDL_PIXELFORMAT_UYVY:
1138  case SDL_PIXELFORMAT_YVYU:
1139  bpp = 2;
1140  break;
1141  case SDL_PIXELFORMAT_YV12:
1142  case SDL_PIXELFORMAT_IYUV:
1143  case SDL_PIXELFORMAT_NV12:
1144  case SDL_PIXELFORMAT_NV21:
1145  bpp = 1;
1146  break;
1147  default:
1148  return SDL_SetError("Unknown FOURCC pixel format");
1149  }
1150  } else {
1151  bpp = SDL_BYTESPERPIXEL(src_format);
1152  }
1153  width *= bpp;
1154 
1155  for (i = height; i--;) {
1156  SDL_memcpy(dst, src, width);
1157  src = (Uint8*)src + src_pitch;
1158  dst = (Uint8*)dst + dst_pitch;
1159  }
1160 
1161  if (src_format == SDL_PIXELFORMAT_YV12 || src_format == SDL_PIXELFORMAT_IYUV) {
1162  /* U and V planes are a quarter the size of the Y plane */
1163  width /= 2;
1164  height /= 2;
1165  src_pitch /= 2;
1166  dst_pitch /= 2;
1167  for (i = height * 2; i--;) {
1168  SDL_memcpy(dst, src, width);
1169  src = (Uint8*)src + src_pitch;
1170  dst = (Uint8*)dst + dst_pitch;
1171  }
1172  } else if (src_format == SDL_PIXELFORMAT_NV12 || src_format == SDL_PIXELFORMAT_NV21) {
1173  /* U/V plane is half the height of the Y plane */
1174  height /= 2;
1175  for (i = height; i--;) {
1176  SDL_memcpy(dst, src, width);
1177  src = (Uint8*)src + src_pitch;
1178  dst = (Uint8*)dst + dst_pitch;
1179  }
1180  }
1181  return 0;
1182  }
1183 
1184  if (!SDL_CreateSurfaceOnStack(width, height, src_format, nonconst_src,
1185  src_pitch,
1186  &src_surface, &src_fmt, &src_blitmap)) {
1187  return -1;
1188  }
1189  if (!SDL_CreateSurfaceOnStack(width, height, dst_format, dst, dst_pitch,
1190  &dst_surface, &dst_fmt, &dst_blitmap)) {
1191  return -1;
1192  }
1193 
1194  /* Set up the rect and go! */
1195  rect.x = 0;
1196  rect.y = 0;
1197  rect.w = width;
1198  rect.h = height;
1199  return SDL_LowerBlit(&src_surface, &rect, &dst_surface, &rect);
1200 }
GLenum GLenum dst
SDL_Rect rect
Definition: testrelative.c:27
static SDL_INLINE SDL_bool SDL_CreateSurfaceOnStack(int width, int height, Uint32 pixel_format, void *pixels, int pitch, SDL_Surface *surface, SDL_PixelFormat *format, SDL_BlitMap *blitmap)
Definition: SDL_surface.c:1074
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
GLenum src
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:548
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define SDL_memcpy
uint8_t Uint8
Definition: SDL_stdinc.h:157
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
#define SDL_SetError
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
int h
Definition: SDL_rect.h:67
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
SDL_Surface* SDL_ConvertSurface ( SDL_Surface src,
const SDL_PixelFormat fmt,
Uint32  flags 
)

Creates a new surface of the specified format, and then copies and maps the given surface to it so the blit of the converted surface will be as fast as possible. If this function fails, it returns NULL.

The flags parameter is passed to SDL_CreateRGBSurface() and has those semantics. You can also pass SDL_RLEACCEL in the flags parameter and SDL will try to RLE accelerate colorkey and alpha blits in the resulting surface.

Definition at line 899 of file SDL_surface.c.

References SDL_BlitInfo::a, SDL_Color::a, SDL_PixelFormat::Amask, SDL_BlitInfo::b, SDL_Color::b, SDL_PixelFormat::BitsPerPixel, SDL_PixelFormat::Bmask, SDL_PixelFormat::BytesPerPixel, SDL_Surface::clip_rect, SDL_BlitInfo::colorkey, SDL_Palette::colors, SDL_BlitInfo::flags, SDL_Surface::format, SDL_BlitInfo::g, SDL_Color::g, SDL_PixelFormat::Gmask, SDL_Rect::h, SDL_Surface::h, i, SDL_BlitMap::info, SDL_Surface::map, SDL_Palette::ncolors, NULL, SDL_PixelFormat::palette, SDL_Surface::pixels, SDL_BlitInfo::r, SDL_Color::r, SDL_PixelFormat::Rmask, SDL_BLENDMODE_BLEND, SDL_ConvertColorkeyToAlpha(), SDL_COPY_BLEND, SDL_COPY_COLORKEY, SDL_COPY_MODULATE_ALPHA, SDL_COPY_RLE_ALPHAKEY, SDL_COPY_RLE_COLORKEY, SDL_COPY_RLE_DESIRED, SDL_CreateRGBSurface(), SDL_FALSE, SDL_FillRect, SDL_FreeSurface(), SDL_InvalidateMap(), SDL_InvalidParamError, SDL_LowerBlit(), SDL_memcmp, SDL_memcpy, SDL_RLEACCEL, SDL_SetClipRect(), SDL_SetColorKey(), SDL_SetError, SDL_SetSurfaceBlendMode(), SDL_SetSurfacePalette(), SDL_SetSurfaceRLE(), SDL_TRUE, SDL_Rect::w, SDL_Surface::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_ConvertSurfaceFormat(), and SDL_DuplicateSurface().

901 {
902  SDL_Surface *convert;
903  Uint32 copy_flags;
904  SDL_Color copy_color;
905  SDL_Rect bounds;
906 
907  if (!surface) {
908  SDL_InvalidParamError("surface");
909  return NULL;
910  }
911  if (!format) {
912  SDL_InvalidParamError("format");
913  return NULL;
914  }
915 
916  /* Check for empty destination palette! (results in empty image) */
917  if (format->palette != NULL) {
918  int i;
919  for (i = 0; i < format->palette->ncolors; ++i) {
920  if ((format->palette->colors[i].r != 0xFF) ||
921  (format->palette->colors[i].g != 0xFF) ||
922  (format->palette->colors[i].b != 0xFF))
923  break;
924  }
925  if (i == format->palette->ncolors) {
926  SDL_SetError("Empty destination palette");
927  return (NULL);
928  }
929  }
930 
931  /* Create a new surface with the desired format */
932  convert = SDL_CreateRGBSurface(flags, surface->w, surface->h,
933  format->BitsPerPixel, format->Rmask,
934  format->Gmask, format->Bmask,
935  format->Amask);
936  if (convert == NULL) {
937  return (NULL);
938  }
939 
940  /* Copy the palette if any */
941  if (format->palette && convert->format->palette) {
942  SDL_memcpy(convert->format->palette->colors,
943  format->palette->colors,
944  format->palette->ncolors * sizeof(SDL_Color));
945  convert->format->palette->ncolors = format->palette->ncolors;
946  }
947 
948  /* Save the original copy flags */
949  copy_flags = surface->map->info.flags;
950  copy_color.r = surface->map->info.r;
951  copy_color.g = surface->map->info.g;
952  copy_color.b = surface->map->info.b;
953  copy_color.a = surface->map->info.a;
954  surface->map->info.r = 0xFF;
955  surface->map->info.g = 0xFF;
956  surface->map->info.b = 0xFF;
957  surface->map->info.a = 0xFF;
958  surface->map->info.flags = 0;
960 
961  /* Copy over the image data */
962  bounds.x = 0;
963  bounds.y = 0;
964  bounds.w = surface->w;
965  bounds.h = surface->h;
966  SDL_LowerBlit(surface, &bounds, convert, &bounds);
967 
968  /* Clean up the original surface, and update converted surface */
969  convert->map->info.r = copy_color.r;
970  convert->map->info.g = copy_color.g;
971  convert->map->info.b = copy_color.b;
972  convert->map->info.a = copy_color.a;
973  convert->map->info.flags =
974  (copy_flags &
978  surface->map->info.r = copy_color.r;
979  surface->map->info.g = copy_color.g;
980  surface->map->info.b = copy_color.b;
981  surface->map->info.a = copy_color.a;
982  surface->map->info.flags = copy_flags;
984  if (copy_flags & SDL_COPY_COLORKEY) {
985  SDL_bool set_colorkey_by_color = SDL_FALSE;
986 
987  if (surface->format->palette) {
988  if (format->palette &&
989  surface->format->palette->ncolors <= format->palette->ncolors &&
990  (SDL_memcmp(surface->format->palette->colors, format->palette->colors,
991  surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) {
992  /* The palette is identical, just set the same colorkey */
993  SDL_SetColorKey(convert, 1, surface->map->info.colorkey);
994  } else if (format->Amask) {
995  /* The alpha was set in the destination from the palette */
996  } else {
997  set_colorkey_by_color = SDL_TRUE;
998  }
999  } else {
1000  set_colorkey_by_color = SDL_TRUE;
1001  }
1002 
1003  if (set_colorkey_by_color) {
1004  SDL_Surface *tmp;
1005  SDL_Surface *tmp2;
1006  int converted_colorkey = 0;
1007 
1008  /* Create a dummy surface to get the colorkey converted */
1009  tmp = SDL_CreateRGBSurface(0, 1, 1,
1010  surface->format->BitsPerPixel, surface->format->Rmask,
1011  surface->format->Gmask, surface->format->Bmask,
1012  surface->format->Amask);
1013 
1014  /* Share the palette, if any */
1015  if (surface->format->palette) {
1017  }
1018 
1019  SDL_FillRect(tmp, NULL, surface->map->info.colorkey);
1020 
1021  tmp->map->info.flags &= ~SDL_COPY_COLORKEY;
1022 
1023  /* Convertion of the colorkey */
1024  tmp2 = SDL_ConvertSurface(tmp, format, 0);
1025 
1026  /* Get the converted colorkey */
1027  SDL_memcpy(&converted_colorkey, tmp2->pixels, tmp2->format->BytesPerPixel);
1028 
1029  SDL_FreeSurface(tmp);
1030  SDL_FreeSurface(tmp2);
1031 
1032  /* Set the converted colorkey on the new surface */
1033  SDL_SetColorKey(convert, 1, converted_colorkey);
1034 
1035  /* This is needed when converting for 3D texture upload */
1036  SDL_ConvertColorkeyToAlpha(convert);
1037  }
1038  }
1039  SDL_SetClipRect(convert, &surface->clip_rect);
1040 
1041  /* Enable alpha blending by default if the new surface has an
1042  * alpha channel or alpha modulation */
1043  if ((surface->format->Amask && format->Amask) ||
1044  (copy_flags & SDL_COPY_MODULATE_ALPHA)) {
1046  }
1047  if ((copy_flags & SDL_COPY_RLE_DESIRED) || (flags & SDL_RLEACCEL)) {
1048  SDL_SetSurfaceRLE(convert, SDL_RLEACCEL);
1049  }
1050 
1051  /* We're ready to go! */
1052  return (convert);
1053 }
Uint8 r
Definition: SDL_blit.h:70
Uint8 b
Definition: SDL_blit.h:70
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:505
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag)
Sets the RLE acceleration hint for a surface.
Definition: SDL_surface.c:204
Uint8 g
Definition: SDL_pixels.h:296
Uint8 BytesPerPixel
Definition: SDL_pixels.h:318
Uint8 g
Definition: SDL_blit.h:70
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:899
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
Set the blend mode used for blit operations.
Definition: SDL_surface.c:439
static void SDL_ConvertColorkeyToAlpha(SDL_Surface *surface)
Definition: SDL_surface.c:288
Uint8 b
Definition: SDL_pixels.h:297
#define SDL_COPY_RLE_COLORKEY
Definition: SDL_blit.h:42
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:548
int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key)
Sets the color key (transparent pixel) in a blittable surface.
Definition: SDL_surface.c:225
Uint32 colorkey
Definition: SDL_blit.h:69
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
#define SDL_memcpy
Uint8 r
Definition: SDL_pixels.h:295
void * pixels
Definition: SDL_surface.h:75
Uint8 a
Definition: SDL_pixels.h:298
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:190
#define SDL_memcmp
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
SDL_Rect clip_rect
Definition: SDL_surface.h:85
void SDL_FreeSurface(SDL_Surface *surface)
Definition: SDL_surface.c:1206
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:139
SDL_Color * colors
Definition: SDL_pixels.h:305
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_SetError
SDL_Surface * SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
Definition: SDL_surface.c:127
GLbitfield flags
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
int h
Definition: SDL_rect.h:67
#define SDL_COPY_RLE_ALPHAKEY
Definition: SDL_blit.h:43
#define SDL_FillRect
SDL_Palette * palette
Definition: SDL_pixels.h:316
int y
Definition: SDL_rect.h:66
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitInfo info
Definition: SDL_blit.h:92
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
Uint8 a
Definition: SDL_blit.h:70
SDL_Surface* SDL_ConvertSurfaceFormat ( SDL_Surface src,
Uint32  pixel_format,
Uint32  flags 
)

Definition at line 1056 of file SDL_surface.c.

References NULL, SDL_AllocFormat, SDL_ConvertSurface(), and SDL_FreeFormat.

1058 {
1059  SDL_PixelFormat *fmt;
1060  SDL_Surface *convert = NULL;
1061 
1063  if (fmt) {
1064  convert = SDL_ConvertSurface(surface, fmt, flags);
1065  SDL_FreeFormat(fmt);
1066  }
1067  return convert;
1068 }
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:899
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_AllocFormat
#define SDL_FreeFormat
#define NULL
Definition: begin_code.h:164
GLbitfield flags
Uint32 pixel_format
Definition: testoverlay2.c:152
SDL_Surface* SDL_CreateRGBSurface ( Uint32  flags,
int  width,
int  height,
int  depth,
Uint32  Rmask,
Uint32  Gmask,
Uint32  Bmask,
Uint32  Amask 
)

Allocate and free an RGB surface.

If the depth is 4 or 8 bits, an empty palette is allocated for the surface. If the depth is greater than 8 bits, the pixel format is set using the flags '[RGB]mask'.

If the function runs out of memory, it will return NULL.

Parameters
flagsThe flags are obsolete and should be set to 0.
widthThe width in pixels of the surface to create.
heightThe height in pixels of the surface to create.
depthThe depth in bits of the surface to create.
RmaskThe red mask of the surface to create.
GmaskThe green mask of the surface to create.
BmaskThe blue mask of the surface to create.
AmaskThe alpha mask of the surface to create.

Definition at line 127 of file SDL_surface.c.

References NULL, SDL_CreateRGBSurfaceWithFormat(), SDL_MasksToPixelFormatEnum, SDL_PIXELFORMAT_UNKNOWN, and SDL_SetError.

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceFrom().

130 {
131  Uint32 format;
132 
133  /* Get the pixel format */
134  format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
135  if (format == SDL_PIXELFORMAT_UNKNOWN) {
136  SDL_SetError("Unknown pixel format");
137  return NULL;
138  }
139 
141 }
#define SDL_MasksToPixelFormatEnum
uint32_t Uint32
Definition: SDL_stdinc.h:181
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
SDL_Surface * SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format)
Definition: SDL_surface.c:40
#define NULL
Definition: begin_code.h:164
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1572
#define SDL_SetError
GLbitfield flags
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
SDL_Surface* SDL_CreateRGBSurfaceFrom ( void pixels,
int  width,
int  height,
int  depth,
int  pitch,
Uint32  Rmask,
Uint32  Gmask,
Uint32  Bmask,
Uint32  Amask 
)

Definition at line 147 of file SDL_surface.c.

References SDL_Surface::flags, SDL_Surface::h, NULL, SDL_Surface::pitch, SDL_Surface::pixels, SDL_CreateRGBSurface(), SDL_PREALLOC, SDL_SetClipRect(), and SDL_Surface::w.

151 {
153 
154  surface = SDL_CreateRGBSurface(0, 0, 0, depth, Rmask, Gmask, Bmask, Amask);
155  if (surface != NULL) {
156  surface->flags |= SDL_PREALLOC;
157  surface->pixels = pixels;
158  surface->w = width;
159  surface->h = height;
160  surface->pitch = pitch;
161  SDL_SetClipRect(surface, NULL);
162  }
163  return surface;
164 }
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:505
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
Uint32 flags
Definition: SDL_surface.h:71
void * pixels
Definition: SDL_surface.h:75
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
#define NULL
Definition: begin_code.h:164
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1572
SDL_Surface * SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
Definition: SDL_surface.c:127
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
#define SDL_PREALLOC
Definition: SDL_surface.h:53
SDL_Surface* SDL_CreateRGBSurfaceWithFormat ( Uint32  flags,
int  width,
int  height,
int  depth,
Uint32  format 
)

Definition at line 40 of file SDL_surface.c.

References SDL_PixelFormat::Amask, SDL_Color::b, SDL_PixelFormat::BitsPerPixel, SDL_Palette::colors, SDL_Surface::format, SDL_PixelFormat::format, SDL_Color::g, SDL_Surface::h, SDL_Surface::map, SDL_Palette::ncolors, NULL, SDL_Surface::pitch, SDL_Surface::pixels, SDL_Color::r, SDL_Surface::refcount, SDL_AllocBlitMap(), SDL_AllocFormat, SDL_AllocPalette, SDL_BLENDMODE_BLEND, SDL_CalculatePitch(), SDL_calloc(), SDL_FreePalette, SDL_FreeSurface(), SDL_ISPIXELFORMAT_INDEXED, SDL_malloc, SDL_MAX_SINT32, SDL_memset, SDL_OutOfMemory, SDL_SetClipRect(), SDL_SetSurfaceBlendMode(), SDL_SetSurfacePalette(), void, and SDL_Surface::w.

Referenced by SDL_CreateRGBSurface(), and SDL_CreateRGBSurfaceWithFormatFrom().

42 {
44 
45  /* The flags are no longer used, make the compiler happy */
46  (void)flags;
47 
48  /* Allocate the surface */
49  surface = (SDL_Surface *) SDL_calloc(1, sizeof(*surface));
50  if (surface == NULL) {
52  return NULL;
53  }
54 
55  surface->format = SDL_AllocFormat(format);
56  if (!surface->format) {
57  SDL_FreeSurface(surface);
58  return NULL;
59  }
60  surface->w = width;
61  surface->h = height;
62  surface->pitch = SDL_CalculatePitch(surface);
63  SDL_SetClipRect(surface, NULL);
64 
65  if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
66  SDL_Palette *palette =
67  SDL_AllocPalette((1 << surface->format->BitsPerPixel));
68  if (!palette) {
69  SDL_FreeSurface(surface);
70  return NULL;
71  }
72  if (palette->ncolors == 2) {
73  /* Create a black and white bitmap palette */
74  palette->colors[0].r = 0xFF;
75  palette->colors[0].g = 0xFF;
76  palette->colors[0].b = 0xFF;
77  palette->colors[1].r = 0x00;
78  palette->colors[1].g = 0x00;
79  palette->colors[1].b = 0x00;
80  }
81  SDL_SetSurfacePalette(surface, palette);
82  SDL_FreePalette(palette);
83  }
84 
85  /* Get the pixels */
86  if (surface->w && surface->h) {
87  /* Assumptions checked in surface_size_assumptions assert above */
88  Sint64 size = ((Sint64)surface->h * surface->pitch);
90  /* Overflow... */
91  SDL_FreeSurface(surface);
93  return NULL;
94  }
95 
96  surface->pixels = SDL_malloc((size_t)size);
97  if (!surface->pixels) {
98  SDL_FreeSurface(surface);
100  return NULL;
101  }
102  /* This is important for bitmaps */
103  SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
104  }
105 
106  /* Allocate an empty mapping */
107  surface->map = SDL_AllocBlitMap();
108  if (!surface->map) {
109  SDL_FreeSurface(surface);
110  return NULL;
111  }
112 
113  /* By default surface with an alpha mask are set up for blending */
114  if (surface->format->Amask) {
116  }
117 
118  /* The surface is ready to go */
119  surface->refcount = 1;
120  return surface;
121 }
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:505
Uint8 g
Definition: SDL_pixels.h:296
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
Set the blend mode used for blit operations.
Definition: SDL_surface.c:439
Uint8 b
Definition: SDL_pixels.h:297
#define SDL_AllocFormat
#define SDL_MAX_SINT32
A signed 32-bit integer type.
Definition: SDL_stdinc.h:173
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
void * SDL_calloc(size_t nmemb, size_t size)
Uint8 r
Definition: SDL_pixels.h:295
void * pixels
Definition: SDL_surface.h:75
Uint8 BitsPerPixel
Definition: SDL_pixels.h:317
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:190
GLsizeiptr size
#define SDL_AllocPalette
void SDL_FreeSurface(SDL_Surface *surface)
Definition: SDL_surface.c:1206
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Color * colors
Definition: SDL_pixels.h:305
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_FreePalette
GLbitfield flags
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
SDL_BlitMap * SDL_AllocBlitMap(void)
Definition: SDL_pixels.c:961
int SDL_CalculatePitch(SDL_Surface *surface)
Definition: SDL_pixels.c:755
#define SDL_malloc
int64_t Sint64
Definition: SDL_stdinc.h:188
#define SDL_memset
SDL_Surface* SDL_CreateRGBSurfaceWithFormatFrom ( void pixels,
int  width,
int  height,
int  depth,
int  pitch,
Uint32  format 
)

Definition at line 171 of file SDL_surface.c.

References SDL_Surface::flags, SDL_Surface::h, NULL, SDL_Surface::pitch, SDL_Surface::pixels, SDL_CreateRGBSurfaceWithFormat(), SDL_PREALLOC, SDL_SetClipRect(), and SDL_Surface::w.

174 {
176 
177  surface = SDL_CreateRGBSurfaceWithFormat(0, 0, 0, depth, format);
178  if (surface != NULL) {
179  surface->flags |= SDL_PREALLOC;
180  surface->pixels = pixels;
181  surface->w = width;
182  surface->h = height;
183  surface->pitch = pitch;
184  SDL_SetClipRect(surface, NULL);
185  }
186  return surface;
187 }
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:505
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
Uint32 flags
Definition: SDL_surface.h:71
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
SDL_Surface * SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format)
Definition: SDL_surface.c:40
void * pixels
Definition: SDL_surface.h:75
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
#define NULL
Definition: begin_code.h:164
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1572
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
#define SDL_PREALLOC
Definition: SDL_surface.h:53
SDL_Surface* SDL_DuplicateSurface ( SDL_Surface surface)

Definition at line 890 of file SDL_surface.c.

References SDL_Surface::flags, SDL_Surface::format, and SDL_ConvertSurface().

891 {
892  return SDL_ConvertSurface(surface, surface->format, surface->flags);
893 }
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:899
Uint32 flags
Definition: SDL_surface.h:71
SDL_PixelFormat * format
Definition: SDL_surface.h:72
int SDL_FillRect ( SDL_Surface dst,
const SDL_Rect rect,
Uint32  color 
)

Performs a fast fill of the given rectangle with color.

If rect is NULL, the whole surface will be filled with color.

The color should be a pixel of the format used by the surface, and can be generated by the SDL_MapRGB() function.

Returns
0 on success, or -1 on error.

Definition at line 237 of file SDL_fillrect.c.

References SDL_PixelFormat::BitsPerPixel, SDL_PixelFormat::BytesPerPixel, SDL_Surface::clip_rect, SDL_Surface::format, SDL_Rect::h, SDL_Surface::pitch, SDL_Surface::pixels, SDL_FillRect1(), SDL_FillRect2(), SDL_FillRect3(), SDL_FillRect4(), SDL_HasSSE, SDL_IntersectRect, SDL_RectEmpty(), SDL_SetError, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_FillRects().

238 {
239  SDL_Rect clipped;
240  Uint8 *pixels;
241 
242  if (!dst) {
243  return SDL_SetError("Passed NULL destination surface");
244  }
245 
246  /* This function doesn't work on surfaces < 8 bpp */
247  if (dst->format->BitsPerPixel < 8) {
248  return SDL_SetError("SDL_FillRect(): Unsupported surface format");
249  }
250 
251  /* If 'rect' == NULL, then fill the whole surface */
252  if (rect) {
253  /* Perform clipping */
254  if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
255  return 0;
256  }
257  rect = &clipped;
258  } else {
259  rect = &dst->clip_rect;
260  /* Don't attempt to fill if the surface's clip_rect is empty */
261  if (SDL_RectEmpty(rect)) {
262  return 0;
263  }
264  }
265 
266  /* Perform software fill */
267  if (!dst->pixels) {
268  return SDL_SetError("SDL_FillRect(): You must lock the surface");
269  }
270 
271  pixels = (Uint8 *) dst->pixels + rect->y * dst->pitch +
272  rect->x * dst->format->BytesPerPixel;
273 
274  switch (dst->format->BytesPerPixel) {
275  case 1:
276  {
277  color |= (color << 8);
278  color |= (color << 16);
279 #ifdef __SSE__
280  if (SDL_HasSSE()) {
281  SDL_FillRect1SSE(pixels, dst->pitch, color, rect->w, rect->h);
282  break;
283  }
284 #endif
285  SDL_FillRect1(pixels, dst->pitch, color, rect->w, rect->h);
286  break;
287  }
288 
289  case 2:
290  {
291  color |= (color << 16);
292 #ifdef __SSE__
293  if (SDL_HasSSE()) {
294  SDL_FillRect2SSE(pixels, dst->pitch, color, rect->w, rect->h);
295  break;
296  }
297 #endif
298  SDL_FillRect2(pixels, dst->pitch, color, rect->w, rect->h);
299  break;
300  }
301 
302  case 3:
303  /* 24-bit RGB is a slow path, at least for now. */
304  {
305  SDL_FillRect3(pixels, dst->pitch, color, rect->w, rect->h);
306  break;
307  }
308 
309  case 4:
310  {
311 #ifdef __SSE__
312  if (SDL_HasSSE()) {
313  SDL_FillRect4SSE(pixels, dst->pitch, color, rect->w, rect->h);
314  break;
315  }
316 #endif
317  SDL_FillRect4(pixels, dst->pitch, color, rect->w, rect->h);
318  break;
319  }
320  }
321 
322  /* We're done! */
323  return 0;
324 }
Uint8 BytesPerPixel
Definition: SDL_pixels.h:318
#define SDL_IntersectRect
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
Definition: SDL_rect.h:82
static void SDL_FillRect3(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:197
void * pixels
Definition: SDL_surface.h:75
uint8_t Uint8
Definition: SDL_stdinc.h:157
Uint8 BitsPerPixel
Definition: SDL_pixels.h:317
int x
Definition: SDL_rect.h:66
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
int w
Definition: SDL_rect.h:67
SDL_Rect clip_rect
Definition: SDL_surface.h:85
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_SetError
static void SDL_FillRect2(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:173
int h
Definition: SDL_rect.h:67
GLuint color
static void SDL_FillRect4(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:225
static void SDL_FillRect1(Uint8 *pixels, int pitch, Uint32 color, int w, int h)
Definition: SDL_fillrect.c:134
#define SDL_HasSSE
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
int SDL_FillRects ( SDL_Surface dst,
const SDL_Rect rects,
int  count,
Uint32  color 
)

Definition at line 327 of file SDL_fillrect.c.

References i, SDL_FillRect(), and SDL_SetError.

329 {
330  int i;
331  int status = 0;
332 
333  if (!rects) {
334  return SDL_SetError("SDL_FillRects() passed NULL rects");
335  }
336 
337  for (i = 0; i < count; ++i) {
338  status += SDL_FillRect(dst, &rects[i], color);
339  }
340  return status;
341 }
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
int SDL_FillRect(SDL_Surface *dst, const SDL_Rect *rect, Uint32 color)
Definition: SDL_fillrect.c:237
#define SDL_SetError
GLuint color
void SDL_FreeSurface ( SDL_Surface surface)

Definition at line 1206 of file SDL_surface.c.

References SDL_Surface::flags, SDL_Surface::format, SDL_Surface::locked, SDL_Surface::map, NULL, SDL_Surface::pixels, SDL_Surface::refcount, SDL_DONTFREE, SDL_free(), SDL_FreeBlitMap(), SDL_FreeFormat, SDL_PREALLOC, SDL_RLEACCEL, SDL_SetSurfacePalette(), SDL_UnlockSurface(), and SDL_UnRLESurface().

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceWithFormat().

1207 {
1208  if (surface == NULL) {
1209  return;
1210  }
1211  if (surface->flags & SDL_DONTFREE) {
1212  return;
1213  }
1214  if (surface->map != NULL) {
1215  SDL_FreeBlitMap(surface->map);
1216  surface->map = NULL;
1217  }
1218  if (--surface->refcount > 0) {
1219  return;
1220  }
1221  while (surface->locked > 0) {
1222  SDL_UnlockSurface(surface);
1223  }
1224  if (surface->flags & SDL_RLEACCEL) {
1225  SDL_UnRLESurface(surface, 0);
1226  }
1227  if (surface->format) {
1228  SDL_SetSurfacePalette(surface, NULL);
1229  SDL_FreeFormat(surface->format);
1230  surface->format = NULL;
1231  }
1232  if (!(surface->flags & SDL_PREALLOC)) {
1233  SDL_free(surface->pixels);
1234  }
1235  SDL_free(surface);
1236 }
void SDL_UnlockSurface(SDL_Surface *surface)
Definition: SDL_surface.c:872
#define SDL_DONTFREE
Definition: SDL_surface.h:55
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Uint32 flags
Definition: SDL_surface.h:71
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
void * pixels
Definition: SDL_surface.h:75
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:190
void SDL_free(void *mem)
#define SDL_FreeFormat
#define NULL
Definition: begin_code.h:164
SDL_PixelFormat * format
Definition: SDL_surface.h:72
void SDL_FreeBlitMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:1086
#define SDL_PREALLOC
Definition: SDL_surface.h:53
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
void SDL_GetClipRect ( SDL_Surface surface,
SDL_Rect rect 
)

Gets the clipping rectangle for the destination surface in a blit.

rect must be a pointer to a valid rectangle which will be filled with the correct values.

Definition at line 529 of file SDL_surface.c.

References SDL_Surface::clip_rect.

530 {
531  if (surface && rect) {
532  *rect = surface->clip_rect;
533  }
534 }
SDL_Rect clip_rect
Definition: SDL_surface.h:85
int SDL_GetColorKey ( SDL_Surface surface,
Uint32 key 
)

Gets the color key (transparent pixel) in a blittable surface.

Parameters
surfaceThe surface to update
keyA pointer filled in with the transparent pixel in the native surface format
Returns
0 on success, or -1 if the surface is not valid or colorkey is not enabled.

Definition at line 270 of file SDL_surface.c.

References SDL_BlitInfo::colorkey, SDL_BlitInfo::flags, SDL_BlitMap::info, SDL_Surface::map, and SDL_COPY_COLORKEY.

271 {
272  if (!surface) {
273  return -1;
274  }
275 
276  if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
277  return -1;
278  }
279 
280  if (key) {
281  *key = surface->map->info.colorkey;
282  }
283  return 0;
284 }
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
Uint32 colorkey
Definition: SDL_blit.h:69
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLuint64 key
Definition: gl2ext.h:2192
SDL_BlitInfo info
Definition: SDL_blit.h:92
int SDL_GetSurfaceAlphaMod ( SDL_Surface surface,
Uint8 alpha 
)

Get the additional alpha value used in blit operations.

Parameters
surfaceThe surface to query.
alphaA pointer filled in with the current alpha value.
Returns
0 on success, or -1 if the surface is not valid.
See also
SDL_SetSurfaceAlphaMod()

Definition at line 426 of file SDL_surface.c.

References SDL_BlitInfo::a, SDL_BlitMap::info, and SDL_Surface::map.

427 {
428  if (!surface) {
429  return -1;
430  }
431 
432  if (alpha) {
433  *alpha = surface->map->info.a;
434  }
435  return 0;
436 }
GLfloat GLfloat GLfloat alpha
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_BlitInfo info
Definition: SDL_blit.h:92
Uint8 a
Definition: SDL_blit.h:70
int SDL_GetSurfaceBlendMode ( SDL_Surface surface,
SDL_BlendMode blendMode 
)

Get the blend mode used for blit operations.

Parameters
surfaceThe surface to query.
blendModeA pointer filled in with the current blend mode.
Returns
0 on success, or -1 if the surface is not valid.
See also
SDL_SetSurfaceBlendMode()

Definition at line 476 of file SDL_surface.c.

References SDL_Surface::map, SDL_BLENDMODE_ADD, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD, SDL_BLENDMODE_NONE, SDL_COPY_ADD, SDL_COPY_BLEND, and SDL_COPY_MOD.

477 {
478  if (!surface) {
479  return -1;
480  }
481 
482  if (!blendMode) {
483  return 0;
484  }
485 
486  switch (surface->map->
487  info.flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD)) {
488  case SDL_COPY_BLEND:
490  break;
491  case SDL_COPY_ADD:
493  break;
494  case SDL_COPY_MOD:
496  break;
497  default:
499  break;
500  }
501  return 0;
502 }
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
int SDL_GetSurfaceColorMod ( SDL_Surface surface,
Uint8 r,
Uint8 g,
Uint8 b 
)

Get the additional color value used in blit operations.

Parameters
surfaceThe surface to query.
rA pointer filled in with the current red color value.
gA pointer filled in with the current green color value.
bA pointer filled in with the current blue color value.
Returns
0 on success, or -1 if the surface is not valid.
See also
SDL_SetSurfaceColorMod()

Definition at line 384 of file SDL_surface.c.

References SDL_BlitInfo::b, SDL_BlitInfo::g, SDL_BlitMap::info, SDL_Surface::map, and SDL_BlitInfo::r.

385 {
386  if (!surface) {
387  return -1;
388  }
389 
390  if (r) {
391  *r = surface->map->info.r;
392  }
393  if (g) {
394  *g = surface->map->info.g;
395  }
396  if (b) {
397  *b = surface->map->info.b;
398  }
399  return 0;
400 }
Uint8 r
Definition: SDL_blit.h:70
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Uint8 b
Definition: SDL_blit.h:70
Uint8 g
Definition: SDL_blit.h:70
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLboolean GLboolean g
GLboolean GLboolean GLboolean b
SDL_BlitInfo info
Definition: SDL_blit.h:92
SDL_Surface* SDL_LoadBMP_RW ( SDL_RWops src,
int  freesrc 
)

Load a surface from a seekable SDL data stream (memory or file).

If freesrc is non-zero, the stream will be closed after being read.

The new surface should be freed with SDL_FreeSurface().

Returns
the new surface, or NULL if there was an error.

Definition at line 87 of file SDL_bmp.c.

References SDL_Color::a, SDL_Color::b, BI_BITFIELDS, BI_RGB, colors, SDL_Palette::colors, CorrectAlphaChannel(), done, SDL_Surface::format, SDL_Color::g, SDL_Surface::h, i, SDL_Palette::ncolors, NULL, SDL_Surface::pitch, SDL_Surface::pixels, SDL_Color::r, RW_SEEK_CUR, RW_SEEK_SET, SDL_ALPHA_OPAQUE, SDL_assert, SDL_ClearError, SDL_CreateRGBSurface, SDL_EFREAD, SDL_EFSEEK, SDL_Error, SDL_FALSE, SDL_FreeSurface, SDL_GetError, SDL_OutOfMemory, SDL_ReadLE16, SDL_ReadLE32, SDL_realloc, SDL_RWclose, SDL_RWread, SDL_RWseek, SDL_RWtell, SDL_SetError, SDL_strcmp, SDL_strncmp, SDL_Swap16(), SDL_Swap32(), SDL_TRUE, void, and SDL_Surface::w.

88 {
89  SDL_bool was_error;
90  Sint64 fp_offset = 0;
91  int bmpPitch;
92  int i, pad;
94  Uint32 Rmask = 0;
95  Uint32 Gmask = 0;
96  Uint32 Bmask = 0;
97  Uint32 Amask = 0;
98  SDL_Palette *palette;
99  Uint8 *bits;
100  Uint8 *top, *end;
101  SDL_bool topDown;
102  int ExpandBMP;
103  SDL_bool haveRGBMasks = SDL_FALSE;
104  SDL_bool haveAlphaMask = SDL_FALSE;
105  SDL_bool correctAlpha = SDL_FALSE;
106 
107  /* The Win32 BMP file header (14 bytes) */
108  char magic[2];
109  /* Uint32 bfSize = 0; */
110  /* Uint16 bfReserved1 = 0; */
111  /* Uint16 bfReserved2 = 0; */
112  Uint32 bfOffBits = 0;
113 
114  /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
115  Uint32 biSize = 0;
116  Sint32 biWidth = 0;
117  Sint32 biHeight = 0;
118  /* Uint16 biPlanes = 0; */
119  Uint16 biBitCount = 0;
120  Uint32 biCompression = 0;
121  /* Uint32 biSizeImage = 0; */
122  /* Sint32 biXPelsPerMeter = 0; */
123  /* Sint32 biYPelsPerMeter = 0; */
124  Uint32 biClrUsed = 0;
125  /* Uint32 biClrImportant = 0; */
126 
127  (void) haveRGBMasks;
128  (void) haveAlphaMask;
129 
130  /* Make sure we are passed a valid data source */
131  surface = NULL;
132  was_error = SDL_FALSE;
133  if (src == NULL) {
134  was_error = SDL_TRUE;
135  goto done;
136  }
137 
138  /* Read in the BMP file header */
139  fp_offset = SDL_RWtell(src);
140  SDL_ClearError();
141  if (SDL_RWread(src, magic, 1, 2) != 2) {
143  was_error = SDL_TRUE;
144  goto done;
145  }
146  if (SDL_strncmp(magic, "BM", 2) != 0) {
147  SDL_SetError("File is not a Windows BMP file");
148  was_error = SDL_TRUE;
149  goto done;
150  }
151  /* bfSize = */ SDL_ReadLE32(src);
152  /* bfReserved1 = */ SDL_ReadLE16(src);
153  /* bfReserved2 = */ SDL_ReadLE16(src);
154  bfOffBits = SDL_ReadLE32(src);
155 
156  /* Read the Win32 BITMAPINFOHEADER */
157  biSize = SDL_ReadLE32(src);
158  if (biSize == 12) { /* really old BITMAPCOREHEADER */
159  biWidth = (Uint32) SDL_ReadLE16(src);
160  biHeight = (Uint32) SDL_ReadLE16(src);
161  /* biPlanes = */ SDL_ReadLE16(src);
162  biBitCount = SDL_ReadLE16(src);
163  biCompression = BI_RGB;
164  } else if (biSize >= 40) { /* some version of BITMAPINFOHEADER */
165  Uint32 headerSize;
166  biWidth = SDL_ReadLE32(src);
167  biHeight = SDL_ReadLE32(src);
168  /* biPlanes = */ SDL_ReadLE16(src);
169  biBitCount = SDL_ReadLE16(src);
170  biCompression = SDL_ReadLE32(src);
171  /* biSizeImage = */ SDL_ReadLE32(src);
172  /* biXPelsPerMeter = */ SDL_ReadLE32(src);
173  /* biYPelsPerMeter = */ SDL_ReadLE32(src);
174  biClrUsed = SDL_ReadLE32(src);
175  /* biClrImportant = */ SDL_ReadLE32(src);
176 
177  /* 64 == BITMAPCOREHEADER2, an incompatible OS/2 2.x extension. Skip this stuff for now. */
178  if (biSize == 64) {
179  /* ignore these extra fields. */
180  if (biCompression == BI_BITFIELDS) {
181  /* this value is actually huffman compression in this variant. */
182  SDL_SetError("Compressed BMP files not supported");
183  was_error = SDL_TRUE;
184  goto done;
185  }
186  } else {
187  /* This is complicated. If compression is BI_BITFIELDS, then
188  we have 3 DWORDS that specify the RGB masks. This is either
189  stored here in an BITMAPV2INFOHEADER (which only differs in
190  that it adds these RGB masks) and biSize >= 52, or we've got
191  these masks stored in the exact same place, but strictly
192  speaking, this is the bmiColors field in BITMAPINFO immediately
193  following the legacy v1 info header, just past biSize. */
194  if (biCompression == BI_BITFIELDS) {
195  haveRGBMasks = SDL_TRUE;
196  Rmask = SDL_ReadLE32(src);
197  Gmask = SDL_ReadLE32(src);
198  Bmask = SDL_ReadLE32(src);
199 
200  /* ...v3 adds an alpha mask. */
201  if (biSize >= 56) { /* BITMAPV3INFOHEADER; adds alpha mask */
202  haveAlphaMask = SDL_TRUE;
203  Amask = SDL_ReadLE32(src);
204  }
205  } else {
206  /* the mask fields are ignored for v2+ headers if not BI_BITFIELD. */
207  if (biSize >= 52) { /* BITMAPV2INFOHEADER; adds RGB masks */
208  /*Rmask = */ SDL_ReadLE32(src);
209  /*Gmask = */ SDL_ReadLE32(src);
210  /*Bmask = */ SDL_ReadLE32(src);
211  }
212  if (biSize >= 56) { /* BITMAPV3INFOHEADER; adds alpha mask */
213  /*Amask = */ SDL_ReadLE32(src);
214  }
215  }
216 
217  /* Insert other fields here; Wikipedia and MSDN say we're up to
218  v5 of this header, but we ignore those for now (they add gamma,
219  color spaces, etc). Ignoring the weird OS/2 2.x format, we
220  currently parse up to v3 correctly (hopefully!). */
221  }
222 
223  /* skip any header bytes we didn't handle... */
224  headerSize = (Uint32) (SDL_RWtell(src) - (fp_offset + 14));
225  if (biSize > headerSize) {
226  SDL_RWseek(src, (biSize - headerSize), RW_SEEK_CUR);
227  }
228  }
229  if (biHeight < 0) {
230  topDown = SDL_TRUE;
231  biHeight = -biHeight;
232  } else {
233  topDown = SDL_FALSE;
234  }
235 
236  /* Check for read error */
237  if (SDL_strcmp(SDL_GetError(), "") != 0) {
238  was_error = SDL_TRUE;
239  goto done;
240  }
241 
242  /* Expand 1 and 4 bit bitmaps to 8 bits per pixel */
243  switch (biBitCount) {
244  case 1:
245  case 4:
246  ExpandBMP = biBitCount;
247  biBitCount = 8;
248  break;
249  default:
250  ExpandBMP = 0;
251  break;
252  }
253 
254  /* We don't support any BMP compression right now */
255  switch (biCompression) {
256  case BI_RGB:
257  /* If there are no masks, use the defaults */
258  SDL_assert(!haveRGBMasks);
259  SDL_assert(!haveAlphaMask);
260  /* Default values for the BMP format */
261  switch (biBitCount) {
262  case 15:
263  case 16:
264  Rmask = 0x7C00;
265  Gmask = 0x03E0;
266  Bmask = 0x001F;
267  break;
268  case 24:
269 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
270  Rmask = 0x000000FF;
271  Gmask = 0x0000FF00;
272  Bmask = 0x00FF0000;
273 #else
274  Rmask = 0x00FF0000;
275  Gmask = 0x0000FF00;
276  Bmask = 0x000000FF;
277 #endif
278  break;
279  case 32:
280  /* We don't know if this has alpha channel or not */
281  correctAlpha = SDL_TRUE;
282  Amask = 0xFF000000;
283  Rmask = 0x00FF0000;
284  Gmask = 0x0000FF00;
285  Bmask = 0x000000FF;
286  break;
287  default:
288  break;
289  }
290  break;
291 
292  case BI_BITFIELDS:
293  break; /* we handled this in the info header. */
294 
295  default:
296  SDL_SetError("Compressed BMP files not supported");
297  was_error = SDL_TRUE;
298  goto done;
299  }
300 
301  /* Create a compatible surface, note that the colors are RGB ordered */
302  surface =
303  SDL_CreateRGBSurface(0, biWidth, biHeight, biBitCount, Rmask, Gmask,
304  Bmask, Amask);
305  if (surface == NULL) {
306  was_error = SDL_TRUE;
307  goto done;
308  }
309 
310  /* Load the palette, if any */
311  palette = (surface->format)->palette;
312  if (palette) {
313  SDL_assert(biBitCount <= 8);
314  if (biClrUsed == 0) {
315  biClrUsed = 1 << biBitCount;
316  }
317  if ((int) biClrUsed > palette->ncolors) {
318  SDL_Color *colors;
319  int ncolors = biClrUsed;
320  colors =
321  (SDL_Color *) SDL_realloc(palette->colors,
322  ncolors *
323  sizeof(*palette->colors));
324  if (!colors) {
325  SDL_OutOfMemory();
326  was_error = SDL_TRUE;
327  goto done;
328  }
329  palette->ncolors = ncolors;
330  palette->colors = colors;
331  } else if ((int) biClrUsed < palette->ncolors) {
332  palette->ncolors = biClrUsed;
333  }
334  if (biSize == 12) {
335  for (i = 0; i < (int) biClrUsed; ++i) {
336  SDL_RWread(src, &palette->colors[i].b, 1, 1);
337  SDL_RWread(src, &palette->colors[i].g, 1, 1);
338  SDL_RWread(src, &palette->colors[i].r, 1, 1);
339  palette->colors[i].a = SDL_ALPHA_OPAQUE;
340  }
341  } else {
342  for (i = 0; i < (int) biClrUsed; ++i) {
343  SDL_RWread(src, &palette->colors[i].b, 1, 1);
344  SDL_RWread(src, &palette->colors[i].g, 1, 1);
345  SDL_RWread(src, &palette->colors[i].r, 1, 1);
346  SDL_RWread(src, &palette->colors[i].a, 1, 1);
347 
348  /* According to Microsoft documentation, the fourth element
349  is reserved and must be zero, so we shouldn't treat it as
350  alpha.
351  */
352  palette->colors[i].a = SDL_ALPHA_OPAQUE;
353  }
354  }
355  }
356 
357  /* Read the surface pixels. Note that the bmp image is upside down */
358  if (SDL_RWseek(src, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
360  was_error = SDL_TRUE;
361  goto done;
362  }
363  top = (Uint8 *)surface->pixels;
364  end = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
365  switch (ExpandBMP) {
366  case 1:
367  bmpPitch = (biWidth + 7) >> 3;
368  pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
369  break;
370  case 4:
371  bmpPitch = (biWidth + 1) >> 1;
372  pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
373  break;
374  default:
375  pad = ((surface->pitch % 4) ? (4 - (surface->pitch % 4)) : 0);
376  break;
377  }
378  if (topDown) {
379  bits = top;
380  } else {
381  bits = end - surface->pitch;
382  }
383  while (bits >= top && bits < end) {
384  switch (ExpandBMP) {
385  case 1:
386  case 4:{
387  Uint8 pixel = 0;
388  int shift = (8 - ExpandBMP);
389  for (i = 0; i < surface->w; ++i) {
390  if (i % (8 / ExpandBMP) == 0) {
391  if (!SDL_RWread(src, &pixel, 1, 1)) {
392  SDL_SetError("Error reading from BMP");
393  was_error = SDL_TRUE;
394  goto done;
395  }
396  }
397  *(bits + i) = (pixel >> shift);
398  pixel <<= ExpandBMP;
399  }
400  }
401  break;
402 
403  default:
404  if (SDL_RWread(src, bits, 1, surface->pitch)
405  != surface->pitch) {
407  was_error = SDL_TRUE;
408  goto done;
409  }
410 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
411  /* Byte-swap the pixels if needed. Note that the 24bpp
412  case has already been taken care of above. */
413  switch (biBitCount) {
414  case 15:
415  case 16:{
416  Uint16 *pix = (Uint16 *) bits;
417  for (i = 0; i < surface->w; i++)
418  pix[i] = SDL_Swap16(pix[i]);
419  break;
420  }
421 
422  case 32:{
423  Uint32 *pix = (Uint32 *) bits;
424  for (i = 0; i < surface->w; i++)
425  pix[i] = SDL_Swap32(pix[i]);
426  break;
427  }
428  }
429 #endif
430  break;
431  }
432  /* Skip padding bytes, ugh */
433  if (pad) {
434  Uint8 padbyte;
435  for (i = 0; i < pad; ++i) {
436  SDL_RWread(src, &padbyte, 1, 1);
437  }
438  }
439  if (topDown) {
440  bits += surface->pitch;
441  } else {
442  bits -= surface->pitch;
443  }
444  }
445  if (correctAlpha) {
446  CorrectAlphaChannel(surface);
447  }
448  done:
449  if (was_error) {
450  if (src) {
451  SDL_RWseek(src, fp_offset, RW_SEEK_SET);
452  }
453  SDL_FreeSurface(surface);
454  surface = NULL;
455  }
456  if (freesrc && src) {
457  SDL_RWclose(src);
458  }
459  return (surface);
460 }
#define BI_RGB
Definition: SDL_bmp.c:45
#define SDL_ClearError
#define SDL_GetError
Uint8 g
Definition: SDL_pixels.h:296
GLuint GLuint end
Definition: SDL_opengl.h:1571
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_ReadLE32
#define SDL_RWread(ctx, ptr, size, n)
Definition: SDL_rwops.h:187
Uint8 b
Definition: SDL_pixels.h:297
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_realloc
static void CorrectAlphaChannel(SDL_Surface *surface)
Definition: SDL_bmp.c:57
GLdouble GLdouble GLdouble GLdouble top
#define SDL_strncmp
#define SDL_Error
#define SDL_RWseek(ctx, offset, whence)
Definition: SDL_rwops.h:185
#define SDL_ReadLE16
SDL_FORCE_INLINE Uint32 SDL_Swap32(Uint32 x)
Definition: SDL_endian.h:162
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
Uint8 r
Definition: SDL_pixels.h:295
void * pixels
Definition: SDL_surface.h:75
#define SDL_FreeSurface
Uint8 a
Definition: SDL_pixels.h:298
uint8_t Uint8
Definition: SDL_stdinc.h:157
int done
Definition: checkkeys.c:28
SDL_FORCE_INLINE Uint16 SDL_Swap16(Uint16 x)
Definition: SDL_endian.h:107
int32_t Sint32
Definition: SDL_stdinc.h:175
#define BI_BITFIELDS
Definition: SDL_bmp.c:48
#define SDL_assert(condition)
Definition: SDL_assert.h:169
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_bool
Definition: SDL_stdinc.h:139
SDL_Color * colors
Definition: SDL_pixels.h:305
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_RWclose(ctx)
Definition: SDL_rwops.h:189
#define SDL_SetError
#define SDL_CreateRGBSurface
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
#define RW_SEEK_SET
Definition: SDL_rwops.h:174
uint16_t Uint16
Definition: SDL_stdinc.h:169
#define SDL_strcmp
#define RW_SEEK_CUR
Definition: SDL_rwops.h:175
int64_t Sint64
Definition: SDL_stdinc.h:188
static int colors[7]
Definition: testgesture.c:39
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:46
#define SDL_RWtell(ctx)
Definition: SDL_rwops.h:186
int SDL_LockSurface ( SDL_Surface surface)

Sets up a surface for directly accessing the pixels.

Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to and read from surface->pixels, using the pixel format stored in surface->format. Once you are done accessing the surface, you should use SDL_UnlockSurface() to release it.

Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates to 0, then you can read and write to the surface at any time, and the pixel format of the surface will not change.

No operating system or library calls should be made between lock/unlock pairs, as critical system locks may be held during this time.

SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.

See also
SDL_UnlockSurface()

Definition at line 851 of file SDL_surface.c.

References SDL_Surface::flags, SDL_Surface::locked, SDL_RLEACCEL, and SDL_UnRLESurface().

Referenced by SDL_ConvertColorkeyToAlpha().

852 {
853  if (!surface->locked) {
854  /* Perform the lock */
855  if (surface->flags & SDL_RLEACCEL) {
856  SDL_UnRLESurface(surface, 1);
857  surface->flags |= SDL_RLEACCEL; /* save accel'd state */
858  }
859  }
860 
861  /* Increment the surface lock count, for recursive locks */
862  ++surface->locked;
863 
864  /* Ready to go.. */
865  return (0);
866 }
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Uint32 flags
Definition: SDL_surface.h:71
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
int SDL_LowerBlit ( SDL_Surface src,
SDL_Rect srcrect,
SDL_Surface dst,
SDL_Rect dstrect 
)

This is a semi-private blit function and it performs low-level surface blitting only.

Definition at line 548 of file SDL_surface.c.

References SDL_BlitMap::blit, SDL_BlitMap::dst, SDL_BlitMap::dst_palette_version, SDL_Surface::format, SDL_Surface::map, SDL_PixelFormat::palette, SDL_MapSurface(), SDL_BlitMap::src_palette_version, and SDL_Palette::version.

Referenced by SDL_ConvertPixels(), SDL_ConvertSurface(), SDL_LowerBlitScaled(), and SDL_UpperBlit().

550 {
551  /* Check to make sure the blit mapping is valid */
552  if ((src->map->dst != dst) ||
553  (dst->format->palette &&
554  src->map->dst_palette_version != dst->format->palette->version) ||
555  (src->format->palette &&
556  src->map->src_palette_version != src->format->palette->version)) {
557  if (SDL_MapSurface(src, dst) < 0) {
558  return (-1);
559  }
560  /* just here for debugging */
561 /* printf */
562 /* ("src = 0x%08X src->flags = %08X src->map->info.flags = %08x\ndst = 0x%08X dst->flags = %08X dst->map->info.flags = %08X\nsrc->map->blit = 0x%08x\n", */
563 /* src, dst->flags, src->map->info.flags, dst, dst->flags, */
564 /* dst->map->info.flags, src->map->blit); */
565  }
566  return (src->map->blit(src, srcrect, dst, dstrect));
567 }
Uint32 version
Definition: SDL_pixels.h:306
SDL_blit blit
Definition: SDL_blit.h:90
Uint32 dst_palette_version
Definition: SDL_blit.h:96
Uint32 src_palette_version
Definition: SDL_blit.h:97
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
int SDL_MapSurface(SDL_Surface *src, SDL_Surface *dst)
Definition: SDL_pixels.c:1000
SDL_Surface * dst
Definition: SDL_blit.h:88
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_Palette * palette
Definition: SDL_pixels.h:316
int SDL_LowerBlitScaled ( SDL_Surface src,
SDL_Rect srcrect,
SDL_Surface dst,
SDL_Rect dstrect 
)

This is a semi-private blit function and it performs low-level surface scaled blitting only.

Definition at line 824 of file SDL_surface.c.

References SDL_BlitInfo::flags, SDL_Surface::format, SDL_PixelFormat::format, SDL_BlitMap::info, SDL_Surface::map, SDL_COPY_ADD, SDL_COPY_BLEND, SDL_COPY_COLORKEY, SDL_COPY_MOD, SDL_COPY_MODULATE_ALPHA, SDL_COPY_MODULATE_COLOR, SDL_COPY_NEAREST, SDL_InvalidateMap(), SDL_ISPIXELFORMAT_INDEXED, SDL_LowerBlit(), and SDL_SoftStretch.

Referenced by SDL_UpperBlitScaled().

826 {
827  static const Uint32 complex_copy_flags = (
831  );
832 
833  if (!(src->map->info.flags & SDL_COPY_NEAREST)) {
834  src->map->info.flags |= SDL_COPY_NEAREST;
835  SDL_InvalidateMap(src->map);
836  }
837 
838  if ( !(src->map->info.flags & complex_copy_flags) &&
839  src->format->format == dst->format->format &&
841  return SDL_SoftStretch( src, srcrect, dst, dstrect );
842  } else {
843  return SDL_LowerBlit( src, srcrect, dst, dstrect );
844  }
845 }
#define SDL_COPY_MODULATE_COLOR
Definition: SDL_blit.h:34
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
#define SDL_SoftStretch
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
uint32_t Uint32
Definition: SDL_stdinc.h:181
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:548
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
#define SDL_COPY_NEAREST
Definition: SDL_blit.h:40
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitInfo info
Definition: SDL_blit.h:92
int SDL_SaveBMP_RW ( SDL_Surface surface,
SDL_RWops dst,
int  freedst 
)

Save a surface to a seekable SDL data stream (memory or file).

Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the BMP directly. Other RGB formats with 8-bit or higher get converted to a 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit surface before they are saved. YUV and paletted 1-bit and 4-bit formats are not supported.

If freedst is non-zero, the stream will be closed after being written.

Returns
0 if successful or -1 if there was an error.

Definition at line 463 of file SDL_bmp.c.

References SDL_PixelFormat::Amask, BI_BITFIELDS, BI_RGB, SDL_PixelFormat::BitsPerPixel, SDL_PixelFormat::Bmask, SDL_PixelFormat::BytesPerPixel, colors, SDL_Palette::colors, SDL_BlitInfo::flags, SDL_Surface::format, SDL_PixelFormat::Gmask, SDL_Surface::h, i, SDL_BlitMap::info, LCS_WINDOWS_COLOR_SPACE, SDL_Surface::map, SDL_Palette::ncolors, NULL, SDL_PixelFormat::palette, SDL_Surface::pitch, SDL_Surface::pixels, SDL_PixelFormat::Rmask, RW_SEEK_SET, SDL_BYTEORDER, SDL_ClearError, SDL_ConvertSurface, SDL_COPY_COLORKEY, SDL_EFSEEK, SDL_EFWRITE, SDL_Error, SDL_FALSE, SDL_FreeSurface, SDL_GetError, SDL_GetHintBoolean, SDL_HINT_BMP_SAVE_LEGACY_FORMAT, SDL_InitFormat(), SDL_LIL_ENDIAN, SDL_LockSurface, SDL_PIXELFORMAT_BGR24, SDL_PIXELFORMAT_BGRA32, SDL_RWclose, SDL_RWseek, SDL_RWtell, SDL_RWwrite, SDL_SetError, SDL_strcmp, SDL_TRUE, SDL_UnlockSurface, SDL_WriteLE16, SDL_WriteLE32, and SDL_Surface::w.

464 {
465  Sint64 fp_offset;
466  int i, pad;
468  Uint8 *bits;
469  SDL_bool save32bit = SDL_FALSE;
470  SDL_bool saveLegacyBMP = SDL_FALSE;
471 
472  /* The Win32 BMP file header (14 bytes) */
473  char magic[2] = { 'B', 'M' };
474  Uint32 bfSize;
475  Uint16 bfReserved1;
476  Uint16 bfReserved2;
477  Uint32 bfOffBits;
478 
479  /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
480  Uint32 biSize;
481  Sint32 biWidth;
482  Sint32 biHeight;
483  Uint16 biPlanes;
484  Uint16 biBitCount;
485  Uint32 biCompression;
486  Uint32 biSizeImage;
487  Sint32 biXPelsPerMeter;
488  Sint32 biYPelsPerMeter;
489  Uint32 biClrUsed;
490  Uint32 biClrImportant;
491 
492  /* The additional header members from the Win32 BITMAPV4HEADER struct (108 bytes in total) */
493  Uint32 bV4RedMask = 0;
494  Uint32 bV4GreenMask = 0;
495  Uint32 bV4BlueMask = 0;
496  Uint32 bV4AlphaMask = 0;
497  Uint32 bV4CSType = 0;
498  Sint32 bV4Endpoints[3 * 3] = {0};
499  Uint32 bV4GammaRed = 0;
500  Uint32 bV4GammaGreen = 0;
501  Uint32 bV4GammaBlue = 0;
502 
503  /* Make sure we have somewhere to save */
504  surface = NULL;
505  if (dst) {
506 #ifdef SAVE_32BIT_BMP
507  /* We can save alpha information in a 32-bit BMP */
508  if (saveme->format->BitsPerPixel >= 8 && (saveme->format->Amask ||
509  saveme->map->info.flags & SDL_COPY_COLORKEY)) {
510  save32bit = SDL_TRUE;
511  }
512 #endif /* SAVE_32BIT_BMP */
513 
514  if (saveme->format->palette && !save32bit) {
515  if (saveme->format->BitsPerPixel == 8) {
516  surface = saveme;
517  } else {
518  SDL_SetError("%d bpp BMP files not supported",
519  saveme->format->BitsPerPixel);
520  }
521  } else if ((saveme->format->BitsPerPixel == 24) && !save32bit &&
523  (saveme->format->Rmask == 0x00FF0000) &&
524  (saveme->format->Gmask == 0x0000FF00) &&
525  (saveme->format->Bmask == 0x000000FF)
526 #else
527  (saveme->format->Rmask == 0x000000FF) &&
528  (saveme->format->Gmask == 0x0000FF00) &&
529  (saveme->format->Bmask == 0x00FF0000)
530 #endif
531  ) {
532  surface = saveme;
533  } else {
535 
536  /* If the surface has a colorkey or alpha channel we'll save a
537  32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
538  if (save32bit) {
540  } else {
542  }
543  surface = SDL_ConvertSurface(saveme, &format, 0);
544  if (!surface) {
545  SDL_SetError("Couldn't convert image to %d bpp",
546  format.BitsPerPixel);
547  }
548  }
549  } else {
550  /* Set no error here because it may overwrite a more useful message from
551  SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */
552  return -1;
553  }
554 
555  if (save32bit) {
557  }
558 
559  if (surface && (SDL_LockSurface(surface) == 0)) {
560  const int bw = surface->w * surface->format->BytesPerPixel;
561 
562  /* Set the BMP file header values */
563  bfSize = 0; /* We'll write this when we're done */
564  bfReserved1 = 0;
565  bfReserved2 = 0;
566  bfOffBits = 0; /* We'll write this when we're done */
567 
568  /* Write the BMP file header values */
569  fp_offset = SDL_RWtell(dst);
570  SDL_ClearError();
571  SDL_RWwrite(dst, magic, 2, 1);
572  SDL_WriteLE32(dst, bfSize);
573  SDL_WriteLE16(dst, bfReserved1);
574  SDL_WriteLE16(dst, bfReserved2);
575  SDL_WriteLE32(dst, bfOffBits);
576 
577  /* Set the BMP info values */
578  biSize = 40;
579  biWidth = surface->w;
580  biHeight = surface->h;
581  biPlanes = 1;
582  biBitCount = surface->format->BitsPerPixel;
583  biCompression = BI_RGB;
584  biSizeImage = surface->h * surface->pitch;
585  biXPelsPerMeter = 0;
586  biYPelsPerMeter = 0;
587  if (surface->format->palette) {
588  biClrUsed = surface->format->palette->ncolors;
589  } else {
590  biClrUsed = 0;
591  }
592  biClrImportant = 0;
593 
594  /* Set the BMP info values for the version 4 header */
595  if (save32bit && !saveLegacyBMP) {
596  biSize = 108;
597  biCompression = BI_BITFIELDS;
598  /* The BMP format is always little endian, these masks stay the same */
599  bV4RedMask = 0x00ff0000;
600  bV4GreenMask = 0x0000ff00;
601  bV4BlueMask = 0x000000ff;
602  bV4AlphaMask = 0xff000000;
603  bV4CSType = LCS_WINDOWS_COLOR_SPACE;
604  bV4GammaRed = 0;
605  bV4GammaGreen = 0;
606  bV4GammaBlue = 0;
607  }
608 
609  /* Write the BMP info values */
610  SDL_WriteLE32(dst, biSize);
611  SDL_WriteLE32(dst, biWidth);
612  SDL_WriteLE32(dst, biHeight);
613  SDL_WriteLE16(dst, biPlanes);
614  SDL_WriteLE16(dst, biBitCount);
615  SDL_WriteLE32(dst, biCompression);
616  SDL_WriteLE32(dst, biSizeImage);
617  SDL_WriteLE32(dst, biXPelsPerMeter);
618  SDL_WriteLE32(dst, biYPelsPerMeter);
619  SDL_WriteLE32(dst, biClrUsed);
620  SDL_WriteLE32(dst, biClrImportant);
621 
622  /* Write the BMP info values for the version 4 header */
623  if (save32bit && !saveLegacyBMP) {
624  SDL_WriteLE32(dst, bV4RedMask);
625  SDL_WriteLE32(dst, bV4GreenMask);
626  SDL_WriteLE32(dst, bV4BlueMask);
627  SDL_WriteLE32(dst, bV4AlphaMask);
628  SDL_WriteLE32(dst, bV4CSType);
629  for (i = 0; i < 3 * 3; i++) {
630  SDL_WriteLE32(dst, bV4Endpoints[i]);
631  }
632  SDL_WriteLE32(dst, bV4GammaRed);
633  SDL_WriteLE32(dst, bV4GammaGreen);
634  SDL_WriteLE32(dst, bV4GammaBlue);
635  }
636 
637  /* Write the palette (in BGR color order) */
638  if (surface->format->palette) {
639  SDL_Color *colors;
640  int ncolors;
641 
642  colors = surface->format->palette->colors;
643  ncolors = surface->format->palette->ncolors;
644  for (i = 0; i < ncolors; ++i) {
645  SDL_RWwrite(dst, &colors[i].b, 1, 1);
646  SDL_RWwrite(dst, &colors[i].g, 1, 1);
647  SDL_RWwrite(dst, &colors[i].r, 1, 1);
648  SDL_RWwrite(dst, &colors[i].a, 1, 1);
649  }
650  }
651 
652  /* Write the bitmap offset */
653  bfOffBits = (Uint32)(SDL_RWtell(dst) - fp_offset);
654  if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
656  }
657  SDL_WriteLE32(dst, bfOffBits);
658  if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
660  }
661 
662  /* Write the bitmap image upside down */
663  bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
664  pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
665  while (bits > (Uint8 *) surface->pixels) {
666  bits -= surface->pitch;
667  if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
669  break;
670  }
671  if (pad) {
672  const Uint8 padbyte = 0;
673  for (i = 0; i < pad; ++i) {
674  SDL_RWwrite(dst, &padbyte, 1, 1);
675  }
676  }
677  }
678 
679  /* Write the BMP file size */
680  bfSize = (Uint32)(SDL_RWtell(dst) - fp_offset);
681  if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
683  }
684  SDL_WriteLE32(dst, bfSize);
685  if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
687  }
688 
689  /* Close it up.. */
690  SDL_UnlockSurface(surface);
691  if (surface != saveme) {
692  SDL_FreeSurface(surface);
693  }
694  }
695 
696  if (freedst && dst) {
697  SDL_RWclose(dst);
698  }
699  return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
700 }
#define BI_RGB
Definition: SDL_bmp.c:45
#define SDL_ClearError
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
#define SDL_GetError
#define SDL_UnlockSurface
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
#define LCS_WINDOWS_COLOR_SPACE
Definition: SDL_bmp.c:54
#define SDL_RWwrite(ctx, ptr, size, n)
Definition: SDL_rwops.h:188
Uint8 BytesPerPixel
Definition: SDL_pixels.h:318
#define SDL_ConvertSurface
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_WriteLE16
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_Error
#define SDL_GetHintBoolean
#define SDL_RWseek(ctx, offset, whence)
Definition: SDL_rwops.h:185
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
void * pixels
Definition: SDL_surface.h:75
#define SDL_FreeSurface
uint8_t Uint8
Definition: SDL_stdinc.h:157
Uint8 BitsPerPixel
Definition: SDL_pixels.h:317
#define SDL_HINT_BMP_SAVE_LEGACY_FORMAT
Prevent SDL from using version 4 of the bitmap header when saving BMPs.
Definition: SDL_hints.h:774
int32_t Sint32
Definition: SDL_stdinc.h:175
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:528
#define BI_BITFIELDS
Definition: SDL_bmp.c:48
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:139
SDL_Color * colors
Definition: SDL_pixels.h:305
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_RWclose(ctx)
Definition: SDL_rwops.h:189
#define SDL_SetError
#define SDL_LockSurface
#define SDL_WriteLE32
#define RW_SEEK_SET
Definition: SDL_rwops.h:174
uint16_t Uint16
Definition: SDL_stdinc.h:169
SDL_Palette * palette
Definition: SDL_pixels.h:316
#define SDL_strcmp
int64_t Sint64
Definition: SDL_stdinc.h:188
static int colors[7]
Definition: testgesture.c:39
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean g
GLboolean GLboolean GLboolean b
#define SDL_RWtell(ctx)
Definition: SDL_rwops.h:186
#define SDL_BYTEORDER
SDL_bool SDL_SetClipRect ( SDL_Surface surface,
const SDL_Rect rect 
)

Sets the clipping rectangle for the destination surface in a blit.

If the clip rectangle is NULL, clipping will be disabled.

If the clip rectangle doesn't intersect the surface, the function will return SDL_FALSE and blits will be completely clipped. Otherwise the function returns SDL_TRUE and blits to the surface will be clipped to the intersection of the surface area and the clipping rectangle.

Note that blits are automatically clipped to the edges of the source and destination surfaces.

Definition at line 505 of file SDL_surface.c.

References SDL_Surface::clip_rect, SDL_Rect::h, SDL_Surface::h, SDL_FALSE, SDL_IntersectRect, SDL_TRUE, SDL_Rect::w, SDL_Surface::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_ConvertSurface(), SDL_CreateRGBSurfaceFrom(), SDL_CreateRGBSurfaceWithFormat(), and SDL_CreateRGBSurfaceWithFormatFrom().

506 {
507  SDL_Rect full_rect;
508 
509  /* Don't do anything if there's no surface to act on */
510  if (!surface) {
511  return SDL_FALSE;
512  }
513 
514  /* Set up the full surface rectangle */
515  full_rect.x = 0;
516  full_rect.y = 0;
517  full_rect.w = surface->w;
518  full_rect.h = surface->h;
519 
520  /* Set the clipping rectangle */
521  if (!rect) {
522  surface->clip_rect = full_rect;
523  return SDL_TRUE;
524  }
525  return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
526 }
#define SDL_IntersectRect
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
SDL_Rect clip_rect
Definition: SDL_surface.h:85
int h
Definition: SDL_rect.h:67
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
int SDL_SetColorKey ( SDL_Surface surface,
int  flag,
Uint32  key 
)

Sets the color key (transparent pixel) in a blittable surface.

Parameters
surfaceThe surface to update
flagNon-zero to enable colorkey and 0 to disable colorkey
keyThe transparent pixel in the native surface format
Returns
0 on success, or -1 if the surface is not valid

You can pass SDL_RLEACCEL to enable RLE accelerated blits.

Definition at line 225 of file SDL_surface.c.

References SDL_Color::a, SDL_BlitInfo::colorkey, SDL_Palette::colors, SDL_BlitInfo::flags, SDL_Surface::format, SDL_BlitMap::info, SDL_Surface::map, SDL_Palette::ncolors, SDL_PixelFormat::palette, SDL_ALPHA_OPAQUE, SDL_ALPHA_TRANSPARENT, SDL_COPY_COLORKEY, SDL_InvalidateMap(), SDL_InvalidParamError, SDL_RLEACCEL, SDL_SetSurfaceRLE(), and SDL_Palette::version.

Referenced by SDL_ConvertColorkeyToAlpha(), and SDL_ConvertSurface().

226 {
227  int flags;
228 
229  if (!surface) {
230  return SDL_InvalidParamError("surface");
231  }
232 
233  if (surface->format->palette && key >= ((Uint32) surface->format->palette->ncolors)) {
234  return SDL_InvalidParamError("key");
235  }
236 
237  if (flag & SDL_RLEACCEL) {
238  SDL_SetSurfaceRLE(surface, 1);
239  }
240 
241  flags = surface->map->info.flags;
242  if (flag) {
243  surface->map->info.flags |= SDL_COPY_COLORKEY;
244  surface->map->info.colorkey = key;
245  if (surface->format->palette) {
246  surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_TRANSPARENT;
247  ++surface->format->palette->version;
248  if (!surface->format->palette->version) {
249  surface->format->palette->version = 1;
250  }
251  }
252  } else {
253  if (surface->format->palette) {
254  surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_OPAQUE;
255  ++surface->format->palette->version;
256  if (!surface->format->palette->version) {
257  surface->format->palette->version = 1;
258  }
259  }
260  surface->map->info.flags &= ~SDL_COPY_COLORKEY;
261  }
262  if (surface->map->info.flags != flags) {
263  SDL_InvalidateMap(surface->map);
264  }
265 
266  return 0;
267 }
Uint32 version
Definition: SDL_pixels.h:306
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag)
Sets the RLE acceleration hint for a surface.
Definition: SDL_surface.c:204
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
Uint32 colorkey
Definition: SDL_blit.h:69
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
#define SDL_ALPHA_TRANSPARENT
Definition: SDL_pixels.h:47
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLuint64 key
Definition: gl2ext.h:2192
Uint8 a
Definition: SDL_pixels.h:298
SDL_Color * colors
Definition: SDL_pixels.h:305
SDL_PixelFormat * format
Definition: SDL_surface.h:72
GLbitfield flags
SDL_Palette * palette
Definition: SDL_pixels.h:316
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:46
SDL_BlitInfo info
Definition: SDL_blit.h:92
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
int SDL_SetSurfaceAlphaMod ( SDL_Surface surface,
Uint8  alpha 
)

Set an additional alpha value used in blit operations.

Parameters
surfaceThe surface to update.
alphaThe alpha value multiplied into blit operations.
Returns
0 on success, or -1 if the surface is not valid.
See also
SDL_GetSurfaceAlphaMod()

Definition at line 403 of file SDL_surface.c.

References SDL_BlitInfo::a, SDL_BlitInfo::flags, SDL_BlitMap::info, SDL_Surface::map, SDL_COPY_MODULATE_ALPHA, and SDL_InvalidateMap().

404 {
405  int flags;
406 
407  if (!surface) {
408  return -1;
409  }
410 
411  surface->map->info.a = alpha;
412 
413  flags = surface->map->info.flags;
414  if (alpha != 0xFF) {
415  surface->map->info.flags |= SDL_COPY_MODULATE_ALPHA;
416  } else {
417  surface->map->info.flags &= ~SDL_COPY_MODULATE_ALPHA;
418  }
419  if (surface->map->info.flags != flags) {
420  SDL_InvalidateMap(surface->map);
421  }
422  return 0;
423 }
GLfloat GLfloat GLfloat alpha
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLbitfield flags
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
SDL_BlitInfo info
Definition: SDL_blit.h:92
Uint8 a
Definition: SDL_blit.h:70
int SDL_SetSurfaceBlendMode ( SDL_Surface surface,
SDL_BlendMode  blendMode 
)

Set the blend mode used for blit operations.

Parameters
surfaceThe surface to update.
blendModeSDL_BlendMode to use for blit blending.
Returns
0 on success, or -1 if the parameters are not valid.
See also
SDL_GetSurfaceBlendMode()

Definition at line 439 of file SDL_surface.c.

References SDL_BlitInfo::flags, SDL_BlitMap::info, SDL_Surface::map, SDL_BLENDMODE_ADD, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD, SDL_BLENDMODE_NONE, SDL_COPY_ADD, SDL_COPY_BLEND, SDL_COPY_MOD, SDL_InvalidateMap(), and SDL_Unsupported.

Referenced by SDL_ConvertColorkeyToAlpha(), SDL_ConvertSurface(), and SDL_CreateRGBSurfaceWithFormat().

440 {
441  int flags, status;
442 
443  if (!surface) {
444  return -1;
445  }
446 
447  status = 0;
448  flags = surface->map->info.flags;
449  surface->map->info.flags &=
451  switch (blendMode) {
452  case SDL_BLENDMODE_NONE:
453  break;
454  case SDL_BLENDMODE_BLEND:
455  surface->map->info.flags |= SDL_COPY_BLEND;
456  break;
457  case SDL_BLENDMODE_ADD:
458  surface->map->info.flags |= SDL_COPY_ADD;
459  break;
460  case SDL_BLENDMODE_MOD:
461  surface->map->info.flags |= SDL_COPY_MOD;
462  break;
463  default:
464  status = SDL_Unsupported();
465  break;
466  }
467 
468  if (surface->map->info.flags != flags) {
469  SDL_InvalidateMap(surface->map);
470  }
471 
472  return status;
473 }
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLbitfield flags
#define SDL_Unsupported()
Definition: SDL_error.h:53
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitInfo info
Definition: SDL_blit.h:92
int SDL_SetSurfaceColorMod ( SDL_Surface surface,
Uint8  r,
Uint8  g,
Uint8  b 
)

Set an additional color value used in blit operations.

Parameters
surfaceThe surface to update.
rThe red color value multiplied into blit operations.
gThe green color value multiplied into blit operations.
bThe blue color value multiplied into blit operations.
Returns
0 on success, or -1 if the surface is not valid.
See also
SDL_GetSurfaceColorMod()

Definition at line 358 of file SDL_surface.c.

References SDL_BlitInfo::b, SDL_BlitInfo::flags, SDL_BlitInfo::g, SDL_BlitMap::info, SDL_Surface::map, SDL_BlitInfo::r, SDL_COPY_MODULATE_COLOR, and SDL_InvalidateMap().

359 {
360  int flags;
361 
362  if (!surface) {
363  return -1;
364  }
365 
366  surface->map->info.r = r;
367  surface->map->info.g = g;
368  surface->map->info.b = b;
369 
370  flags = surface->map->info.flags;
371  if (r != 0xFF || g != 0xFF || b != 0xFF) {
372  surface->map->info.flags |= SDL_COPY_MODULATE_COLOR;
373  } else {
374  surface->map->info.flags &= ~SDL_COPY_MODULATE_COLOR;
375  }
376  if (surface->map->info.flags != flags) {
377  SDL_InvalidateMap(surface->map);
378  }
379  return 0;
380 }
Uint8 r
Definition: SDL_blit.h:70
#define SDL_COPY_MODULATE_COLOR
Definition: SDL_blit.h:34
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Uint8 b
Definition: SDL_blit.h:70
Uint8 g
Definition: SDL_blit.h:70
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLbitfield flags
GLboolean GLboolean g
GLboolean GLboolean GLboolean b
SDL_BlitInfo info
Definition: SDL_blit.h:92
int SDL_SetSurfacePalette ( SDL_Surface surface,
SDL_Palette palette 
)

Set the palette used by a surface.

Returns
0, or -1 if the surface format doesn't use a palette.
Note
A single palette can be shared with many surfaces.

Definition at line 190 of file SDL_surface.c.

References SDL_Surface::format, SDL_Surface::map, SDL_InvalidateMap(), SDL_SetError, and SDL_SetPixelFormatPalette.

Referenced by SDL_ConvertSurface(), SDL_CreateRGBSurfaceWithFormat(), and SDL_FreeSurface().

191 {
192  if (!surface) {
193  return SDL_SetError("SDL_SetSurfacePalette() passed a NULL surface");
194  }
195  if (SDL_SetPixelFormatPalette(surface->format, palette) < 0) {
196  return -1;
197  }
198  SDL_InvalidateMap(surface->map);
199 
200  return 0;
201 }
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_SetError
#define SDL_SetPixelFormatPalette
int SDL_SetSurfaceRLE ( SDL_Surface surface,
int  flag 
)

Sets the RLE acceleration hint for a surface.

Returns
0 on success, or -1 if the surface is not valid
Note
If RLE is enabled, colorkey and alpha blending blits are much faster, but the surface must be locked before directly accessing the pixels.

Definition at line 204 of file SDL_surface.c.

References SDL_BlitInfo::flags, SDL_BlitMap::info, SDL_Surface::map, SDL_COPY_RLE_DESIRED, and SDL_InvalidateMap().

Referenced by SDL_ConvertSurface(), and SDL_SetColorKey().

205 {
206  int flags;
207 
208  if (!surface) {
209  return -1;
210  }
211 
212  flags = surface->map->info.flags;
213  if (flag) {
214  surface->map->info.flags |= SDL_COPY_RLE_DESIRED;
215  } else {
216  surface->map->info.flags &= ~SDL_COPY_RLE_DESIRED;
217  }
218  if (surface->map->info.flags != flags) {
219  SDL_InvalidateMap(surface->map);
220  }
221  return 0;
222 }
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLbitfield flags
SDL_BlitInfo info
Definition: SDL_blit.h:92
int SDL_SoftStretch ( SDL_Surface src,
const SDL_Rect srcrect,
SDL_Surface dst,
const SDL_Rect dstrect 
)

Perform a fast, low quality, stretch blit between two surfaces of the same pixel format.

Note
This function uses a static buffer, and is not thread-safe.

Definition at line 203 of file SDL_stretch.c.

References SDL_PixelFormat::BytesPerPixel, copy_row3(), SDL_Surface::format, SDL_PixelFormat::format, SDL_Rect::h, SDL_Surface::h, NULL, SDL_Surface::pitch, SDL_Surface::pixels, pop, SDL_FALSE, SDL_LockSurface, SDL_MUSTLOCK, SDL_SetError, SDL_TRUE, SDL_UnlockSurface, SDL_Rect::w, SDL_Surface::w, SDL_Rect::x, and SDL_Rect::y.

205 {
206  int src_locked;
207  int dst_locked;
208  int pos, inc;
209  int dst_maxrow;
210  int src_row, dst_row;
211  Uint8 *srcp = NULL;
212  Uint8 *dstp;
213  SDL_Rect full_src;
214  SDL_Rect full_dst;
215 #ifdef USE_ASM_STRETCH
216  SDL_bool use_asm = SDL_TRUE;
217 #ifdef __GNUC__
218  int u1, u2;
219 #endif
220 #endif /* USE_ASM_STRETCH */
221  const int bpp = dst->format->BytesPerPixel;
222 
223  if (src->format->format != dst->format->format) {
224  return SDL_SetError("Only works with same format surfaces");
225  }
226 
227  /* Verify the blit rectangles */
228  if (srcrect) {
229  if ((srcrect->x < 0) || (srcrect->y < 0) ||
230  ((srcrect->x + srcrect->w) > src->w) ||
231  ((srcrect->y + srcrect->h) > src->h)) {
232  return SDL_SetError("Invalid source blit rectangle");
233  }
234  } else {
235  full_src.x = 0;
236  full_src.y = 0;
237  full_src.w = src->w;
238  full_src.h = src->h;
239  srcrect = &full_src;
240  }
241  if (dstrect) {
242  if ((dstrect->x < 0) || (dstrect->y < 0) ||
243  ((dstrect->x + dstrect->w) > dst->w) ||
244  ((dstrect->y + dstrect->h) > dst->h)) {
245  return SDL_SetError("Invalid destination blit rectangle");
246  }
247  } else {
248  full_dst.x = 0;
249  full_dst.y = 0;
250  full_dst.w = dst->w;
251  full_dst.h = dst->h;
252  dstrect = &full_dst;
253  }
254 
255  /* Lock the destination if it's in hardware */
256  dst_locked = 0;
257  if (SDL_MUSTLOCK(dst)) {
258  if (SDL_LockSurface(dst) < 0) {
259  return SDL_SetError("Unable to lock destination surface");
260  }
261  dst_locked = 1;
262  }
263  /* Lock the source if it's in hardware */
264  src_locked = 0;
265  if (SDL_MUSTLOCK(src)) {
266  if (SDL_LockSurface(src) < 0) {
267  if (dst_locked) {
268  SDL_UnlockSurface(dst);
269  }
270  return SDL_SetError("Unable to lock source surface");
271  }
272  src_locked = 1;
273  }
274 
275  /* Set up the data... */
276  pos = 0x10000;
277  inc = (srcrect->h << 16) / dstrect->h;
278  src_row = srcrect->y;
279  dst_row = dstrect->y;
280 
281 #ifdef USE_ASM_STRETCH
282  /* Write the opcodes for this stretch */
283  if ((bpp == 3) || (generate_rowbytes(srcrect->w, dstrect->w, bpp) < 0)) {
284  use_asm = SDL_FALSE;
285  }
286 #endif
287 
288  /* Perform the stretch blit */
289  for (dst_maxrow = dst_row + dstrect->h; dst_row < dst_maxrow; ++dst_row) {
290  dstp = (Uint8 *) dst->pixels + (dst_row * dst->pitch)
291  + (dstrect->x * bpp);
292  while (pos >= 0x10000L) {
293  srcp = (Uint8 *) src->pixels + (src_row * src->pitch)
294  + (srcrect->x * bpp);
295  ++src_row;
296  pos -= 0x10000L;
297  }
298 #ifdef USE_ASM_STRETCH
299  if (use_asm) {
300 #ifdef __GNUC__
301  __asm__ __volatile__("call *%4":"=&D"(u1), "=&S"(u2)
302  :"0"(dstp), "1"(srcp), "r"(copy_row)
303  :"memory");
304 #elif defined(_MSC_VER) || defined(__WATCOMC__)
305  /* *INDENT-OFF* */
306  {
307  void *code = copy_row;
308  __asm {
309  push edi
310  push esi
311  mov edi, dstp
312  mov esi, srcp
313  call dword ptr code
314  pop esi
315  pop edi
316  }
317  }
318  /* *INDENT-ON* */
319 #else
320 #error Need inline assembly for this compiler
321 #endif
322  } else
323 #endif
324  switch (bpp) {
325  case 1:
326  copy_row1(srcp, srcrect->w, dstp, dstrect->w);
327  break;
328  case 2:
329  copy_row2((Uint16 *) srcp, srcrect->w,
330  (Uint16 *) dstp, dstrect->w);
331  break;
332  case 3:
333  copy_row3(srcp, srcrect->w, dstp, dstrect->w);
334  break;
335  case 4:
336  copy_row4((Uint32 *) srcp, srcrect->w,
337  (Uint32 *) dstp, dstrect->w);
338  break;
339  }
340  pos += inc;
341  }
342 
343  /* We need to unlock the surfaces if they're locked */
344  if (dst_locked) {
345  SDL_UnlockSurface(dst);
346  }
347  if (src_locked) {
348  SDL_UnlockSurface(src);
349  }
350  return (0);
351 }
#define SDL_UnlockSurface
Uint8 BytesPerPixel
Definition: SDL_pixels.h:318
GLfixed u1
uint32_t Uint32
Definition: SDL_stdinc.h:181
static void copy_row3(Uint8 *src, int src_w, Uint8 *dst, int dst_w)
Definition: SDL_stretch.c:177
GLfixed GLfixed u2
void * pixels
Definition: SDL_surface.h:75
uint8_t Uint8
Definition: SDL_stdinc.h:157
#define pop
Definition: SDL_qsort.c:192
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:139
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_SetError
#define SDL_LockSurface
#define SDL_MUSTLOCK(S)
Definition: SDL_surface.h:61
int h
Definition: SDL_rect.h:67
uint16_t Uint16
Definition: SDL_stdinc.h:169
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
void SDL_UnlockSurface ( SDL_Surface surface)
See also
SDL_LockSurface()

Definition at line 872 of file SDL_surface.c.

References SDL_Surface::flags, SDL_Surface::locked, SDL_RLEACCEL, and SDL_RLESurface().

Referenced by SDL_ConvertColorkeyToAlpha(), and SDL_FreeSurface().

873 {
874  /* Only perform an unlock if we are locked */
875  if (!surface->locked || (--surface->locked > 0)) {
876  return;
877  }
878 
879  /* Update RLE encoded surface with new data */
880  if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
881  surface->flags &= ~SDL_RLEACCEL; /* stop lying */
882  SDL_RLESurface(surface);
883  }
884 }
Uint32 flags
Definition: SDL_surface.h:71
int SDL_RLESurface(SDL_Surface *surface)
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
int SDL_UpperBlit ( SDL_Surface src,
const SDL_Rect srcrect,
SDL_Surface dst,
SDL_Rect dstrect 
)

This is the public blit function, SDL_BlitSurface(), and it performs rectangle validation and clipping before passing it to SDL_LowerBlit()

Definition at line 571 of file SDL_surface.c.

References SDL_Surface::clip_rect, SDL_BlitInfo::flags, SDL_Rect::h, SDL_Surface::h, SDL_BlitMap::info, SDL_Surface::locked, SDL_Surface::map, NULL, SDL_COPY_NEAREST, SDL_InvalidateMap(), SDL_LowerBlit(), SDL_SetError, SDL_Rect::w, SDL_Surface::w, SDL_Rect::x, and SDL_Rect::y.

573 {
574  SDL_Rect fulldst;
575  int srcx, srcy, w, h;
576 
577  /* Make sure the surfaces aren't locked */
578  if (!src || !dst) {
579  return SDL_SetError("SDL_UpperBlit: passed a NULL surface");
580  }
581  if (src->locked || dst->locked) {
582  return SDL_SetError("Surfaces must not be locked during blit");
583  }
584 
585  /* If the destination rectangle is NULL, use the entire dest surface */
586  if (dstrect == NULL) {
587  fulldst.x = fulldst.y = 0;
588  fulldst.w = dst->w;
589  fulldst.h = dst->h;
590  dstrect = &fulldst;
591  }
592 
593  /* clip the source rectangle to the source surface */
594  if (srcrect) {
595  int maxw, maxh;
596 
597  srcx = srcrect->x;
598  w = srcrect->w;
599  if (srcx < 0) {
600  w += srcx;
601  dstrect->x -= srcx;
602  srcx = 0;
603  }
604  maxw = src->w - srcx;
605  if (maxw < w)
606  w = maxw;
607 
608  srcy = srcrect->y;
609  h = srcrect->h;
610  if (srcy < 0) {
611  h += srcy;
612  dstrect->y -= srcy;
613  srcy = 0;
614  }
615  maxh = src->h - srcy;
616  if (maxh < h)
617  h = maxh;
618 
619  } else {
620  srcx = srcy = 0;
621  w = src->w;
622  h = src->h;
623  }
624 
625  /* clip the destination rectangle against the clip rectangle */
626  {
627  SDL_Rect *clip = &dst->clip_rect;
628  int dx, dy;
629 
630  dx = clip->x - dstrect->x;
631  if (dx > 0) {
632  w -= dx;
633  dstrect->x += dx;
634  srcx += dx;
635  }
636  dx = dstrect->x + w - clip->x - clip->w;
637  if (dx > 0)
638  w -= dx;
639 
640  dy = clip->y - dstrect->y;
641  if (dy > 0) {
642  h -= dy;
643  dstrect->y += dy;
644  srcy += dy;
645  }
646  dy = dstrect->y + h - clip->y - clip->h;
647  if (dy > 0)
648  h -= dy;
649  }
650 
651  /* Switch back to a fast blit if we were previously stretching */
652  if (src->map->info.flags & SDL_COPY_NEAREST) {
653  src->map->info.flags &= ~SDL_COPY_NEAREST;
654  SDL_InvalidateMap(src->map);
655  }
656 
657  if (w > 0 && h > 0) {
658  SDL_Rect sr;
659  sr.x = srcx;
660  sr.y = srcy;
661  sr.w = dstrect->w = w;
662  sr.h = dstrect->h = h;
663  return SDL_LowerBlit(src, &sr, dst, dstrect);
664  }
665  dstrect->w = dstrect->h = 0;
666  return 0;
667 }
GLfloat GLfloat GLfloat GLfloat h
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:548
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:981
#define SDL_COPY_NEAREST
Definition: SDL_blit.h:40
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLubyte GLubyte GLubyte GLubyte w
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
SDL_Rect clip_rect
Definition: SDL_surface.h:85
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
int h
Definition: SDL_rect.h:67
int y
Definition: SDL_rect.h:66
SDL_BlitInfo info
Definition: SDL_blit.h:92
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
int SDL_UpperBlitScaled ( SDL_Surface src,
const SDL_Rect srcrect,
SDL_Surface dst,
SDL_Rect dstrect 
)

This is the public scaled blit function, SDL_BlitScaled(), and it performs rectangle validation and clipping before passing it to SDL_LowerBlitScaled()

Definition at line 670 of file SDL_surface.c.

References SDL_Surface::clip_rect, SDL_Rect::h, SDL_Surface::h, SDL_Surface::locked, NULL, SDL_BlitSurface, SDL_floor, SDL_LowerBlitScaled(), SDL_SetError, SDL_Rect::w, SDL_Surface::w, SDL_Rect::x, and SDL_Rect::y.

672 {
673  double src_x0, src_y0, src_x1, src_y1;
674  double dst_x0, dst_y0, dst_x1, dst_y1;
675  SDL_Rect final_src, final_dst;
676  double scaling_w, scaling_h;
677  int src_w, src_h;
678  int dst_w, dst_h;
679 
680  /* Make sure the surfaces aren't locked */
681  if (!src || !dst) {
682  return SDL_SetError("SDL_UpperBlitScaled: passed a NULL surface");
683  }
684  if (src->locked || dst->locked) {
685  return SDL_SetError("Surfaces must not be locked during blit");
686  }
687 
688  if (NULL == srcrect) {
689  src_w = src->w;
690  src_h = src->h;
691  } else {
692  src_w = srcrect->w;
693  src_h = srcrect->h;
694  }
695 
696  if (NULL == dstrect) {
697  dst_w = dst->w;
698  dst_h = dst->h;
699  } else {
700  dst_w = dstrect->w;
701  dst_h = dstrect->h;
702  }
703 
704  if (dst_w == src_w && dst_h == src_h) {
705  /* No scaling, defer to regular blit */
706  return SDL_BlitSurface(src, srcrect, dst, dstrect);
707  }
708 
709  scaling_w = (double)dst_w / src_w;
710  scaling_h = (double)dst_h / src_h;
711 
712  if (NULL == dstrect) {
713  dst_x0 = 0;
714  dst_y0 = 0;
715  dst_x1 = dst_w - 1;
716  dst_y1 = dst_h - 1;
717  } else {
718  dst_x0 = dstrect->x;
719  dst_y0 = dstrect->y;
720  dst_x1 = dst_x0 + dst_w - 1;
721  dst_y1 = dst_y0 + dst_h - 1;
722  }
723 
724  if (NULL == srcrect) {
725  src_x0 = 0;
726  src_y0 = 0;
727  src_x1 = src_w - 1;
728  src_y1 = src_h - 1;
729  } else {
730  src_x0 = srcrect->x;
731  src_y0 = srcrect->y;
732  src_x1 = src_x0 + src_w - 1;
733  src_y1 = src_y0 + src_h - 1;
734 
735  /* Clip source rectangle to the source surface */
736 
737  if (src_x0 < 0) {
738  dst_x0 -= src_x0 * scaling_w;
739  src_x0 = 0;
740  }
741 
742  if (src_x1 >= src->w) {
743  dst_x1 -= (src_x1 - src->w + 1) * scaling_w;
744  src_x1 = src->w - 1;
745  }
746 
747  if (src_y0 < 0) {
748  dst_y0 -= src_y0 * scaling_h;
749  src_y0 = 0;
750  }
751 
752  if (src_y1 >= src->h) {
753  dst_y1 -= (src_y1 - src->h + 1) * scaling_h;
754  src_y1 = src->h - 1;
755  }
756  }
757 
758  /* Clip destination rectangle to the clip rectangle */
759 
760  /* Translate to clip space for easier calculations */
761  dst_x0 -= dst->clip_rect.x;
762  dst_x1 -= dst->clip_rect.x;
763  dst_y0 -= dst->clip_rect.y;
764  dst_y1 -= dst->clip_rect.y;
765 
766  if (dst_x0 < 0) {
767  src_x0 -= dst_x0 / scaling_w;
768  dst_x0 = 0;
769  }
770 
771  if (dst_x1 >= dst->clip_rect.w) {
772  src_x1 -= (dst_x1 - dst->clip_rect.w + 1) / scaling_w;
773  dst_x1 = dst->clip_rect.w - 1;
774  }
775 
776  if (dst_y0 < 0) {
777  src_y0 -= dst_y0 / scaling_h;
778  dst_y0 = 0;
779  }
780 
781  if (dst_y1 >= dst->clip_rect.h) {
782  src_y1 -= (dst_y1 - dst->clip_rect.h + 1) / scaling_h;
783  dst_y1 = dst->clip_rect.h - 1;
784  }
785 
786  /* Translate back to surface coordinates */
787  dst_x0 += dst->clip_rect.x;
788  dst_x1 += dst->clip_rect.x;
789  dst_y0 += dst->clip_rect.y;
790  dst_y1 += dst->clip_rect.y;
791 
792  final_src.x = (int)SDL_floor(src_x0 + 0.5);
793  final_src.y = (int)SDL_floor(src_y0 + 0.5);
794  final_src.w = (int)SDL_floor(src_x1 + 1 + 0.5) - (int)SDL_floor(src_x0 + 0.5);
795  final_src.h = (int)SDL_floor(src_y1 + 1 + 0.5) - (int)SDL_floor(src_y0 + 0.5);
796 
797  final_dst.x = (int)SDL_floor(dst_x0 + 0.5);
798  final_dst.y = (int)SDL_floor(dst_y0 + 0.5);
799  final_dst.w = (int)SDL_floor(dst_x1 - dst_x0 + 1.5);
800  final_dst.h = (int)SDL_floor(dst_y1 - dst_y0 + 1.5);
801 
802  if (final_dst.w < 0)
803  final_dst.w = 0;
804  if (final_dst.h < 0)
805  final_dst.h = 0;
806 
807  if (dstrect)
808  *dstrect = final_dst;
809 
810  if (final_dst.w == 0 || final_dst.h == 0 ||
811  final_src.w <= 0 || final_src.h <= 0) {
812  /* No-op. */
813  return 0;
814  }
815 
816  return SDL_LowerBlitScaled(src, &final_src, dst, &final_dst);
817 }
#define SDL_BlitSurface
Definition: SDL_surface.h:465
#define SDL_floor
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
SDL_Rect clip_rect
Definition: SDL_surface.h:85
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
int h
Definition: SDL_rect.h:67
int SDL_LowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:824
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64