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...
 

Enumerations

enum  SDL_YUV_CONVERSION_MODE {
  SDL_YUV_CONVERSION_JPEG,
  SDL_YUV_CONVERSION_BT601,
  SDL_YUV_CONVERSION_BT709,
  SDL_YUV_CONVERSION_AUTOMATIC
}
 The formula used for converting between YUV and RGB. 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...
 
SDL_bool SDL_HasColorKey (SDL_Surface *surface)
 Returns whether the surface has a color key. 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)
 
void SDL_SetYUVConversionMode (SDL_YUV_CONVERSION_MODE mode)
 Set the YUV conversion mode. More...
 
SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionMode (void)
 Get the YUV conversion mode. More...
 
SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionModeForResolution (int width, int height)
 Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC. More...
 

Detailed Description

Header file for SDL_Surface definition and management functions.

Definition in file SDL_surface.h.

Macro Definition Documentation

◆ SDL_BlitScaled

#define SDL_BlitScaled   SDL_UpperBlitScaled

Definition at line 512 of file SDL_surface.h.

Referenced by SW_RenderCopy(), and SW_RenderCopyEx().

◆ SDL_BlitSurface

#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 483 of file SDL_surface.h.

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

◆ SDL_DONTFREE

#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().

◆ SDL_LoadBMP

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

Load a surface from a file.

Convenience macro.

Definition at line 200 of file SDL_surface.h.

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

◆ SDL_MUSTLOCK

#define SDL_MUSTLOCK (   S)    (((S)->flags & SDL_RLEACCEL) != 0)

◆ SDL_PREALLOC

#define SDL_PREALLOC   0x00000001

◆ SDL_RLEACCEL

◆ SDL_SaveBMP

#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 223 of file SDL_surface.h.

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

◆ SDL_SWSURFACE

#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

◆ SDL_blit

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.

Enumeration Type Documentation

◆ SDL_YUV_CONVERSION_MODE

The formula used for converting between YUV and RGB.

Enumerator
SDL_YUV_CONVERSION_JPEG 

Full range JPEG

SDL_YUV_CONVERSION_BT601 

BT.601 (the default)

SDL_YUV_CONVERSION_BT709 

BT.709

SDL_YUV_CONVERSION_AUTOMATIC 

BT.601 for SD content, BT.709 for HD content

Definition at line 103 of file SDL_surface.h.

104 {
105  SDL_YUV_CONVERSION_JPEG, /**< Full range JPEG */
106  SDL_YUV_CONVERSION_BT601, /**< BT.601 (the default) */
107  SDL_YUV_CONVERSION_BT709, /**< BT.709 */
108  SDL_YUV_CONVERSION_AUTOMATIC /**< BT.601 for SD content, BT.709 for HD content */
SDL_YUV_CONVERSION_MODE
The formula used for converting between YUV and RGB.
Definition: SDL_surface.h:103

Function Documentation

◆ SDL_ConvertPixels()

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 1152 of file SDL_surface.c.

References SDL_Rect::h, i, rect, SDL_BYTESPERPIXEL, SDL_ConvertPixels_RGB_to_YUV(), SDL_ConvertPixels_YUV_to_RGB(), SDL_ConvertPixels_YUV_to_YUV(), SDL_CreateSurfaceOnStack(), SDL_InvalidParamError, SDL_ISPIXELFORMAT_FOURCC, SDL_LowerBlit(), SDL_memcpy, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

1155 {
1156  SDL_Surface src_surface, dst_surface;
1157  SDL_PixelFormat src_fmt, dst_fmt;
1158  SDL_BlitMap src_blitmap, dst_blitmap;
1159  SDL_Rect rect;
1160  void *nonconst_src = (void *) src;
1161 
1162  /* Check to make sure we are blitting somewhere, so we don't crash */
1163  if (!dst) {
1164  return SDL_InvalidParamError("dst");
1165  }
1166  if (!dst_pitch) {
1167  return SDL_InvalidParamError("dst_pitch");
1168  }
1169 
1170  if (SDL_ISPIXELFORMAT_FOURCC(src_format) && SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
1171  return SDL_ConvertPixels_YUV_to_YUV(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
1172  } else if (SDL_ISPIXELFORMAT_FOURCC(src_format)) {
1173  return SDL_ConvertPixels_YUV_to_RGB(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
1174  } else if (SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
1175  return SDL_ConvertPixels_RGB_to_YUV(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
1176  }
1177 
1178  /* Fast path for same format copy */
1179  if (src_format == dst_format) {
1180  int i;
1181  const int bpp = SDL_BYTESPERPIXEL(src_format);
1182  width *= bpp;
1183  for (i = height; i--;) {
1184  SDL_memcpy(dst, src, width);
1185  src = (const Uint8*)src + src_pitch;
1186  dst = (Uint8*)dst + dst_pitch;
1187  }
1188  return 0;
1189  }
1190 
1191  if (!SDL_CreateSurfaceOnStack(width, height, src_format, nonconst_src,
1192  src_pitch,
1193  &src_surface, &src_fmt, &src_blitmap)) {
1194  return -1;
1195  }
1196  if (!SDL_CreateSurfaceOnStack(width, height, dst_format, dst, dst_pitch,
1197  &dst_surface, &dst_fmt, &dst_blitmap)) {
1198  return -1;
1199  }
1200 
1201  /* Set up the rect and go! */
1202  rect.x = 0;
1203  rect.y = 0;
1204  rect.w = width;
1205  rect.h = height;
1206  return SDL_LowerBlit(&src_surface, &rect, &dst_surface, &rect);
1207 }
int SDL_ConvertPixels_YUV_to_YUV(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Definition: SDL_yuv.c:1810
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:1114
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:588
int SDL_ConvertPixels_YUV_to_RGB(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Definition: SDL_yuv.c:395
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
#define SDL_memcpy
uint8_t Uint8
Definition: SDL_stdinc.h:179
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
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 height
Definition: SDL_opengl.h:1572
int h
Definition: SDL_rect.h:67
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
int SDL_ConvertPixels_RGB_to_YUV(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Definition: SDL_yuv.c:784
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

◆ SDL_ConvertSurface()

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 939 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().

941 {
942  SDL_Surface *convert;
943  Uint32 copy_flags;
944  SDL_Color copy_color;
945  SDL_Rect bounds;
946 
947  if (!surface) {
948  SDL_InvalidParamError("surface");
949  return NULL;
950  }
951  if (!format) {
952  SDL_InvalidParamError("format");
953  return NULL;
954  }
955 
956  /* Check for empty destination palette! (results in empty image) */
957  if (format->palette != NULL) {
958  int i;
959  for (i = 0; i < format->palette->ncolors; ++i) {
960  if ((format->palette->colors[i].r != 0xFF) ||
961  (format->palette->colors[i].g != 0xFF) ||
962  (format->palette->colors[i].b != 0xFF))
963  break;
964  }
965  if (i == format->palette->ncolors) {
966  SDL_SetError("Empty destination palette");
967  return (NULL);
968  }
969  }
970 
971  /* Create a new surface with the desired format */
972  convert = SDL_CreateRGBSurface(flags, surface->w, surface->h,
973  format->BitsPerPixel, format->Rmask,
974  format->Gmask, format->Bmask,
975  format->Amask);
976  if (convert == NULL) {
977  return (NULL);
978  }
979 
980  /* Copy the palette if any */
981  if (format->palette && convert->format->palette) {
982  SDL_memcpy(convert->format->palette->colors,
983  format->palette->colors,
984  format->palette->ncolors * sizeof(SDL_Color));
985  convert->format->palette->ncolors = format->palette->ncolors;
986  }
987 
988  /* Save the original copy flags */
989  copy_flags = surface->map->info.flags;
990  copy_color.r = surface->map->info.r;
991  copy_color.g = surface->map->info.g;
992  copy_color.b = surface->map->info.b;
993  copy_color.a = surface->map->info.a;
994  surface->map->info.r = 0xFF;
995  surface->map->info.g = 0xFF;
996  surface->map->info.b = 0xFF;
997  surface->map->info.a = 0xFF;
998  surface->map->info.flags = 0;
1000 
1001  /* Copy over the image data */
1002  bounds.x = 0;
1003  bounds.y = 0;
1004  bounds.w = surface->w;
1005  bounds.h = surface->h;
1006  SDL_LowerBlit(surface, &bounds, convert, &bounds);
1007 
1008  /* Clean up the original surface, and update converted surface */
1009  convert->map->info.r = copy_color.r;
1010  convert->map->info.g = copy_color.g;
1011  convert->map->info.b = copy_color.b;
1012  convert->map->info.a = copy_color.a;
1013  convert->map->info.flags =
1014  (copy_flags &
1018  surface->map->info.r = copy_color.r;
1019  surface->map->info.g = copy_color.g;
1020  surface->map->info.b = copy_color.b;
1021  surface->map->info.a = copy_color.a;
1022  surface->map->info.flags = copy_flags;
1023  SDL_InvalidateMap(surface->map);
1024  if (copy_flags & SDL_COPY_COLORKEY) {
1025  SDL_bool set_colorkey_by_color = SDL_FALSE;
1026 
1027  if (surface->format->palette) {
1028  if (format->palette &&
1029  surface->format->palette->ncolors <= format->palette->ncolors &&
1030  (SDL_memcmp(surface->format->palette->colors, format->palette->colors,
1031  surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) {
1032  /* The palette is identical, just set the same colorkey */
1033  SDL_SetColorKey(convert, 1, surface->map->info.colorkey);
1034  } else if (format->Amask) {
1035  /* The alpha was set in the destination from the palette */
1036  } else {
1037  set_colorkey_by_color = SDL_TRUE;
1038  }
1039  } else {
1040  set_colorkey_by_color = SDL_TRUE;
1041  }
1042 
1043  if (set_colorkey_by_color) {
1044  SDL_Surface *tmp;
1045  SDL_Surface *tmp2;
1046  int converted_colorkey = 0;
1047 
1048  /* Create a dummy surface to get the colorkey converted */
1049  tmp = SDL_CreateRGBSurface(0, 1, 1,
1050  surface->format->BitsPerPixel, surface->format->Rmask,
1051  surface->format->Gmask, surface->format->Bmask,
1052  surface->format->Amask);
1053 
1054  /* Share the palette, if any */
1055  if (surface->format->palette) {
1057  }
1058 
1059  SDL_FillRect(tmp, NULL, surface->map->info.colorkey);
1060 
1061  tmp->map->info.flags &= ~SDL_COPY_COLORKEY;
1062 
1063  /* Convertion of the colorkey */
1064  tmp2 = SDL_ConvertSurface(tmp, format, 0);
1065 
1066  /* Get the converted colorkey */
1067  SDL_memcpy(&converted_colorkey, tmp2->pixels, tmp2->format->BytesPerPixel);
1068 
1069  SDL_FreeSurface(tmp);
1070  SDL_FreeSurface(tmp2);
1071 
1072  /* Set the converted colorkey on the new surface */
1073  SDL_SetColorKey(convert, 1, converted_colorkey);
1074 
1075  /* This is needed when converting for 3D texture upload */
1076  SDL_ConvertColorkeyToAlpha(convert);
1077  }
1078  }
1079  SDL_SetClipRect(convert, &surface->clip_rect);
1080 
1081  /* Enable alpha blending by default if the new surface has an
1082  * alpha channel or alpha modulation */
1083  if ((surface->format->Amask && format->Amask) ||
1084  (copy_flags & SDL_COPY_MODULATE_ALPHA)) {
1086  }
1087  if ((copy_flags & SDL_COPY_RLE_DESIRED) || (flags & SDL_RLEACCEL)) {
1088  SDL_SetSurfaceRLE(convert, SDL_RLEACCEL);
1089  }
1090 
1091  /* We're ready to go! */
1092  return (convert);
1093 }
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:545
#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:230
Uint8 g
Definition: SDL_pixels.h:298
Uint8 BytesPerPixel
Definition: SDL_pixels.h:320
Uint8 g
Definition: SDL_blit.h:70
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:939
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:479
static void SDL_ConvertColorkeyToAlpha(SDL_Surface *surface)
Definition: SDL_surface.c:328
Uint8 b
Definition: SDL_pixels.h:299
#define SDL_COPY_RLE_COLORKEY
Definition: SDL_blit.h:42
#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:588
int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key)
Sets the color key (transparent pixel) in a blittable surface.
Definition: SDL_surface.c:251
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:972
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:297
void * pixels
Definition: SDL_surface.h:75
Uint8 a
Definition: SDL_pixels.h:300
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:216
#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:1213
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 NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:161
SDL_Color * colors
Definition: SDL_pixels.h:307
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:153
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
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define SDL_FillRect
SDL_Palette * palette
Definition: SDL_pixels.h:318
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_ConvertSurfaceFormat()

SDL_Surface* SDL_ConvertSurfaceFormat ( SDL_Surface src,
Uint32  pixel_format,
Uint32  flags 
)

Definition at line 1096 of file SDL_surface.c.

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

1098 {
1099  SDL_PixelFormat *fmt;
1100  SDL_Surface *convert = NULL;
1101 
1102  fmt = SDL_AllocFormat(pixel_format);
1103  if (fmt) {
1104  convert = SDL_ConvertSurface(surface, fmt, flags);
1105  SDL_FreeFormat(fmt);
1106  }
1107  return convert;
1108 }
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:939
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

◆ SDL_CreateRGBSurface()

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 153 of file SDL_surface.c.

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

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceFrom().

156 {
157  Uint32 format;
158 
159  /* Get the pixel format */
160  format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
161  if (format == SDL_PIXELFORMAT_UNKNOWN) {
162  SDL_SetError("Unknown pixel format");
163  return NULL;
164  }
165 
167 }
#define SDL_MasksToPixelFormatEnum
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:66
#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
uint32_t Uint32
Definition: SDL_stdinc.h:203

◆ SDL_CreateRGBSurfaceFrom()

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 173 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.

177 {
179 
180  surface = SDL_CreateRGBSurface(0, 0, 0, depth, Rmask, Gmask, Bmask, Amask);
181  if (surface != NULL) {
182  surface->flags |= SDL_PREALLOC;
183  surface->pixels = pixels;
184  surface->w = width;
185  surface->h = height;
186  surface->pitch = pitch;
187  SDL_SetClipRect(surface, NULL);
188  }
189  return surface;
190 }
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:545
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:153
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
#define SDL_PREALLOC
Definition: SDL_surface.h:53

◆ SDL_CreateRGBSurfaceWithFormat()

SDL_Surface* SDL_CreateRGBSurfaceWithFormat ( Uint32  flags,
int  width,
int  height,
int  depth,
Uint32  format 
)

Definition at line 66 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().

68 {
70 
71  /* The flags are no longer used, make the compiler happy */
72  (void)flags;
73 
74  /* Allocate the surface */
75  surface = (SDL_Surface *) SDL_calloc(1, sizeof(*surface));
76  if (surface == NULL) {
78  return NULL;
79  }
80 
81  surface->format = SDL_AllocFormat(format);
82  if (!surface->format) {
83  SDL_FreeSurface(surface);
84  return NULL;
85  }
86  surface->w = width;
87  surface->h = height;
88  surface->pitch = SDL_CalculatePitch(format, width);
89  SDL_SetClipRect(surface, NULL);
90 
91  if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
92  SDL_Palette *palette =
93  SDL_AllocPalette((1 << surface->format->BitsPerPixel));
94  if (!palette) {
95  SDL_FreeSurface(surface);
96  return NULL;
97  }
98  if (palette->ncolors == 2) {
99  /* Create a black and white bitmap palette */
100  palette->colors[0].r = 0xFF;
101  palette->colors[0].g = 0xFF;
102  palette->colors[0].b = 0xFF;
103  palette->colors[1].r = 0x00;
104  palette->colors[1].g = 0x00;
105  palette->colors[1].b = 0x00;
106  }
107  SDL_SetSurfacePalette(surface, palette);
108  SDL_FreePalette(palette);
109  }
110 
111  /* Get the pixels */
112  if (surface->w && surface->h) {
113  /* Assumptions checked in surface_size_assumptions assert above */
114  Sint64 size = ((Sint64)surface->h * surface->pitch);
116  /* Overflow... */
117  SDL_FreeSurface(surface);
118  SDL_OutOfMemory();
119  return NULL;
120  }
121 
122  surface->pixels = SDL_malloc((size_t)size);
123  if (!surface->pixels) {
124  SDL_FreeSurface(surface);
125  SDL_OutOfMemory();
126  return NULL;
127  }
128  /* This is important for bitmaps */
129  SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
130  }
131 
132  /* Allocate an empty mapping */
133  surface->map = SDL_AllocBlitMap();
134  if (!surface->map) {
135  SDL_FreeSurface(surface);
136  return NULL;
137  }
138 
139  /* By default surface with an alpha mask are set up for blending */
140  if (surface->format->Amask) {
142  }
143 
144  /* The surface is ready to go */
145  surface->refcount = 1;
146  return surface;
147 }
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:545
static int SDL_CalculatePitch(Uint32 format, int width)
Definition: SDL_surface.c:41
Uint8 g
Definition: SDL_pixels.h:298
#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:479
Uint8 b
Definition: SDL_pixels.h:299
#define SDL_AllocFormat
#define SDL_MAX_SINT32
A signed 32-bit integer type.
Definition: SDL_stdinc.h:195
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
Uint8 r
Definition: SDL_pixels.h:297
void * pixels
Definition: SDL_surface.h:75
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:216
GLsizeiptr size
#define SDL_AllocPalette
void SDL_FreeSurface(SDL_Surface *surface)
Definition: SDL_surface.c:1213
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_FreePalette
GLbitfield flags
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
#define SDL_calloc
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:952
#define SDL_malloc
int64_t Sint64
Definition: SDL_stdinc.h:210
#define SDL_memset

◆ SDL_CreateRGBSurfaceWithFormatFrom()

SDL_Surface* SDL_CreateRGBSurfaceWithFormatFrom ( void pixels,
int  width,
int  height,
int  depth,
int  pitch,
Uint32  format 
)

Definition at line 197 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.

200 {
202 
203  surface = SDL_CreateRGBSurfaceWithFormat(0, 0, 0, depth, format);
204  if (surface != NULL) {
205  surface->flags |= SDL_PREALLOC;
206  surface->pixels = pixels;
207  surface->w = width;
208  surface->h = height;
209  surface->pitch = pitch;
210  SDL_SetClipRect(surface, NULL);
211  }
212  return surface;
213 }
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:545
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:66
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_DuplicateSurface()

SDL_Surface* SDL_DuplicateSurface ( SDL_Surface surface)

Definition at line 930 of file SDL_surface.c.

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

931 {
932  return SDL_ConvertSurface(surface, surface->format, surface->flags);
933 }
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:939
Uint32 flags
Definition: SDL_surface.h:71
SDL_PixelFormat * format
Definition: SDL_surface.h:72

◆ SDL_FillRect()

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:320
#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:179
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319
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

◆ SDL_FillRects()

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

◆ SDL_FreeSurface()

void SDL_FreeSurface ( SDL_Surface surface)

Definition at line 1213 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_InvalidateMap(), SDL_PREALLOC, SDL_RLEACCEL, SDL_SetSurfacePalette(), SDL_UnlockSurface(), and SDL_UnRLESurface().

Referenced by SDL_ConvertSurface(), and SDL_CreateRGBSurfaceWithFormat().

1214 {
1215  if (surface == NULL) {
1216  return;
1217  }
1218  if (surface->flags & SDL_DONTFREE) {
1219  return;
1220  }
1221  SDL_InvalidateMap(surface->map);
1222 
1223  if (--surface->refcount > 0) {
1224  return;
1225  }
1226  while (surface->locked > 0) {
1227  SDL_UnlockSurface(surface);
1228  }
1229  if (surface->flags & SDL_RLEACCEL) {
1230  SDL_UnRLESurface(surface, 0);
1231  }
1232  if (surface->format) {
1233  SDL_SetSurfacePalette(surface, NULL);
1234  SDL_FreeFormat(surface->format);
1235  surface->format = NULL;
1236  }
1237  if (!(surface->flags & SDL_PREALLOC)) {
1238  SDL_free(surface->pixels);
1239  }
1240  if (surface->map) {
1241  SDL_FreeBlitMap(surface->map);
1242  }
1243  SDL_free(surface);
1244 }
void SDL_UnlockSurface(SDL_Surface *surface)
Definition: SDL_surface.c:912
#define SDL_DONTFREE
Definition: SDL_surface.h:55
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Uint32 flags
Definition: SDL_surface.h:71
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
void * pixels
Definition: SDL_surface.h:75
#define SDL_free
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:216
#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:1077
#define SDL_PREALLOC
Definition: SDL_surface.h:53
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

◆ SDL_GetClipRect()

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 569 of file SDL_surface.c.

References SDL_Surface::clip_rect.

570 {
571  if (surface && rect) {
572  *rect = surface->clip_rect;
573  }
574 }
SDL_Rect clip_rect
Definition: SDL_surface.h:85

◆ SDL_GetColorKey()

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 310 of file SDL_surface.c.

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

311 {
312  if (!surface) {
313  return SDL_InvalidParamError("surface");
314  }
315 
316  if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
317  return SDL_SetError("Surface doesn't have a colorkey");
318  }
319 
320  if (key) {
321  *key = surface->map->info.colorkey;
322  }
323  return 0;
324 }
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
Uint32 colorkey
Definition: SDL_blit.h:69
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLuint64 key
Definition: gl2ext.h:2192
#define SDL_SetError
SDL_BlitInfo info
Definition: SDL_blit.h:92

◆ SDL_GetSurfaceAlphaMod()

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 466 of file SDL_surface.c.

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

467 {
468  if (!surface) {
469  return -1;
470  }
471 
472  if (alpha) {
473  *alpha = surface->map->info.a;
474  }
475  return 0;
476 }
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

◆ SDL_GetSurfaceBlendMode()

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 516 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.

517 {
518  if (!surface) {
519  return -1;
520  }
521 
522  if (!blendMode) {
523  return 0;
524  }
525 
526  switch (surface->map->
527  info.flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD)) {
528  case SDL_COPY_BLEND:
530  break;
531  case SDL_COPY_ADD:
533  break;
534  case SDL_COPY_MOD:
536  break;
537  default:
539  break;
540  }
541  return 0;
542 }
#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

◆ SDL_GetSurfaceColorMod()

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 424 of file SDL_surface.c.

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

425 {
426  if (!surface) {
427  return -1;
428  }
429 
430  if (r) {
431  *r = surface->map->info.r;
432  }
433  if (g) {
434  *g = surface->map->info.g;
435  }
436  if (b) {
437  *b = surface->map->info.b;
438  }
439  return 0;
440 }
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_GetYUVConversionMode()

SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionMode ( void  )

Get the YUV conversion mode.

Definition at line 41 of file SDL_yuv.c.

References SDL_YUV_ConversionMode.

Referenced by SDL_GetYUVConversionModeForResolution().

42 {
44 }
static SDL_YUV_CONVERSION_MODE SDL_YUV_ConversionMode
Definition: SDL_yuv.c:33

◆ SDL_GetYUVConversionModeForResolution()

SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionModeForResolution ( int  width,
int  height 
)

Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC.

Definition at line 46 of file SDL_yuv.c.

References SDL_GetYUVConversionMode(), SDL_YUV_CONVERSION_AUTOMATIC, SDL_YUV_CONVERSION_BT601, SDL_YUV_CONVERSION_BT709, and SDL_YUV_SD_THRESHOLD.

Referenced by GetYUVConversionType(), and SDL_ConvertPixels_ARGB8888_to_YUV().

47 {
49  if (mode == SDL_YUV_CONVERSION_AUTOMATIC) {
52  } else {
54  }
55  }
56  return mode;
57 }
SDL_YUV_CONVERSION_MODE
The formula used for converting between YUV and RGB.
Definition: SDL_surface.h:103
GLenum mode
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
#define SDL_YUV_SD_THRESHOLD
Definition: SDL_yuv.c:30
SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionMode()
Get the YUV conversion mode.
Definition: SDL_yuv.c:41

◆ SDL_HasColorKey()

SDL_bool SDL_HasColorKey ( SDL_Surface surface)

Returns whether the surface has a color key.

Returns
SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key

Definition at line 296 of file SDL_surface.c.

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

297 {
298  if (!surface) {
299  return SDL_FALSE;
300  }
301 
302  if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
303  return SDL_FALSE;
304  }
305 
306  return SDL_TRUE;
307 }
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_BlitInfo info
Definition: SDL_blit.h:92

◆ SDL_LoadBMP_RW()

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 (biWidth <= 0 || biHeight == 0) {
230  SDL_SetError("BMP file with bad dimensions (%dx%d)", biWidth, biHeight);
231  was_error = SDL_TRUE;
232  goto done;
233  }
234  if (biHeight < 0) {
235  topDown = SDL_TRUE;
236  biHeight = -biHeight;
237  } else {
238  topDown = SDL_FALSE;
239  }
240 
241  /* Check for read error */
242  if (SDL_strcmp(SDL_GetError(), "") != 0) {
243  was_error = SDL_TRUE;
244  goto done;
245  }
246 
247  /* Expand 1 and 4 bit bitmaps to 8 bits per pixel */
248  switch (biBitCount) {
249  case 1:
250  case 4:
251  ExpandBMP = biBitCount;
252  biBitCount = 8;
253  break;
254  case 2:
255  case 3:
256  case 5:
257  case 6:
258  case 7:
259  SDL_SetError("%d-bpp BMP images are not supported", biBitCount);
260  was_error = SDL_TRUE;
261  goto done;
262  default:
263  ExpandBMP = 0;
264  break;
265  }
266 
267  /* We don't support any BMP compression right now */
268  switch (biCompression) {
269  case BI_RGB:
270  /* If there are no masks, use the defaults */
271  SDL_assert(!haveRGBMasks);
272  SDL_assert(!haveAlphaMask);
273  /* Default values for the BMP format */
274  switch (biBitCount) {
275  case 15:
276  case 16:
277  Rmask = 0x7C00;
278  Gmask = 0x03E0;
279  Bmask = 0x001F;
280  break;
281  case 24:
282 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
283  Rmask = 0x000000FF;
284  Gmask = 0x0000FF00;
285  Bmask = 0x00FF0000;
286 #else
287  Rmask = 0x00FF0000;
288  Gmask = 0x0000FF00;
289  Bmask = 0x000000FF;
290 #endif
291  break;
292  case 32:
293  /* We don't know if this has alpha channel or not */
294  correctAlpha = SDL_TRUE;
295  Amask = 0xFF000000;
296  Rmask = 0x00FF0000;
297  Gmask = 0x0000FF00;
298  Bmask = 0x000000FF;
299  break;
300  default:
301  break;
302  }
303  break;
304 
305  case BI_BITFIELDS:
306  break; /* we handled this in the info header. */
307 
308  default:
309  SDL_SetError("Compressed BMP files not supported");
310  was_error = SDL_TRUE;
311  goto done;
312  }
313 
314  /* Create a compatible surface, note that the colors are RGB ordered */
315  surface =
316  SDL_CreateRGBSurface(0, biWidth, biHeight, biBitCount, Rmask, Gmask,
317  Bmask, Amask);
318  if (surface == NULL) {
319  was_error = SDL_TRUE;
320  goto done;
321  }
322 
323  /* Load the palette, if any */
324  palette = (surface->format)->palette;
325  if (palette) {
326  SDL_assert(biBitCount <= 8);
327  if (biClrUsed == 0) {
328  biClrUsed = 1 << biBitCount;
329  } else if (biClrUsed > (1 << biBitCount)) {
330  SDL_SetError("BMP file has an invalid number of colors");
331  was_error = SDL_TRUE;
332  goto done;
333  }
334  if ((int) biClrUsed > palette->ncolors) {
335  SDL_Color *colors;
336  int ncolors = biClrUsed;
337  colors =
338  (SDL_Color *) SDL_realloc(palette->colors,
339  ncolors *
340  sizeof(*palette->colors));
341  if (!colors) {
342  SDL_OutOfMemory();
343  was_error = SDL_TRUE;
344  goto done;
345  }
346  palette->ncolors = ncolors;
347  palette->colors = colors;
348  } else if ((int) biClrUsed < palette->ncolors) {
349  palette->ncolors = biClrUsed;
350  }
351  if (biSize == 12) {
352  for (i = 0; i < (int) biClrUsed; ++i) {
353  SDL_RWread(src, &palette->colors[i].b, 1, 1);
354  SDL_RWread(src, &palette->colors[i].g, 1, 1);
355  SDL_RWread(src, &palette->colors[i].r, 1, 1);
356  palette->colors[i].a = SDL_ALPHA_OPAQUE;
357  }
358  } else {
359  for (i = 0; i < (int) biClrUsed; ++i) {
360  SDL_RWread(src, &palette->colors[i].b, 1, 1);
361  SDL_RWread(src, &palette->colors[i].g, 1, 1);
362  SDL_RWread(src, &palette->colors[i].r, 1, 1);
363  SDL_RWread(src, &palette->colors[i].a, 1, 1);
364 
365  /* According to Microsoft documentation, the fourth element
366  is reserved and must be zero, so we shouldn't treat it as
367  alpha.
368  */
369  palette->colors[i].a = SDL_ALPHA_OPAQUE;
370  }
371  }
372  }
373 
374  /* Read the surface pixels. Note that the bmp image is upside down */
375  if (SDL_RWseek(src, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
377  was_error = SDL_TRUE;
378  goto done;
379  }
380  top = (Uint8 *)surface->pixels;
381  end = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
382  switch (ExpandBMP) {
383  case 1:
384  bmpPitch = (biWidth + 7) >> 3;
385  pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
386  break;
387  case 4:
388  bmpPitch = (biWidth + 1) >> 1;
389  pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
390  break;
391  default:
392  pad = ((surface->pitch % 4) ? (4 - (surface->pitch % 4)) : 0);
393  break;
394  }
395  if (topDown) {
396  bits = top;
397  } else {
398  bits = end - surface->pitch;
399  }
400  while (bits >= top && bits < end) {
401  switch (ExpandBMP) {
402  case 1:
403  case 4:{
404  Uint8 pixel = 0;
405  int shift = (8 - ExpandBMP);
406  for (i = 0; i < surface->w; ++i) {
407  if (i % (8 / ExpandBMP) == 0) {
408  if (!SDL_RWread(src, &pixel, 1, 1)) {
409  SDL_SetError("Error reading from BMP");
410  was_error = SDL_TRUE;
411  goto done;
412  }
413  }
414 
415  bits[i] = (pixel >> shift);
416  if (bits[i] >= biClrUsed) {
417  SDL_SetError("A BMP image contains a pixel with a color out of the palette");
418  was_error = SDL_TRUE;
419  goto done;
420  }
421  pixel <<= ExpandBMP;
422  }
423  }
424  break;
425 
426  default:
427  if (SDL_RWread(src, bits, 1, surface->pitch) != surface->pitch) {
429  was_error = SDL_TRUE;
430  goto done;
431  }
432  if (biBitCount == 8 && palette && biClrUsed < (1 << biBitCount)) {
433  for (i = 0; i < surface->w; ++i) {
434  if (bits[i] >= biClrUsed) {
435  SDL_SetError("A BMP image contains a pixel with a color out of the palette");
436  was_error = SDL_TRUE;
437  goto done;
438  }
439  }
440  }
441 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
442  /* Byte-swap the pixels if needed. Note that the 24bpp
443  case has already been taken care of above. */
444  switch (biBitCount) {
445  case 15:
446  case 16:{
447  Uint16 *pix = (Uint16 *) bits;
448  for (i = 0; i < surface->w; i++)
449  pix[i] = SDL_Swap16(pix[i]);
450  break;
451  }
452 
453  case 32:{
454  Uint32 *pix = (Uint32 *) bits;
455  for (i = 0; i < surface->w; i++)
456  pix[i] = SDL_Swap32(pix[i]);
457  break;
458  }
459  }
460 #endif
461  break;
462  }
463  /* Skip padding bytes, ugh */
464  if (pad) {
465  Uint8 padbyte;
466  for (i = 0; i < pad; ++i) {
467  SDL_RWread(src, &padbyte, 1, 1);
468  }
469  }
470  if (topDown) {
471  bits += surface->pitch;
472  } else {
473  bits -= surface->pitch;
474  }
475  }
476  if (correctAlpha) {
477  CorrectAlphaChannel(surface);
478  }
479  done:
480  if (was_error) {
481  if (src) {
482  SDL_RWseek(src, fp_offset, RW_SEEK_SET);
483  }
484  SDL_FreeSurface(surface);
485  surface = NULL;
486  }
487  if (freesrc && src) {
488  SDL_RWclose(src);
489  }
490  return (surface);
491 }
#define BI_RGB
Definition: SDL_bmp.c:45
#define SDL_ClearError
#define SDL_GetError
Uint8 g
Definition: SDL_pixels.h:298
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
uint16_t Uint16
Definition: SDL_stdinc.h:191
#define SDL_ReadLE32
#define SDL_RWread(ctx, ptr, size, n)
Definition: SDL_rwops.h:187
Uint8 b
Definition: SDL_pixels.h:299
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
#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
Uint8 r
Definition: SDL_pixels.h:297
void * pixels
Definition: SDL_surface.h:75
#define SDL_FreeSurface
Uint8 a
Definition: SDL_pixels.h:300
uint8_t Uint8
Definition: SDL_stdinc.h:179
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:197
#define BI_BITFIELDS
Definition: SDL_bmp.c:48
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_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:161
SDL_Color * colors
Definition: SDL_pixels.h:307
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
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define RW_SEEK_SET
Definition: SDL_rwops.h:174
#define SDL_strcmp
#define RW_SEEK_CUR
Definition: SDL_rwops.h:175
int64_t Sint64
Definition: SDL_stdinc.h:210
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

◆ SDL_LockSurface()

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 891 of file SDL_surface.c.

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

Referenced by SDL_ConvertColorkeyToAlpha().

892 {
893  if (!surface->locked) {
894  /* Perform the lock */
895  if (surface->flags & SDL_RLEACCEL) {
896  SDL_UnRLESurface(surface, 1);
897  surface->flags |= SDL_RLEACCEL; /* save accel'd state */
898  }
899  }
900 
901  /* Increment the surface lock count, for recursive locks */
902  ++surface->locked;
903 
904  /* Ready to go.. */
905  return (0);
906 }
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Uint32 flags
Definition: SDL_surface.h:71
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

◆ SDL_LowerBlit()

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 588 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().

590 {
591  /* Check to make sure the blit mapping is valid */
592  if ((src->map->dst != dst) ||
593  (dst->format->palette &&
594  src->map->dst_palette_version != dst->format->palette->version) ||
595  (src->format->palette &&
596  src->map->src_palette_version != src->format->palette->version)) {
597  if (SDL_MapSurface(src, dst) < 0) {
598  return (-1);
599  }
600  /* just here for debugging */
601 /* printf */
602 /* ("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", */
603 /* src, dst->flags, src->map->info.flags, dst, dst->flags, */
604 /* dst->map->info.flags, src->map->blit); */
605  }
606  return (src->map->blit(src, srcrect, dst, dstrect));
607 }
Uint32 version
Definition: SDL_pixels.h:308
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:991
SDL_Surface * dst
Definition: SDL_blit.h:88
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_Palette * palette
Definition: SDL_pixels.h:318

◆ SDL_LowerBlitScaled()

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 864 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().

866 {
867  static const Uint32 complex_copy_flags = (
871  );
872 
873  if (!(src->map->info.flags & SDL_COPY_NEAREST)) {
874  src->map->info.flags |= SDL_COPY_NEAREST;
875  SDL_InvalidateMap(src->map);
876  }
877 
878  if ( !(src->map->info.flags & complex_copy_flags) &&
879  src->format->format == dst->format->format &&
881  return SDL_SoftStretch( src, srcrect, dst, dstrect );
882  } else {
883  return SDL_LowerBlit( src, srcrect, dst, dstrect );
884  }
885 }
#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
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:588
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
#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
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitInfo info
Definition: SDL_blit.h:92

◆ SDL_SaveBMP_RW()

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 494 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.

495 {
496  Sint64 fp_offset;
497  int i, pad;
499  Uint8 *bits;
500  SDL_bool save32bit = SDL_FALSE;
501  SDL_bool saveLegacyBMP = SDL_FALSE;
502 
503  /* The Win32 BMP file header (14 bytes) */
504  char magic[2] = { 'B', 'M' };
505  Uint32 bfSize;
506  Uint16 bfReserved1;
507  Uint16 bfReserved2;
508  Uint32 bfOffBits;
509 
510  /* The Win32 BITMAPINFOHEADER struct (40 bytes) */
511  Uint32 biSize;
512  Sint32 biWidth;
513  Sint32 biHeight;
514  Uint16 biPlanes;
515  Uint16 biBitCount;
516  Uint32 biCompression;
517  Uint32 biSizeImage;
518  Sint32 biXPelsPerMeter;
519  Sint32 biYPelsPerMeter;
520  Uint32 biClrUsed;
521  Uint32 biClrImportant;
522 
523  /* The additional header members from the Win32 BITMAPV4HEADER struct (108 bytes in total) */
524  Uint32 bV4RedMask = 0;
525  Uint32 bV4GreenMask = 0;
526  Uint32 bV4BlueMask = 0;
527  Uint32 bV4AlphaMask = 0;
528  Uint32 bV4CSType = 0;
529  Sint32 bV4Endpoints[3 * 3] = {0};
530  Uint32 bV4GammaRed = 0;
531  Uint32 bV4GammaGreen = 0;
532  Uint32 bV4GammaBlue = 0;
533 
534  /* Make sure we have somewhere to save */
535  surface = NULL;
536  if (dst) {
537 #ifdef SAVE_32BIT_BMP
538  /* We can save alpha information in a 32-bit BMP */
539  if (saveme->format->BitsPerPixel >= 8 && (saveme->format->Amask ||
540  saveme->map->info.flags & SDL_COPY_COLORKEY)) {
541  save32bit = SDL_TRUE;
542  }
543 #endif /* SAVE_32BIT_BMP */
544 
545  if (saveme->format->palette && !save32bit) {
546  if (saveme->format->BitsPerPixel == 8) {
547  surface = saveme;
548  } else {
549  SDL_SetError("%d bpp BMP files not supported",
550  saveme->format->BitsPerPixel);
551  }
552  } else if ((saveme->format->BitsPerPixel == 24) && !save32bit &&
554  (saveme->format->Rmask == 0x00FF0000) &&
555  (saveme->format->Gmask == 0x0000FF00) &&
556  (saveme->format->Bmask == 0x000000FF)
557 #else
558  (saveme->format->Rmask == 0x000000FF) &&
559  (saveme->format->Gmask == 0x0000FF00) &&
560  (saveme->format->Bmask == 0x00FF0000)
561 #endif
562  ) {
563  surface = saveme;
564  } else {
566 
567  /* If the surface has a colorkey or alpha channel we'll save a
568  32-bit BMP with alpha channel, otherwise save a 24-bit BMP. */
569  if (save32bit) {
571  } else {
573  }
574  surface = SDL_ConvertSurface(saveme, &format, 0);
575  if (!surface) {
576  SDL_SetError("Couldn't convert image to %d bpp",
577  format.BitsPerPixel);
578  }
579  }
580  } else {
581  /* Set no error here because it may overwrite a more useful message from
582  SDL_RWFromFile() if SDL_SaveBMP_RW() is called from SDL_SaveBMP(). */
583  return -1;
584  }
585 
586  if (save32bit) {
588  }
589 
590  if (surface && (SDL_LockSurface(surface) == 0)) {
591  const int bw = surface->w * surface->format->BytesPerPixel;
592 
593  /* Set the BMP file header values */
594  bfSize = 0; /* We'll write this when we're done */
595  bfReserved1 = 0;
596  bfReserved2 = 0;
597  bfOffBits = 0; /* We'll write this when we're done */
598 
599  /* Write the BMP file header values */
600  fp_offset = SDL_RWtell(dst);
601  SDL_ClearError();
602  SDL_RWwrite(dst, magic, 2, 1);
603  SDL_WriteLE32(dst, bfSize);
604  SDL_WriteLE16(dst, bfReserved1);
605  SDL_WriteLE16(dst, bfReserved2);
606  SDL_WriteLE32(dst, bfOffBits);
607 
608  /* Set the BMP info values */
609  biSize = 40;
610  biWidth = surface->w;
611  biHeight = surface->h;
612  biPlanes = 1;
613  biBitCount = surface->format->BitsPerPixel;
614  biCompression = BI_RGB;
615  biSizeImage = surface->h * surface->pitch;
616  biXPelsPerMeter = 0;
617  biYPelsPerMeter = 0;
618  if (surface->format->palette) {
619  biClrUsed = surface->format->palette->ncolors;
620  } else {
621  biClrUsed = 0;
622  }
623  biClrImportant = 0;
624 
625  /* Set the BMP info values for the version 4 header */
626  if (save32bit && !saveLegacyBMP) {
627  biSize = 108;
628  biCompression = BI_BITFIELDS;
629  /* The BMP format is always little endian, these masks stay the same */
630  bV4RedMask = 0x00ff0000;
631  bV4GreenMask = 0x0000ff00;
632  bV4BlueMask = 0x000000ff;
633  bV4AlphaMask = 0xff000000;
634  bV4CSType = LCS_WINDOWS_COLOR_SPACE;
635  bV4GammaRed = 0;
636  bV4GammaGreen = 0;
637  bV4GammaBlue = 0;
638  }
639 
640  /* Write the BMP info values */
641  SDL_WriteLE32(dst, biSize);
642  SDL_WriteLE32(dst, biWidth);
643  SDL_WriteLE32(dst, biHeight);
644  SDL_WriteLE16(dst, biPlanes);
645  SDL_WriteLE16(dst, biBitCount);
646  SDL_WriteLE32(dst, biCompression);
647  SDL_WriteLE32(dst, biSizeImage);
648  SDL_WriteLE32(dst, biXPelsPerMeter);
649  SDL_WriteLE32(dst, biYPelsPerMeter);
650  SDL_WriteLE32(dst, biClrUsed);
651  SDL_WriteLE32(dst, biClrImportant);
652 
653  /* Write the BMP info values for the version 4 header */
654  if (save32bit && !saveLegacyBMP) {
655  SDL_WriteLE32(dst, bV4RedMask);
656  SDL_WriteLE32(dst, bV4GreenMask);
657  SDL_WriteLE32(dst, bV4BlueMask);
658  SDL_WriteLE32(dst, bV4AlphaMask);
659  SDL_WriteLE32(dst, bV4CSType);
660  for (i = 0; i < 3 * 3; i++) {
661  SDL_WriteLE32(dst, bV4Endpoints[i]);
662  }
663  SDL_WriteLE32(dst, bV4GammaRed);
664  SDL_WriteLE32(dst, bV4GammaGreen);
665  SDL_WriteLE32(dst, bV4GammaBlue);
666  }
667 
668  /* Write the palette (in BGR color order) */
669  if (surface->format->palette) {
670  SDL_Color *colors;
671  int ncolors;
672 
673  colors = surface->format->palette->colors;
674  ncolors = surface->format->palette->ncolors;
675  for (i = 0; i < ncolors; ++i) {
676  SDL_RWwrite(dst, &colors[i].b, 1, 1);
677  SDL_RWwrite(dst, &colors[i].g, 1, 1);
678  SDL_RWwrite(dst, &colors[i].r, 1, 1);
679  SDL_RWwrite(dst, &colors[i].a, 1, 1);
680  }
681  }
682 
683  /* Write the bitmap offset */
684  bfOffBits = (Uint32)(SDL_RWtell(dst) - fp_offset);
685  if (SDL_RWseek(dst, fp_offset + 10, RW_SEEK_SET) < 0) {
687  }
688  SDL_WriteLE32(dst, bfOffBits);
689  if (SDL_RWseek(dst, fp_offset + bfOffBits, RW_SEEK_SET) < 0) {
691  }
692 
693  /* Write the bitmap image upside down */
694  bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
695  pad = ((bw % 4) ? (4 - (bw % 4)) : 0);
696  while (bits > (Uint8 *) surface->pixels) {
697  bits -= surface->pitch;
698  if (SDL_RWwrite(dst, bits, 1, bw) != bw) {
700  break;
701  }
702  if (pad) {
703  const Uint8 padbyte = 0;
704  for (i = 0; i < pad; ++i) {
705  SDL_RWwrite(dst, &padbyte, 1, 1);
706  }
707  }
708  }
709 
710  /* Write the BMP file size */
711  bfSize = (Uint32)(SDL_RWtell(dst) - fp_offset);
712  if (SDL_RWseek(dst, fp_offset + 2, RW_SEEK_SET) < 0) {
714  }
715  SDL_WriteLE32(dst, bfSize);
716  if (SDL_RWseek(dst, fp_offset + bfSize, RW_SEEK_SET) < 0) {
718  }
719 
720  /* Close it up.. */
721  SDL_UnlockSurface(surface);
722  if (surface != saveme) {
723  SDL_FreeSurface(surface);
724  }
725  }
726 
727  if (freedst && dst) {
728  SDL_RWclose(dst);
729  }
730  return ((SDL_strcmp(SDL_GetError(), "") == 0) ? 0 : -1);
731 }
#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:320
#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
uint16_t Uint16
Definition: SDL_stdinc.h:191
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
#define SDL_Error
#define SDL_GetHintBoolean
#define SDL_RWseek(ctx, offset, whence)
Definition: SDL_rwops.h:185
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:179
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319
#define SDL_HINT_BMP_SAVE_LEGACY_FORMAT
Prevent SDL from using version 4 of the bitmap header when saving BMPs.
Definition: SDL_hints.h:932
int32_t Sint32
Definition: SDL_stdinc.h:197
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:537
#define BI_BITFIELDS
Definition: SDL_bmp.c:48
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 NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:161
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_RWclose(ctx)
Definition: SDL_rwops.h:189
#define SDL_SetError
#define SDL_LockSurface
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define SDL_WriteLE32
#define RW_SEEK_SET
Definition: SDL_rwops.h:174
SDL_Palette * palette
Definition: SDL_pixels.h:318
#define SDL_strcmp
int64_t Sint64
Definition: SDL_stdinc.h:210
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_SetClipRect()

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 545 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().

546 {
547  SDL_Rect full_rect;
548 
549  /* Don't do anything if there's no surface to act on */
550  if (!surface) {
551  return SDL_FALSE;
552  }
553 
554  /* Set up the full surface rectangle */
555  full_rect.x = 0;
556  full_rect.y = 0;
557  full_rect.w = surface->w;
558  full_rect.h = surface->h;
559 
560  /* Set the clipping rectangle */
561  if (!rect) {
562  surface->clip_rect = full_rect;
563  return SDL_TRUE;
564  }
565  return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
566 }
#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

◆ SDL_SetColorKey()

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 251 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().

252 {
253  int flags;
254 
255  if (!surface) {
256  return SDL_InvalidParamError("surface");
257  }
258 
259  if (surface->format->palette && key >= ((Uint32) surface->format->palette->ncolors)) {
260  return SDL_InvalidParamError("key");
261  }
262 
263  if (flag & SDL_RLEACCEL) {
264  SDL_SetSurfaceRLE(surface, 1);
265  }
266 
267  flags = surface->map->info.flags;
268  if (flag) {
269  surface->map->info.flags |= SDL_COPY_COLORKEY;
270  surface->map->info.colorkey = key;
271  if (surface->format->palette) {
272  surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_TRANSPARENT;
273  ++surface->format->palette->version;
274  if (!surface->format->palette->version) {
275  surface->format->palette->version = 1;
276  }
277  }
278  } else {
279  if (surface->format->palette) {
280  surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_OPAQUE;
281  ++surface->format->palette->version;
282  if (!surface->format->palette->version) {
283  surface->format->palette->version = 1;
284  }
285  }
286  surface->map->info.flags &= ~SDL_COPY_COLORKEY;
287  }
288  if (surface->map->info.flags != flags) {
289  SDL_InvalidateMap(surface->map);
290  }
291 
292  return 0;
293 }
Uint32 version
Definition: SDL_pixels.h:308
#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:230
#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:972
#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:300
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_PixelFormat * format
Definition: SDL_surface.h:72
GLbitfield flags
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_Palette * palette
Definition: SDL_pixels.h:318
#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

◆ SDL_SetSurfaceAlphaMod()

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 443 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().

444 {
445  int flags;
446 
447  if (!surface) {
448  return -1;
449  }
450 
451  surface->map->info.a = alpha;
452 
453  flags = surface->map->info.flags;
454  if (alpha != 0xFF) {
455  surface->map->info.flags |= SDL_COPY_MODULATE_ALPHA;
456  } else {
457  surface->map->info.flags &= ~SDL_COPY_MODULATE_ALPHA;
458  }
459  if (surface->map->info.flags != flags) {
460  SDL_InvalidateMap(surface->map);
461  }
462  return 0;
463 }
GLfloat GLfloat GLfloat alpha
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
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

◆ SDL_SetSurfaceBlendMode()

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 479 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().

480 {
481  int flags, status;
482 
483  if (!surface) {
484  return -1;
485  }
486 
487  status = 0;
488  flags = surface->map->info.flags;
489  surface->map->info.flags &=
491  switch (blendMode) {
492  case SDL_BLENDMODE_NONE:
493  break;
494  case SDL_BLENDMODE_BLEND:
495  surface->map->info.flags |= SDL_COPY_BLEND;
496  break;
497  case SDL_BLENDMODE_ADD:
498  surface->map->info.flags |= SDL_COPY_ADD;
499  break;
500  case SDL_BLENDMODE_MOD:
501  surface->map->info.flags |= SDL_COPY_MOD;
502  break;
503  default:
504  status = SDL_Unsupported();
505  break;
506  }
507 
508  if (surface->map->info.flags != flags) {
509  SDL_InvalidateMap(surface->map);
510  }
511 
512  return status;
513 }
#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:972
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

◆ SDL_SetSurfaceColorMod()

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 398 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().

399 {
400  int flags;
401 
402  if (!surface) {
403  return -1;
404  }
405 
406  surface->map->info.r = r;
407  surface->map->info.g = g;
408  surface->map->info.b = b;
409 
410  flags = surface->map->info.flags;
411  if (r != 0xFF || g != 0xFF || b != 0xFF) {
412  surface->map->info.flags |= SDL_COPY_MODULATE_COLOR;
413  } else {
414  surface->map->info.flags &= ~SDL_COPY_MODULATE_COLOR;
415  }
416  if (surface->map->info.flags != flags) {
417  SDL_InvalidateMap(surface->map);
418  }
419  return 0;
420 }
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:972
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

◆ SDL_SetSurfacePalette()

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 216 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().

217 {
218  if (!surface) {
219  return SDL_SetError("SDL_SetSurfacePalette() passed a NULL surface");
220  }
221  if (SDL_SetPixelFormatPalette(surface->format, palette) < 0) {
222  return -1;
223  }
224  SDL_InvalidateMap(surface->map);
225 
226  return 0;
227 }
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_SetError
#define SDL_SetPixelFormatPalette

◆ SDL_SetSurfaceRLE()

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 230 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().

231 {
232  int flags;
233 
234  if (!surface) {
235  return -1;
236  }
237 
238  flags = surface->map->info.flags;
239  if (flag) {
240  surface->map->info.flags |= SDL_COPY_RLE_DESIRED;
241  } else {
242  surface->map->info.flags &= ~SDL_COPY_RLE_DESIRED;
243  }
244  if (surface->map->info.flags != flags) {
245  SDL_InvalidateMap(surface->map);
246  }
247  return 0;
248 }
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
GLbitfield flags
SDL_BlitInfo info
Definition: SDL_blit.h:92

◆ SDL_SetYUVConversionMode()

void SDL_SetYUVConversionMode ( SDL_YUV_CONVERSION_MODE  mode)

Set the YUV conversion mode.

Definition at line 36 of file SDL_yuv.c.

References SDL_YUV_ConversionMode.

37 {
39 }
GLenum mode
static SDL_YUV_CONVERSION_MODE SDL_YUV_ConversionMode
Definition: SDL_yuv.c:33

◆ SDL_SoftStretch()

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:320
uint16_t Uint16
Definition: SDL_stdinc.h:191
GLfixed u1
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:179
#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:161
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
uint32_t Uint32
Definition: SDL_stdinc.h:203
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

◆ SDL_UnlockSurface()

void SDL_UnlockSurface ( SDL_Surface surface)
See also
SDL_LockSurface()

Definition at line 912 of file SDL_surface.c.

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

Referenced by SDL_ConvertColorkeyToAlpha(), and SDL_FreeSurface().

913 {
914  /* Only perform an unlock if we are locked */
915  if (!surface->locked || (--surface->locked > 0)) {
916  return;
917  }
918 
919  /* Update RLE encoded surface with new data */
920  if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
921  surface->flags &= ~SDL_RLEACCEL; /* stop lying */
922  SDL_RLESurface(surface);
923  }
924 }
Uint32 flags
Definition: SDL_surface.h:71
int SDL_RLESurface(SDL_Surface *surface)
#define SDL_RLEACCEL
Definition: SDL_surface.h:54

◆ SDL_UpperBlit()

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 611 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.

613 {
614  SDL_Rect fulldst;
615  int srcx, srcy, w, h;
616 
617  /* Make sure the surfaces aren't locked */
618  if (!src || !dst) {
619  return SDL_SetError("SDL_UpperBlit: passed a NULL surface");
620  }
621  if (src->locked || dst->locked) {
622  return SDL_SetError("Surfaces must not be locked during blit");
623  }
624 
625  /* If the destination rectangle is NULL, use the entire dest surface */
626  if (dstrect == NULL) {
627  fulldst.x = fulldst.y = 0;
628  fulldst.w = dst->w;
629  fulldst.h = dst->h;
630  dstrect = &fulldst;
631  }
632 
633  /* clip the source rectangle to the source surface */
634  if (srcrect) {
635  int maxw, maxh;
636 
637  srcx = srcrect->x;
638  w = srcrect->w;
639  if (srcx < 0) {
640  w += srcx;
641  dstrect->x -= srcx;
642  srcx = 0;
643  }
644  maxw = src->w - srcx;
645  if (maxw < w)
646  w = maxw;
647 
648  srcy = srcrect->y;
649  h = srcrect->h;
650  if (srcy < 0) {
651  h += srcy;
652  dstrect->y -= srcy;
653  srcy = 0;
654  }
655  maxh = src->h - srcy;
656  if (maxh < h)
657  h = maxh;
658 
659  } else {
660  srcx = srcy = 0;
661  w = src->w;
662  h = src->h;
663  }
664 
665  /* clip the destination rectangle against the clip rectangle */
666  {
667  SDL_Rect *clip = &dst->clip_rect;
668  int dx, dy;
669 
670  dx = clip->x - dstrect->x;
671  if (dx > 0) {
672  w -= dx;
673  dstrect->x += dx;
674  srcx += dx;
675  }
676  dx = dstrect->x + w - clip->x - clip->w;
677  if (dx > 0)
678  w -= dx;
679 
680  dy = clip->y - dstrect->y;
681  if (dy > 0) {
682  h -= dy;
683  dstrect->y += dy;
684  srcy += dy;
685  }
686  dy = dstrect->y + h - clip->y - clip->h;
687  if (dy > 0)
688  h -= dy;
689  }
690 
691  /* Switch back to a fast blit if we were previously stretching */
692  if (src->map->info.flags & SDL_COPY_NEAREST) {
693  src->map->info.flags &= ~SDL_COPY_NEAREST;
694  SDL_InvalidateMap(src->map);
695  }
696 
697  if (w > 0 && h > 0) {
698  SDL_Rect sr;
699  sr.x = srcx;
700  sr.y = srcy;
701  sr.w = dstrect->w = w;
702  sr.h = dstrect->h = h;
703  return SDL_LowerBlit(src, &sr, dst, dstrect);
704  }
705  dstrect->w = dstrect->h = 0;
706  return 0;
707 }
GLfloat GLfloat GLfloat GLfloat h
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:588
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
#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

◆ SDL_UpperBlitScaled()

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 710 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.

712 {
713  double src_x0, src_y0, src_x1, src_y1;
714  double dst_x0, dst_y0, dst_x1, dst_y1;
715  SDL_Rect final_src, final_dst;
716  double scaling_w, scaling_h;
717  int src_w, src_h;
718  int dst_w, dst_h;
719 
720  /* Make sure the surfaces aren't locked */
721  if (!src || !dst) {
722  return SDL_SetError("SDL_UpperBlitScaled: passed a NULL surface");
723  }
724  if (src->locked || dst->locked) {
725  return SDL_SetError("Surfaces must not be locked during blit");
726  }
727 
728  if (NULL == srcrect) {
729  src_w = src->w;
730  src_h = src->h;
731  } else {
732  src_w = srcrect->w;
733  src_h = srcrect->h;
734  }
735 
736  if (NULL == dstrect) {
737  dst_w = dst->w;
738  dst_h = dst->h;
739  } else {
740  dst_w = dstrect->w;
741  dst_h = dstrect->h;
742  }
743 
744  if (dst_w == src_w && dst_h == src_h) {
745  /* No scaling, defer to regular blit */
746  return SDL_BlitSurface(src, srcrect, dst, dstrect);
747  }
748 
749  scaling_w = (double)dst_w / src_w;
750  scaling_h = (double)dst_h / src_h;
751 
752  if (NULL == dstrect) {
753  dst_x0 = 0;
754  dst_y0 = 0;
755  dst_x1 = dst_w - 1;
756  dst_y1 = dst_h - 1;
757  } else {
758  dst_x0 = dstrect->x;
759  dst_y0 = dstrect->y;
760  dst_x1 = dst_x0 + dst_w - 1;
761  dst_y1 = dst_y0 + dst_h - 1;
762  }
763 
764  if (NULL == srcrect) {
765  src_x0 = 0;
766  src_y0 = 0;
767  src_x1 = src_w - 1;
768  src_y1 = src_h - 1;
769  } else {
770  src_x0 = srcrect->x;
771  src_y0 = srcrect->y;
772  src_x1 = src_x0 + src_w - 1;
773  src_y1 = src_y0 + src_h - 1;
774 
775  /* Clip source rectangle to the source surface */
776 
777  if (src_x0 < 0) {
778  dst_x0 -= src_x0 * scaling_w;
779  src_x0 = 0;
780  }
781 
782  if (src_x1 >= src->w) {
783  dst_x1 -= (src_x1 - src->w + 1) * scaling_w;
784  src_x1 = src->w - 1;
785  }
786 
787  if (src_y0 < 0) {
788  dst_y0 -= src_y0 * scaling_h;
789  src_y0 = 0;
790  }
791 
792  if (src_y1 >= src->h) {
793  dst_y1 -= (src_y1 - src->h + 1) * scaling_h;
794  src_y1 = src->h - 1;
795  }
796  }
797 
798  /* Clip destination rectangle to the clip rectangle */
799 
800  /* Translate to clip space for easier calculations */
801  dst_x0 -= dst->clip_rect.x;
802  dst_x1 -= dst->clip_rect.x;
803  dst_y0 -= dst->clip_rect.y;
804  dst_y1 -= dst->clip_rect.y;
805 
806  if (dst_x0 < 0) {
807  src_x0 -= dst_x0 / scaling_w;
808  dst_x0 = 0;
809  }
810 
811  if (dst_x1 >= dst->clip_rect.w) {
812  src_x1 -= (dst_x1 - dst->clip_rect.w + 1) / scaling_w;
813  dst_x1 = dst->clip_rect.w - 1;
814  }
815 
816  if (dst_y0 < 0) {
817  src_y0 -= dst_y0 / scaling_h;
818  dst_y0 = 0;
819  }
820 
821  if (dst_y1 >= dst->clip_rect.h) {
822  src_y1 -= (dst_y1 - dst->clip_rect.h + 1) / scaling_h;
823  dst_y1 = dst->clip_rect.h - 1;
824  }
825 
826  /* Translate back to surface coordinates */
827  dst_x0 += dst->clip_rect.x;
828  dst_x1 += dst->clip_rect.x;
829  dst_y0 += dst->clip_rect.y;
830  dst_y1 += dst->clip_rect.y;
831 
832  final_src.x = (int)SDL_floor(src_x0 + 0.5);
833  final_src.y = (int)SDL_floor(src_y0 + 0.5);
834  final_src.w = (int)SDL_floor(src_x1 + 1 + 0.5) - (int)SDL_floor(src_x0 + 0.5);
835  final_src.h = (int)SDL_floor(src_y1 + 1 + 0.5) - (int)SDL_floor(src_y0 + 0.5);
836 
837  final_dst.x = (int)SDL_floor(dst_x0 + 0.5);
838  final_dst.y = (int)SDL_floor(dst_y0 + 0.5);
839  final_dst.w = (int)SDL_floor(dst_x1 - dst_x0 + 1.5);
840  final_dst.h = (int)SDL_floor(dst_y1 - dst_y0 + 1.5);
841 
842  if (final_dst.w < 0)
843  final_dst.w = 0;
844  if (final_dst.h < 0)
845  final_dst.h = 0;
846 
847  if (dstrect)
848  *dstrect = final_dst;
849 
850  if (final_dst.w == 0 || final_dst.h == 0 ||
851  final_src.w <= 0 || final_src.h <= 0) {
852  /* No-op. */
853  return 0;
854  }
855 
856  return SDL_LowerBlitScaled(src, &final_src, dst, &final_dst);
857 }
#define SDL_BlitSurface
Definition: SDL_surface.h:483
#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:864
int y
Definition: SDL_rect.h:66
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64